feat: add utilities for typescript ast

EmmanuelAzuh · EmmanuelAzuh · commit 46c965cbd1ca · 2016-07-13T14:56:25.000-07:00
'ast-utils.ts' provides typescript ast utility functions
diff --git a/addon/ng2/utilities/ast-utils.ts b/addon/ng2/utilities/ast-utils.ts
@@ -0,0 +1,53 @@
+import * as ts from 'typescript';
+import { InsertChange } from './change';
+/**
+* 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[] {
+  return nodes.sort((first, second) => {return first.pos - second.pos;});
+}
+
+/**
+ * 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] and save the changes in file.
+ *  
+ * @param nodes (insert after the last occurence of nodes)
+ * @param toInsert (string to insert)
+ * @param file (file to insert changes into)
+ * @param fallbackPos (position to insert if toInsert happens to be the first occurence)
+ * @param syntaxKind (the ts.SyntaxKind of the subchildren to insert after) 
+ * @return Change instance
+ * @throw Error if toInsert is first occurence but fall back is not set
+ */
+export function insertAfterLastOccurence(nodes: ts.Node[], toInsert: string, file: string,
+                        fallbackPos?: number, syntaxKind?: ts.SyntaxKind): Change {
+  var lastItem = sortNodesByPosition(nodes).pop();
+  if (syntaxKind) {
+    lastItem = sortNodesByPosition(findNodes(lastItem, syntaxKind)).pop();
+  }
+  if (!lastItem && fallbackPos == undefined) {
+    throw new Error(`tried to insert ${toInsert} as first occurence with no fallback position`);
+  }
+  let lastItemPosition: number = lastItem ? lastItem.end : fallbackPos;
+  return new InsertChange(file, lastItemPosition, toInsert);
+}
+
diff --git a/addon/ng2/utilities/dynamic-path-parser.js b/addon/ng2/utilities/dynamic-path-parser.js
@@ -55,4 +55,5 @@ module.exports = function dynamicPathParser(project, entityName) {
   parsedPath.appRoot = appRoot
 
   return parsedPath;
-};
+};
+
diff --git a/tests/acceptance/ast-utils.spec.ts b/tests/acceptance/ast-utils.spec.ts
@@ -0,0 +1,232 @@
+import * as mockFs from 'mock-fs';
+import { expect } from 'chai';
+import * as ts from 'typescript';
+import * as fs from 'fs';
+import { InsertChange, RemoveChange } from '../../addon/ng2/utilities/change';
+import {findNodes,
+        sortNodesByPosition,
+        insertAfterLastOccurence} from '../../addon/ng2/utilities/ast-utils';
+import * as Promise from 'ember-cli/lib/ext/promise';
+const readFile = Promise.denodeify(fs.readFile);
+
+describe('ast-utils: findNodes', () => {
+  const sourceFile = 'tmp/tmp.ts';
+
+  beforeEach(() => {
+    let mockDrive = {
+      'tmp': {
+        'tmp.ts': `import * as myTest from 'tests' \n` +
+                  'hello.'
+      }
+    };
+    mockFs(mockDrive);
+  });
+
+  afterEach(() => {
+    mockFs.restore();
+  });
+
+  it('finds no imports', () => {
+    let editedFile = new RemoveChange(sourceFile, 0, `import * as myTest from 'tests' \n`);
+    return editedFile
+    .apply()
+    .then(() => {
+      let rootNode = getRootNode(sourceFile);
+      let nodes = findNodes(rootNode, ts.SyntaxKind.ImportDeclaration);
+      expect(nodes).to.be.empty;
+    });
+  });
+  it('finds one import', () => {
+    let rootNode = getRootNode(sourceFile);
+    let nodes = findNodes(rootNode, ts.SyntaxKind.ImportDeclaration);
+    expect(nodes.length).to.equal(1);
+  });
+  it('finds two imports from inline declarations', () => {
+    // remove new line and add an inline import
+    let editedFile = new RemoveChange(sourceFile, 32, '\n');
+    return editedFile
+    .apply()
+    .then(() => {
+      let insert = new InsertChange(sourceFile, 32, `import {Routes} from '@angular/routes'`);
+      return insert.apply();
+    })
+    .then(() => {
+      let rootNode = getRootNode(sourceFile);
+      let nodes = findNodes(rootNode, ts.SyntaxKind.ImportDeclaration);
+      expect(nodes.length).to.equal(2);
+    });
+  });
+  it('finds two imports from new line separated declarations', () => {
+    let editedFile = new InsertChange(sourceFile, 33, `import {Routes} from '@angular/routes'`);
+    return editedFile
+    .apply()
+    .then(() => {
+      let rootNode = getRootNode(sourceFile);
+      let nodes = findNodes(rootNode, ts.SyntaxKind.ImportDeclaration);
+      expect(nodes.length).to.equal(2);
+    });
+  });
+});
+
+describe('ast-utils: sortNodesByPosition', () => {
+  const sourceFile = 'tmp/tmp.ts';
+  beforeEach(() => {
+    let mockDrive = {
+      'tmp': {
+        'tmp.ts': ''
+      }
+    };
+    mockFs(mockDrive);
+  });
+
+  afterEach(() => {
+    mockFs.restore();
+  });
+
+  it('gives an empty array', () => {
+    let nodes = getNodesOfKind(ts.SyntaxKind.ImportDeclaration, sourceFile);
+    let sortedNodes = sortNodesByPosition(nodes);
+    expect(sortedNodes).to.be.empty;
+  });
+
+  it('returns unity array', () => {
+    let editedFile = new InsertChange(sourceFile, 0, `import * as ts from 'ts'`);
+    return editedFile
+    .apply()
+    .then(() => {
+      let nodes = getNodesOfKind(ts.SyntaxKind.ImportDeclaration, sourceFile);
+      let sortedNodes = sortNodesByPosition(nodes);
+      expect(sortedNodes.length).to.equal(1);
+      expect(sortedNodes[0].pos).to.equal(0);
+    });
+  });
+  it('returns a sorted array of three components', () => {
+    let content = `import {Router} from '@angular/router'\n` +
+                  `import * as fs from 'fs'` +
+                  `import {  Component} from '@angular/core'\n`;
+    let editedFile = new InsertChange(sourceFile, 0, content);
+    return editedFile
+    .apply()
+    .then(() => {
+      let nodes = getNodesOfKind(ts.SyntaxKind.ImportDeclaration, sourceFile);
+      // shuffle up nodes
+      let shuffledNodes = [nodes[1], nodes[2], nodes[0]];
+      expect(shuffledNodes[0].pos).to.equal(38);
+      expect(shuffledNodes[1].pos).to.equal(63);
+      expect(shuffledNodes[2].pos).to.equal(0);
+
+      let sortedNodes = sortNodesByPosition(shuffledNodes);
+      expect(sortedNodes.length).to.equal(3);
+      expect(sortedNodes[0].pos).to.equal(0);
+      expect(sortedNodes[1].pos).to.equal(38);
+      expect(sortedNodes[2].pos).to.equal(63);
+    });
+  });
+});
+
+describe('ast-utils: insertAfterLastOccurence', () => {
+  const sourceFile = 'tmp/tmp.ts';
+  beforeEach(() => {
+    let mockDrive = {
+      'tmp': {
+        'tmp.ts': ''
+      }
+    };
+    mockFs(mockDrive);
+  });
+
+  afterEach(() => {
+    mockFs.restore();
+  });
+
+  it('inserts at beginning of file', () => {
+    let imports = getNodesOfKind(ts.SyntaxKind.ImportDeclaration, sourceFile);
+    return insertAfterLastOccurence(imports, `\nimport { Router } from '@angular/router';`,
+                                    sourceFile, 0)
+    .apply()
+    .then(() => {
+      return readFile(sourceFile, 'utf8');
+    }).then((content) => {
+      let expected = '\nimport { Router } from \'@angular/router\';';
+      expect(content).to.equal(expected);
+    });
+  });
+  it('throws an error if first occurence with no fallback position', () => {
+    let imports = getNodesOfKind(ts.SyntaxKind.ImportDeclaration, sourceFile);
+    expect(() => insertAfterLastOccurence(imports, `import { Router } from '@angular/router';`,
+                                    sourceFile)).to.throw(Error);
+  });
+  it('inserts after last import', () => {
+    let content = `import { foo, bar } from 'fizz';`;
+    let editedFile = new InsertChange(sourceFile, 0, content);
+    return editedFile
+    .apply()
+    .then(() => {
+      let imports = getNodesOfKind(ts.SyntaxKind.ImportDeclaration, sourceFile);
+      return insertAfterLastOccurence(imports, ', baz', sourceFile,
+                                      0, ts.SyntaxKind.Identifier)
+             .apply();
+    }).then(() => {
+      return readFile(sourceFile, 'utf8');
+    }).then(newContent => expect(newContent).to.equal(`import { foo, bar, baz } from 'fizz';`));
+  });
+  it('inserts after last import declaration', () => {
+    let content = `import * from 'foo' \n import { bar } from 'baz'`;
+    let editedFile = new InsertChange(sourceFile, 0, content);
+    return editedFile
+    .apply()
+    .then(() => {
+      let imports = getNodesOfKind(ts.SyntaxKind.ImportDeclaration, sourceFile);
+      return insertAfterLastOccurence(imports, `\nimport Router from '@angular/router'`,
+                                      sourceFile)
+             .apply();
+    }).then(() => {
+      return readFile(sourceFile, 'utf8');
+    }).then(newContent => {
+      let expected = `import * from 'foo' \n import { bar } from 'baz'` +
+                     `\nimport Router from '@angular/router'`;
+      expect(newContent).to.equal(expected);
+    });
+  });
+  it('inserts correctly if no imports', () => {
+    let content = `import {} from 'foo'`;
+    let editedFile = new InsertChange(sourceFile, 0, content);
+    return editedFile
+    .apply()
+   .then(() => {
+     let imports = getNodesOfKind(ts.SyntaxKind.ImportDeclaration, sourceFile);
+     return insertAfterLastOccurence(imports, ', bar', sourceFile, undefined,
+                                     ts.SyntaxKind.Identifier)
+            .apply();
+   }).catch(() => {
+     return readFile(sourceFile, 'utf8');
+   })
+    .then(newContent => {
+      expect(newContent).to.equal(content);
+      // use a fallback position for safety
+      let imports = getNodesOfKind(ts.SyntaxKind.ImportDeclaration, sourceFile);
+      let pos = findNodes(sortNodesByPosition(imports).pop(),
+                          ts.SyntaxKind.CloseBraceToken).pop().pos;
+      return insertAfterLastOccurence(imports, ' bar ',
+                                      sourceFile, pos, ts.SyntaxKind.Identifier)
+             .apply();
+    }).then(() => {
+      return readFile(sourceFile, 'utf8');
+    }).then(newContent => {
+      expect(newContent).to.equal(`import { bar } from 'foo'`);
+    });
+  });
+});
+
+  /**
+ * Gets node of kind kind from sourceFile
+ */
+function getNodesOfKind(kind: ts.SyntaxKind, sourceFile: string) {
+  return findNodes(getRootNode(sourceFile), kind);
+}
+
+function getRootNode(sourceFile: string) {
+  return ts.createSourceFile(sourceFile, fs.readFileSync(sourceFile).toString(),
+                                         ts.ScriptTarget.ES6, true);
+}
+
