feat: add utilities for typescript ast

'newroute-utility.ts' provides typescript utility functions to be used in the
new generate router command

Author: EmmanuelAzuh

addon/ng2/utilities/dynamic-path-parser.js

@@ -55,4 +55,4 @@ module.exports = function dynamicPathParser(project, entityName) {
   parsedPath.appRoot = appRoot
 
   return parsedPath;
-};
+};

addon/ng2/utilities/newroute-utilities.ts

@@ -0,0 +1,184 @@
+import * as ts from 'typescript';
+import * as fs from 'fs';
+import * as edit from './change';
+
+export function removeRouteFromParent(){
+
+}
+
+export function findParentRouteFile(){
+
+}
+
+export function addRoutesToParent(){
+
+}
+
+/**
+ * Adds provideRouter configuration to the main file (import and bootstrap) if 
+ * main file hasn't been already configured, else it has no effect.
+ * 
+ * @param (mainFile) path to main.ts in ng project
+ */
+export function configureMain(mainFile: string): Promise<void>{
+   return insertImport(mainFile, 'provideRouter', '@angular/router')
+   .then(() => {
+    let rootNode = ts.createSourceFile(mainFile, fs.readFileSync(mainFile).toString(),
+                                              ts.ScriptTarget.ES6, true);
+    let paths = '[]';
+    let expressions = findNodes(rootNode, ts.SyntaxKind.ExpressionStatement);
+    let isBootstraped = false;
+    let bootstrapNode = expressions.filter(node => {
+      let st = findNodes(node, ts.SyntaxKind.Identifier).filter(n => {
+        if (n.text === 'provideRouter') { // checks whether to insert provideRouter
+          isBootstraped = true;
+        }
+        return n.text.toLowerCase() === 'bootstrap';
+      });
+      return st.length === 1;
+    }).pop();
+
+    if (isBootstraped) {
+      return Promise.resolve();
+    }
+
+    // if bracket exitst already, add configuration template, 
+    // otherwise, insert into bootstrap parens
+    let bootstrapProviders = findNodes(bootstrapNode, ts.SyntaxKind.ArrayLiteralExpression);
+
+    var fallBackPos: number, configurePathsTemplate: string, separator: string;
+
+    if (bootstrapProviders.length > 0) {
+      fallBackPos = findNodes(bootstrapNode, ts.SyntaxKind.CloseBracketToken).pop().pos;
+      // count content of provider array. Child at position 1 is the 
+      // node of syntaxLists within the '[' ']' literals
+      let providerCount: number = bootstrapProviders.pop().getChildAt(1).getChildCount();
+      configurePathsTemplate = `provideRouter(${paths})`;
+      separator = providerCount == 0 ? '' : ', ';
+    } else {
+      fallBackPos = findNodes(bootstrapNode, ts.SyntaxKind.CloseParenToken).pop().pos;
+      configurePathsTemplate = `, [provideRouter(${paths})]`;
+      separator = '';
+    }
+    return insertAfterLastOccurence(bootstrapProviders, separator, configurePathsTemplate,
+                                            mainFile, fallBackPos, ts.SyntaxKind.SyntaxList);
+   });
+}
+
+/**
+* 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();
+}
+