feat: add utilities for typescript ast

EmmanuelAzuh · EmmanuelAzuh · commit b9f77dc6302d · 2016-06-21T17:56:01.000-07:00
'newroute-utility.ts' provides typescript utility functions to be used in the
new generate router command
diff --git a/addon/ng2/utilities/change.ts b/addon/ng2/utilities/change.ts
@@ -0,0 +1,103 @@
+'use strict';
+
+import * as Promise from 'ember-cli/lib/ext/promise';
+let fs = require('fs');
+
+const readFile =  Promise.denodeify(fs.readFile);
+const writeFile = Promise.denodeify(fs.writeFile);
+
+export interface Change {
+  /**
+   *  True on success, false otherwise.
+   */
+  apply(): Promise<void>;
+
+  // The file this change should be applied to. Some changes might not apply to
+  // a file (maybe the config).
+  path: string | null;
+
+  // The order this change should be applied. Normally the position inside the file.
+  // Changes are applied from the bottom of a file to the top.
+  order: number | null;
+
+  // The description of this change. This will be outputted in a dry or verbose run.
+  description: string;
+}
+
+
+/**
+ * Will add text to the source code.
+ */
+export class InsertChange implements Change {
+  const order: number;
+  const description: string;
+  constructor(
+    public path: string,
+    private pos: number,
+    private toAdd: string,
+    ) {
+      this.description = `Inserted ${toAdd} into position ${pos} of ${path}`;
+      this.order = pos;
+  }
+
+  /**
+   * This method does not insert spaces if there is none in the original string. 
+   * @param file (path to file)
+   * @param pos
+   * @param toAdd (text to add)
+   * @return Promise with a description on success or reject on error
+   */
+  apply(): Promise<any> {
+    return readFile(this.path, 'utf8').then(content => {
+      content = content.substring(0, this.pos) + this.toAdd + content.substring(this.pos);
+      return writeFile(this.path, content);
+    });
+  }
+}
+
+/**
+ * Will remove text from the source code.
+ */
+export class RemoveChange implements Change {
+  const order: number;
+  const description: string;
+
+  constructor(
+    public path: string,
+    private pos: number,
+    private toRemove: string) {
+      this.description = `Removed ${toRemove} into position ${pos} of ${path}`;
+      this.order = pos;
+    }
+
+  apply(): Promise<any> {
+    return readFile(this.path, 'utf8').then(content => {
+      content = content.substring(0, this.pos) + content.substring(this.pos + this.toRemove.length);
+      return writeFile(this.path, content);
+    });
+  }
+}
+
+/**
+ * Will replace text from the source code.
+ */
+export class ReplaceChange implements Change {
+  const order: number;
+  const description: string;
+
+  constructor(
+    public path: string,
+    private pos: number,
+    private oldText: string,
+    private newText: string) {
+      this.description = `Replaced ${oldText} into position ${pos} of ${path} with ${newText}`;
+      this.order = pos;
+  }
+
+  apply(): Promise<any> {
+    return readFile(this.path, 'utf8').then(content => {
+      content = content.substring(0, this.pos) + this.newText + content.substring(this.pos + this.oldText.length);
+      writeFile(this.path, content);
+    });
+  }
+}
diff --git a/addon/ng2/utilities/dynamic-path-parser.js b/addon/ng2/utilities/dynamic-path-parser.js
@@ -55,4 +55,4 @@ module.exports = function dynamicPathParser(project, entityName) {
   parsedPath.appRoot = appRoot
 
   return parsedPath;
-};
+};
diff --git a/addon/ng2/utilities/newroute-utilities.ts b/addon/ng2/utilities/newroute-utilities.ts
@@ -0,0 +1,133 @@
+import * as ts from 'typescript';
+import * as fs from 'fs';
+import * as edit from './change';
+
+export function removeRouteFromParent(){
+
+}
+
+export function findParentRouteFile(){
+
+}
+
+export function addRoutesToParent(){
+
+}
+
+/**
+* Add Import `import { symbolName } from fileName` if the import doesn't exit
+* already. Assumes fileToEdit can be resolved and accessed.
+* @param fileToEdit (file we want to add import to)
+* @param symbolName (item to import)
+* @param fileName (path to the file)
+*/
+
+export function insertImport(fileToEdit: string, symbolName: string, fileName: string): Promise<void> {
+  let rootNode = ts.createSourceFile(fileToEdit, fs.readFileSync(fileToEdit).toString(),
+                                                ts.ScriptTarget.ES6, true);
+  let allImports = findNodes(rootNode, ts.SyntaxKind.ImportDeclaration);
+
+  // get nodes that map to import statements from the file fileName
+  let relevantImports = allImports.filter(node => {
+    // StringLiteral of the ImportDeclaration is the import file (fileName in this case).
+    let importFiles = node.getChildren().filter(child => child.kind === ts.SyntaxKind.StringLiteral)
+                      .map(n => (<ts.StringLiteralTypeNode>n).text);
+    return importFiles.filter(file => file === fileName).length === 1;
+  });
+
+  if (relevantImports.length > 0) {
+
+    var importsAsterisk: boolean = false;
+    // imports from import file
+    let imports: ts.Node[] = [];
+    relevantImports.forEach(n => {
+      Array.prototype.push.apply(imports, findNodes(n, ts.SyntaxKind.Identifier));
+      if (findNodes(n, ts.SyntaxKind.AsteriskToken).length > 0) {
+        importsAsterisk = true;
+      }
+    });
+
+    // if imports * from fileName, don't add symbolName
+    if (importsAsterisk) {
+      return Promise.resolve();
+    }
+
+    let importTextNodes = imports.filter(n => (<ts.Identifier>n).text === symbolName);
+
+    // insert import if it's not there
+    if (importTextNodes.length === 0) {
+      let fallbackPos = findNodes(relevantImports[0], ts.SyntaxKind.CloseBraceToken)[0].pos ||
+                        findNodes(relevantImports[0], ts.SyntaxKind.FromKeyword)[0].pos;
+      return insertAfterLastOccurence(imports, ', ', symbolName, fileToEdit, fallbackPos);
+    }
+    return Promise.resolve();
+  }
+  // no such import declaration exists
+  let useStrict = findNodes(rootNode, ts.SyntaxKind.StringLiteral).filter(n => n.text === 'use strict');
+  let fallbackPos: number = 0;
+  if(useStrict.length > 0){
+    fallbackPos = useStrict[0].end;
+  }
+  return insertAfterLastOccurence(allImports, ';\n', 'import { ' + symbolName + ' } from \'' + fileName + '\'',
+                             fileToEdit, fallbackPos, ts.SyntaxKind.StringLiteral)
+};
+
+/**
+* Find all nodes from the AST in the subtree of node of SyntaxKind kind.
+* @param node 
+* @param kind (a valid index of ts.SyntaxKind enum, eg ts.SyntaxKind.ImportDeclaration)
+* @return all nodes of kind kind, or [] if none is found
+*/
+export function findNodes (node: ts.Node, kind: number, arr: ts.Node[] = []): ts.Node[]{
+  if (node) {
+    if(node.kind === kind){
+      arr.push(node);
+    }
+    node.getChildren().forEach(child => findNodes(child, kind, arr));
+  }
+  return arr;
+}
+
+/**
+ * @param nodes (nodes to sort)
+ * @return (nodes sorted by their position from the source file 
+ *          or [] if nodes is empty)
+ */
+export function sortNodesByPosition(nodes: ts.Node[]): ts.Node[]{
+  if (nodes) {
+    return nodes.sort((first, second) => {return first.pos - second.pos});
+  }
+  return [];
+}
+
+/**
+ *
+ * Insert toInsert after the last occurence of ts.SyntaxKind[nodes[i].kind] 
+ * or after the last of occurence of syntaxKind if the last occurence is a sub child
+ * of ts.SyntaxKind[nodes[i].kind]
+ * @param nodes (insert after the last occurence of nodes)
+ * @param toInsert (string to insert)
+ * @param separator (separator between existing text that comes before
+ *                   the new text and toInsert)
+ * @param file (file to write the changes to)
+ * @param fallbackPos (position to insert if toInsert happens to be the first occurence)
+ * @param syntaxKind (the ts.SyntaxKind of the last subchild of the last
+ *                    occurence of nodes, after which we want to insert)
+ * @throw Error if toInsert is first occurence but fall back is not set
+ */
+export function insertAfterLastOccurence(nodes: ts.Node[], separator: string, toInsert:string, 
+                        file: string, fallbackPos?: number, syntaxKind?: ts.SyntaxKind): Promise<void> {
+  var lastItem = sortNodesByPosition(nodes).pop();
+  
+  if (syntaxKind) {
+    lastItem = sortNodesByPosition(findNodes(lastItem, syntaxKind)).pop(;
+  }
+  if (!lastItem && fallbackPos === undefined) {
+    return Promise.reject(new Error(`tried to insert ${toInsert} as first occurence with no fallback position`));
+  }
+  let lastItemPosition: number = lastItem? lastItem.end : fallbackPos;
+
+  let editFile = new edit.InsertChange(file, lastItemPosition, separator + toInsert);
+  return editFile.apply();
+}
+
diff --git a/tests/acceptance/change.spec.js b/tests/acceptance/change.spec.js
@@ -0,0 +1,135 @@
+'use strict';
+
+const expect = require('chai').expect;
+let path = require('path');
+let mockFs = require('mock-fs');
+let change = require('../../addon/ng2/utilities/change');
+let fs = require('fs');
+let Promise = require('ember-cli/lib/ext/promise');
+
+
+
+describe('Change: Testing operations', () => {
+  const readFile =  Promise.denodeify(fs.readFile);
+  let sourcePath = 'src/app/my-component';
+  
+  beforeEach(() => {
+    let mockDrive = {
+      'src/app/my-component': {
+        'add-file.txt': 'hello',
+        'remove-replace-file.txt': 'import * as foo from "./bar"',
+        'replace-file.txt': 'import { FooComponent } from "./baz"'
+      }
+    }
+    mockFs(mockDrive);
+  });
+
+  afterEach(() => {
+    mockFs.restore();
+  });
+
+  describe('InsertChange: add string to the source code', () => {
+    
+    it('should add text to the source code', () => {
+      let sourceFile = path.join(sourcePath, 'add-file.txt');
+      expect(fs.existsSync(sourceFile)).to.equal(true);
+      let changeInstance = new change.InsertChange(sourceFile, 6, ' world!');
+      return changeInstance
+        .apply()
+        .then(() => readFile(sourceFile, 'utf8'))
+        .then(contents => {
+          expect(contents).to.equal('hello world!');
+        })
+    })
+
+    it('should append string before any strings in the source code, and hence unexpected output', () => {
+      let sourceFile = path.join(sourcePath, 'add-file.txt');
+      expect(fs.existsSync(sourceFile)).to.equal(true);
+      let changeInstance = new change.InsertChange(sourceFile, -6, ' world!');
+      return changeInstance
+        .apply()
+        .then(() => readFile(sourceFile))
+        .then(contents => {
+          expect(contents).to.not.equal('hello world!');
+        });
+    })
+
+    it('should add nothing in the source code if empty string is inserted', () => {
+      let sourceFile = path.join(sourcePath, 'add-file.txt');
+      expect(fs.existsSync(sourceFile)).to.equal(true);
+      let changeInstance = new change.InsertChange(sourceFile, 6, '');
+      return changeInstance
+        .apply()
+        .then(() => readFile(sourceFile, 'utf8'))
+        .then(contents => {
+          expect(contents).to.equal('hello');
+        });
+    })
+  });
+
+  describe('RemoveChange: remove string from the source code', () => {
+    
+    it('should remove given text from the source code', () => {
+      let sourceFile = path.join(sourcePath, 'remove-replace-file.txt');
+      expect(fs.existsSync(sourceFile)).to.equal(true);
+      let changeInstance = new change.RemoveChange(sourceFile, 9, 'as foo');
+      return changeInstance
+        .apply()
+        .then(() => readFile(sourceFile, 'utf8'))
+        .then(contents => {
+          expect(contents).to.equal('import *  from "./bar"');
+        });
+    })
+
+    it('should remove nothing in the source code if empty string is to be removed', () => {
+      let sourceFile = path.join(sourcePath, 'remove-replace-file.txt');
+      expect(fs.existsSync(sourceFile)).to.equal(true);
+      let changeInstance = new change.RemoveChange(sourceFile, 9, '');
+      return changeInstance
+        .apply()
+        .then(() => readFile(sourceFile, 'utf8'))
+        .then(contents => {
+          expect(contents).to.equal('import * as foo from "./bar"');
+        });
+    })
+  });
+
+  describe('ReplaceChange: replace string in the source code', () => {
+
+    it('should replace a given text in the source code', () => {
+      let sourceFile = path.join(sourcePath, 'remove-replace-file.txt');
+      expect(fs.existsSync(sourceFile)).to.equal(true);
+      let changeInstance = new change.ReplaceChange(sourceFile, 7, '* as foo', '{ fooComponent }');
+      return changeInstance
+        .apply()
+        .then(() => readFile(sourceFile, 'utf8'))
+        .then(contents => {
+          expect(contents).to.equal('import { fooComponent } from "./bar"');
+        });
+    })
+
+    it('should add string to the position of an empty string', () => {
+      let sourceFile = path.join(sourcePath, 'replace-file.txt');
+      expect(fs.existsSync(sourceFile)).to.equal(true);
+      let changeInstance = new change.ReplaceChange(sourceFile, 9, '', 'BarComponent, ');
+      return changeInstance
+        .apply()
+        .then(() => readFile(sourceFile, 'utf8'))
+        .then(contents => {
+          expect(contents).to.equal('import { BarComponent, FooComponent } from "./baz"');
+        });
+    })
+
+    it('should removes the string in the given postion and add nothing if empty string is to be replaced', () => {
+      let sourceFile = path.join(sourcePath, 'remove-replace-file.txt');
+      expect(fs.existsSync(sourceFile)).to.equal(true);
+      let changeInstance = new change.ReplaceChange(sourceFile, 9, ' as foo', '');
+      return changeInstance
+        .apply()
+        .then(() => readFile(sourceFile, 'utf8'))
+        .then(contents => {
+          expect(contents).to.equal('import * from "./bar"');
+        });
+    })
+  });
+});
diff --git a/tests/acceptance/newroute.spec.js b/tests/acceptance/newroute.spec.js
diff --git a/tests/runner.js b/tests/runner.js
