refactor: Renamed writer to generator

Author: KnisterPeter

README.md

@@ -78,9 +78,9 @@ function generateFromAst(name, ast, options)
 ``` 
 
 Options:
-* writer  
-  An instance of the exported writer class. This options is usefull to write
-  multiple declarations into one .d.ts file. The writer could be used
+* generator  
+  An instance of the exported Generator class. This options is usefull to write
+  multiple declarations into one .d.ts file. The generator could be used
   for consecutive function calls.
 * instanceOfResolver  
   A function which gets a type name (as string) and should return the path

index.ts

@@ -11,9 +11,9 @@ export interface IOptions {
    */
   instanceOfResolver?: InstanceOfResolver;
   /**
-   * The writer generating .d.ts code with.
+   * The Generator generating .d.ts code with.
    */
-  writer?: Writer;
+  generator?: Generator;
 }
 
 interface IASTNode {
@@ -84,25 +84,25 @@ const defaultInstanceOfResolver: InstanceOfResolver = (name: string): string =>
 
 export function generateFromAst(name: string, ast: any, options: IOptions = {}): string {
   const {exportType, classname, propTypes}: IParsingResult = parseAst(ast, options.instanceOfResolver);
-  const writer: Writer = options.writer || new Writer();
-  writer.declareModule(name, () => {
-    writer.import('* as React', 'react');
+  const generator: Generator = options.generator || new Generator();
+  generator.declareModule(name, () => {
+    generator.import('* as React', 'react');
     if (propTypes) {
       Object.keys(propTypes).forEach((propName: string) => {
         const prop: IProp = propTypes[propName];
         if (prop.importPath) {
-          writer.import(prop.importType, prop.importPath);
+          generator.import(prop.importType, prop.importPath);
         }
       });
     }
-    writer.nl();
-    writer.props(classname, propTypes);
-    writer.nl();
-    writer.exportDeclaration(exportType, () => {
-      writer.class(classname, !!propTypes);
+    generator.nl();
+    generator.props(classname, propTypes);
+    generator.nl();
+    generator.exportDeclaration(exportType, () => {
+      generator.class(classname, !!propTypes);
     });
   });
-  return writer.toString();
+  return generator.toString();
 }
 
 enum ExportType {
@@ -288,7 +288,7 @@ export function getTypeFromPropType(node: IASTNode, instanceOfResolver: Instance
   return result;
 }
 
-export class Writer {
+export class Generator {
 
   private static NL: string = '\n';
 
@@ -305,7 +305,7 @@ export class Writer {
   }
 
   public nl(): void {
-    this.code += Writer.NL;
+    this.code += Generator.NL;
   }
 
   public declareModule(name: string, fn: () => void): void {

tests/generator-test.ts

@@ -0,0 +1,51 @@
+import { assert } from 'chai';
+import { Generator } from '../index';
+
+describe('The Generator', () => {
+  let generator: Generator;
+  beforeEach(() => {
+    generator = new Generator();
+  });
+  it('should write a module declaration', () => {
+    generator.declareModule('name', () => {
+      //
+    });
+    assert.equal(generator.toString(), "declare module 'name' {\n}\n");
+  });
+  it('should write an import statement', () => {
+    generator.import('decls', 'from');
+    assert.equal(generator.toString(), "import decls from 'from';\n");
+  });
+  it('should write a required property', () => {
+    generator.prop('name', 'type', false);
+    assert.equal(generator.toString(), 'name: type;\n');
+  });
+  it('should write an optional property', () => {
+    generator.prop('name', 'type', true);
+    assert.equal(generator.toString(), 'name?: type;\n');
+  });
+  it('should write a property interface', () => {
+    generator.props('Name', {prop: {type: 'type', optional: true}});
+    assert.equal(generator.toString(), 'interface NameProps {\n\tkey?: any;\n\tprop?: type;\n}\n');
+  });
+  it('should write a class with props declaration', () => {
+    generator.class('Name', true);
+    assert.equal(generator.toString(), 'class Name extends React.Component<NameProps, any> {\n}\n');
+  });
+  it('should write a class without props declaration', () => {
+    generator.class('Name', false);
+    assert.equal(generator.toString(), 'class Name extends React.Component<any, any> {\n}\n');
+  });
+  it('should write an indented block comment', () => {
+    generator.comment('* yada\n\t\t\t\tyada\n ');
+    assert.equal(generator.toString(), '/** yada\nyada\n */\n');
+  });
+  it('should write an export default declaration', () => {
+    generator.exportDeclaration(0, () => undefined);
+    assert.equal(generator.toString(), 'export default ');
+  });
+  it('should write a named export declaration', () => {
+    generator.exportDeclaration(1, () => undefined);
+    assert.equal(generator.toString(), 'export ');
+  });
+});

tests/writer-test.ts

@@ -10,6 +10,6 @@
     "index.ts",
     "tests/parsing-test.ts",
     "tests/parse-prop-types-test.ts",
-    "tests/writer-test.ts"
+    "tests/generator-test.ts"
   ]
 }