chore(lint): format tools dir

Author: alexeagle

DEVELOPER.md

@@ -238,17 +238,17 @@ repository, allowing many tools and editors to share our settings.
 
 To check the formatting of your code, run
 
-    gulp check-format
+    gulp lint
 
-Note that the continuous build on Travis runs `gulp enforce-format`. Unlike the `check-format` task,
-this will actually fail the build if files aren't formatted according to the style guide.
+Note that the continuous build on CircleCI will fail the build if files aren't formatted according
+to the style guide.
 
 Your life will be easier if you include the formatter in your standard workflow. Otherwise, you'll
 likely forget to check the formatting, and waste time waiting for a build on Travis that fails due
 to some whitespace difference.
 
-* Use `$(npm bin)/clang-format -i [file name]` to format a file (or multiple).
-* Use `gulp enforce-format` to check if your code is `clang-format` clean. This also gives
+* Use `gulp format` to format everything.
+* Use `gulp lint` to check if your code is `clang-format` clean. This also gives
   you a command line to format your code.
 * `clang-format` also includes a git hook, run `git clang-format` to format all files you
   touched.

tools/broccoli/angular_builder.ts

@@ -11,10 +11,7 @@ export type ProjectMap = {
 };
 
 export type Options = {
-  projects: ProjectMap;
-  noTypeChecks: boolean;
-  generateEs6: boolean;
-  useBundles: boolean;
+  projects: ProjectMap; noTypeChecks: boolean; generateEs6: boolean; useBundles: boolean;
 };
 
 export interface AngularBuilderOptions {
@@ -133,14 +130,16 @@ export class AngularBuilder {
           writeBuildLog(result, name);
           return result;
         },
-        (error): any => {
-          // the build tree is the same during rebuilds, only leaf properties of the nodes change
-          // so let's traverse it and get updated values for input/cache/output paths
-          if (this.firstResult) {
-            writeBuildLog(this.firstResult, name);
-          }
-          throw error;
-        });
+        (error):
+            any => {
+              // the build tree is the same during rebuilds, only leaf properties of the nodes
+              // change
+              // so let's traverse it and get updated values for input/cache/output paths
+              if (this.firstResult) {
+                writeBuildLog(this.firstResult, name);
+              }
+              throw error;
+            });
   }
 }
 
@@ -159,16 +158,17 @@ function writeBuildLog(result: BuildResult, name: string) {
 function broccoliNodeToBuildNode(broccoliNode: BroccoliNode): BuildNode {
   let tree = broccoliNode.tree.newStyleTree || broccoliNode.tree;
 
-  return new BuildNode(tree.description || (<any>tree.constructor).name,
-                       tree.inputPath ? [tree.inputPath] : tree.inputPaths, tree.cachePath,
-                       tree.outputPath, broccoliNode.selfTime / (1000 * 1000 * 1000),
-                       broccoliNode.totalTime / (1000 * 1000 * 1000),
-                       broccoliNode.subtrees.map(broccoliNodeToBuildNode));
+  return new BuildNode(
+      tree.description || (<any>tree.constructor).name,
+      tree.inputPath ? [tree.inputPath] : tree.inputPaths, tree.cachePath, tree.outputPath,
+      broccoliNode.selfTime / (1000 * 1000 * 1000), broccoliNode.totalTime / (1000 * 1000 * 1000),
+      broccoliNode.subtrees.map(broccoliNodeToBuildNode));
 }
 
 
 class BuildNode {
-  constructor(public pluginName: string, public inputPaths: string[], public cachePath: string,
-              public outputPath: string, public selfTime: number, public totalTime: number,
-              public inputNodes: BuildNode[]) {}
+  constructor(
+      public pluginName: string, public inputPaths: string[], public cachePath: string,
+      public outputPath: string, public selfTime: number, public totalTime: number,
+      public inputNodes: BuildNode[]) {}
 }

tools/broccoli/broccoli-check-imports.ts

@@ -9,16 +9,16 @@ import {wrapDiffingPlugin, DiffingBroccoliPlugin, DiffResult} from './diffing-br
  * This guarantees that platform-independent modules remain platoform-independent.
  */
 class CheckImports implements DiffingBroccoliPlugin {
-  static IMPORT_DECL_REGEXP = new RegExp(`^import[^;]+;`, "mg");
-  static IMPORT_PATH_REGEXP = new RegExp(`['"]([^'"]+)+['"]`, "m");
+  static IMPORT_DECL_REGEXP = new RegExp(`^import[^;]+;`, 'mg');
+  static IMPORT_PATH_REGEXP = new RegExp(`['"]([^'"]+)+['"]`, 'm');
 
   static ALLOWED_IMPORTS: {[s: string]: string[]} = {
-    "angular2/src/core": ["angular2/src/facade"],
-    "angular2/src/facade": ["rxjs"],
-    "angular2/src/common": ["angular2/core", "angular2/src/facade"],
-    "angular2/src/http": ["angular2/core", "angular2/src/facade", "rxjs"],
-    "angular2/src/upgrade":
-        ["angular2/core", "angular2/src/facade", "angular2/platform/browser", "angular2/compiler"]
+    'angular2/src/core': ['angular2/src/facade'],
+    'angular2/src/facade': ['rxjs'],
+    'angular2/src/common': ['angular2/core', 'angular2/src/facade'],
+    'angular2/src/http': ['angular2/core', 'angular2/src/facade', 'rxjs'],
+    'angular2/src/upgrade':
+        ['angular2/core', 'angular2/src/facade', 'angular2/platform/browser', 'angular2/compiler']
     //"angular2/src/render": [
     //  "angular2/animate",
     //  "angular2/core",
@@ -55,8 +55,8 @@ class CheckImports implements DiffingBroccoliPlugin {
 
   private checkFilePath(filePath: string) {
     const sourceFilePath = path.join(this.inputPath, filePath);
-    if (endsWith(sourceFilePath, ".ts") && fs.existsSync(sourceFilePath)) {
-      const content = fs.readFileSync(sourceFilePath, "UTF-8");
+    if (endsWith(sourceFilePath, '.ts') && fs.existsSync(sourceFilePath)) {
+      const content = fs.readFileSync(sourceFilePath, 'UTF-8');
       const imports = content.match(CheckImports.IMPORT_DECL_REGEXP);
       if (imports) {
         return imports.filter(i => !this.isAllowedImport(filePath, i))
@@ -73,22 +73,22 @@ class CheckImports implements DiffingBroccoliPlugin {
     if (!res || res.length < 2) return true;  // non-es6 import
     const importPath = res[1];
 
-    if (startsWith(importPath, "./") || startsWith(importPath, "../")) return true;
+    if (startsWith(importPath, './') || startsWith(importPath, '../')) return true;
 
     const c = CheckImports.ALLOWED_IMPORTS;
     for (var prop in c) {
       if (c.hasOwnProperty(prop) && startsWith(sourceFile, prop)) {
         const allowedPaths = c[prop];
         return startsWith(importPath, prop) ||
-               allowedPaths.filter(p => startsWith(importPath, p)).length > 0;
+            allowedPaths.filter(p => startsWith(importPath, p)).length > 0;
       }
     }
 
     return true;
   }
 
   private formatError(filePath: string, importPath: string): string {
-    const i = importPath.replace(new RegExp(`\n`, 'g'), "\\n");
+    const i = importPath.replace(new RegExp(`\n`, 'g'), '\\n');
     return `${filePath}: ${i}`;
   }
 }

tools/broccoli/broccoli-dartfmt.ts

@@ -24,7 +24,7 @@ class DartFormatter implements DiffingBroccoliPlugin {
   private firstBuild: boolean = true;
 
   constructor(public inputPath: string, public cachePath: string, options: AngularBuilderOptions) {
-    if (!options.dartSDK) throw new Error("Missing Dart SDK");
+    if (!options.dartSDK) throw new Error('Missing Dart SDK');
     this.DARTFMT = options.dartSDK.DARTFMT;
     this.verbose = options.logs.dartfmt;
   }
@@ -34,22 +34,21 @@ class DartFormatter implements DiffingBroccoliPlugin {
     let argsLength = 2;
     let argPackages: string[][] = [];
     let firstBuild = this.firstBuild;
-    treeDiff.addedPaths.concat(treeDiff.changedPaths)
-        .forEach((changedFile) => {
-          let sourcePath = path.join(this.inputPath, changedFile);
-          let destPath = path.join(this.cachePath, changedFile);
-          if (!firstBuild && /\.dart$/.test(changedFile)) {
-            if ((argsLength + destPath.length + 2) >= 0x2000) {
-              // Win32 command line arguments length
-              argPackages.push(args);
-              args = ['-w'];
-              argsLength = 2;
-            }
-            args.push(destPath);
-            argsLength += destPath.length + 2;
-          }
-          fse.copySync(sourcePath, destPath);
-        });
+    treeDiff.addedPaths.concat(treeDiff.changedPaths).forEach((changedFile) => {
+      let sourcePath = path.join(this.inputPath, changedFile);
+      let destPath = path.join(this.cachePath, changedFile);
+      if (!firstBuild && /\.dart$/.test(changedFile)) {
+        if ((argsLength + destPath.length + 2) >= 0x2000) {
+          // Win32 command line arguments length
+          argPackages.push(args);
+          args = ['-w'];
+          argsLength = 2;
+        }
+        args.push(destPath);
+        argsLength += destPath.length + 2;
+      }
+      fse.copySync(sourcePath, destPath);
+    });
     treeDiff.removedPaths.forEach((removedFile) => {
       let destPath = path.join(this.cachePath, removedFile);
       fse.removeSync(destPath);
@@ -60,8 +59,7 @@ class DartFormatter implements DiffingBroccoliPlugin {
     }
 
     let execute = (args: string[]) => {
-      if (args.length < 2)
-        return Promise.resolve();
+      if (args.length < 2) return Promise.resolve();
       return new Promise<void>((resolve, reject) => {
         exec(this.DARTFMT + ' ' + args.join(' '), (err: Error, stdout: string, stderr: string) => {
           if (this.verbose) {

tools/broccoli/broccoli-dest-copy.ts

@@ -12,14 +12,13 @@ class DestCopy implements DiffingBroccoliPlugin {
 
 
   rebuild(treeDiff: DiffResult) {
-    treeDiff.addedPaths.concat(treeDiff.changedPaths)
-        .forEach((changedFilePath) => {
-          var destFilePath = path.join(this.outputRoot, changedFilePath);
+    treeDiff.addedPaths.concat(treeDiff.changedPaths).forEach((changedFilePath) => {
+      var destFilePath = path.join(this.outputRoot, changedFilePath);
 
-          var destDirPath = path.dirname(destFilePath);
-          fse.mkdirsSync(destDirPath);
-          fse.copySync(path.join(this.inputPath, changedFilePath), destFilePath);
-        });
+      var destDirPath = path.dirname(destFilePath);
+      fse.mkdirsSync(destDirPath);
+      fse.copySync(path.join(this.inputPath, changedFilePath), destFilePath);
+    });
 
     treeDiff.removedPaths.forEach((removedFilePath) => {
       var destFilePath = path.join(this.outputRoot, removedFilePath);

tools/broccoli/broccoli-flatten.spec.ts

@@ -8,10 +8,10 @@ describe('Flatten', () => {
   afterEach(() => mockfs.restore());
 
   let flatten = (inputPaths: string) => new DiffingFlatten(inputPaths, 'output', null);
-  let read = (path: string) => fs.readFileSync(path, {encoding: "utf-8"});
+  let read = (path: string) => fs.readFileSync(path, {encoding: 'utf-8'});
   let rm = (path: string) => fs.unlinkSync(path);
   let write =
-      (path: string, content: string) => { fs.writeFileSync(path, content, {encoding: "utf-8"}); }
+      (path: string, content: string) => { fs.writeFileSync(path, content, {encoding: 'utf-8'}); }
 
 
   it('should flatten files and be incremental', () => {
@@ -67,7 +67,8 @@ describe('Flatten', () => {
     let differ = new TreeDiffer('testLabel', 'input');
     let flattenedTree = flatten('input');
     expect(() => flattenedTree.rebuild(differ.diffTree()))
-        .toThrowError("Duplicate file 'file-1.txt' found in path 'dir1" + path.sep + "subdir-1" +
-                      path.sep + "file-1.txt'");
+        .toThrowError(
+            'Duplicate file \'file-1.txt\' found in path \'dir1' + path.sep + 'subdir-1' +
+            path.sep + 'file-1.txt\'');
   });
 });

tools/broccoli/broccoli-flatten.ts

@@ -14,8 +14,9 @@ var isWindows = process.platform === 'win32';
  * the associated changes.
  */
 export class DiffingFlatten implements DiffingBroccoliPlugin {
-  constructor(private inputPath: string, private cachePath: string,
-              private options: AngularBuilderOptions) {}
+  constructor(
+      private inputPath: string, private cachePath: string,
+      private options: AngularBuilderOptions) {}
 
 
   rebuild(treeDiff: DiffResult) {
@@ -39,8 +40,9 @@ export class DiffingFlatten implements DiffingBroccoliPlugin {
       if (!fs.existsSync(destFilePath)) {
         symlinkOrCopy(sourceFilePath, destFilePath);
       } else {
-        throw new Error(`Duplicate file '${path.basename(changedFilePath)}' ` +
-                        `found in path '${changedFilePath}'`);
+        throw new Error(
+            `Duplicate file '${path.basename(changedFilePath)}' ` +
+            `found in path '${changedFilePath}'`);
       }
     });
 

tools/broccoli/broccoli-generate-for-test.ts

@@ -13,23 +13,26 @@ import {wrapDiffingPlugin, DiffingBroccoliPlugin, DiffResult} from './diffing-br
 class GeneratorForTest implements DiffingBroccoliPlugin {
   private seenFiles: {[key: string]: boolean} = {};
 
-  constructor(private inputPath: string, private outputPath: string,
-              private options: { files: string[], dartPath: string }) {}
+  constructor(private inputPath: string, private outputPath: string, private options: {
+    files: string[],
+    dartPath: string
+  }) {}
 
   rebuild(treeDiff: DiffResult) {
     var matchedFiles: string[] = [];
     this.options.files.forEach(
         (file) => { matchedFiles = matchedFiles.concat(glob.sync(file, {cwd: this.inputPath})); });
-    return Promise.all(matchedFiles.map((matchedFile) => {
-                    var inputFilePath = path.join(this.inputPath, matchedFile);
-                    var outputFilePath = path.join(this.outputPath, matchedFile);
+    return Promise
+        .all(matchedFiles.map((matchedFile) => {
+          var inputFilePath = path.join(this.inputPath, matchedFile);
+          var outputFilePath = path.join(this.outputPath, matchedFile);
 
-                    var outputDirPath = path.dirname(outputFilePath);
-                    if (!fs.existsSync(outputDirPath)) {
-                      fse.mkdirpSync(outputDirPath);
-                    }
-                    return this.invokeGenerator(matchedFile, inputFilePath, outputFilePath)
-                  }))
+          var outputDirPath = path.dirname(outputFilePath);
+          if (!fs.existsSync(outputDirPath)) {
+            fse.mkdirpSync(outputDirPath);
+          }
+          return this.invokeGenerator(matchedFile, inputFilePath, outputFilePath)
+        }))
         .then(() => {
           var result = new DiffResult();
           matchedFiles.forEach((file) => {
@@ -44,8 +47,8 @@ class GeneratorForTest implements DiffingBroccoliPlugin {
         });
   }
 
-  private invokeGenerator(file: string, inputFilePath: string,
-                          outputFilePath: string): Promise<any> {
+  private invokeGenerator(file: string, inputFilePath: string, outputFilePath: string):
+      Promise<any> {
     return new Promise((resolve, reject) => {
       var args: string[];
       var vmPath: string;
@@ -62,15 +65,14 @@ class GeneratorForTest implements DiffingBroccoliPlugin {
       }
 
       var stdoutStream = fs.createWriteStream(outputFilePath);
-      var proc = childProcess.spawn(
-          vmPath, args,
-          { stdio: ['ignore', 'pipe', 'inherit'],
-            env: (<any>Object)['assign']({}, process.env, env)
-          });
+      var proc = childProcess.spawn(vmPath, args, {
+        stdio: ['ignore', 'pipe', 'inherit'],
+        env: (<any>Object)['assign']({}, process.env, env)
+      });
       proc.on('error', function(code: any) {
         console.error(code);
-        reject(new Error('Failed while generating code. Please run manually: ' + vmPath + ' ' +
-                         args.join(' ')));
+        reject(new Error(
+            'Failed while generating code. Please run manually: ' + vmPath + ' ' + args.join(' ')));
       });
       proc.on('close', function() {
         stdoutStream.close();

tools/broccoli/broccoli-lodash.ts

@@ -23,8 +23,9 @@ const kDefaultOptions: LodashRendererOptions = {
  * the associated changes.
  */
 export class LodashRenderer implements DiffingBroccoliPlugin {
-  constructor(private inputPath: string, private cachePath: string,
-              private options: LodashRendererOptions = kDefaultOptions) {}
+  constructor(
+      private inputPath: string, private cachePath: string,
+      private options: LodashRendererOptions = kDefaultOptions) {}
 
   rebuild(treeDiff: DiffResult) {
     let {encoding = 'utf-8', context = {}} = this.options;

tools/broccoli/broccoli-merge-trees.spec.ts

@@ -15,7 +15,7 @@ describe('MergeTrees', () => {
   }
 
   let diffTrees = (differs: TreeDiffer[]): DiffResult[] => differs.map(tree => tree.diffTree());
-  function read(path: string) { return fs.readFileSync(path, "utf-8"); }
+  function read(path: string) { return fs.readFileSync(path, 'utf-8'); }
 
   it('should copy the file from the right-most inputTree with overwrite=true', () => {
     let testDir: any = {

tools/broccoli/broccoli-merge-trees.ts

@@ -24,8 +24,8 @@ export class MergeTrees implements DiffingBroccoliPlugin {
   public options: MergeTreesOptions;
   private firstBuild: boolean = true;
 
-  constructor(public inputPaths: string[], public cachePath: string,
-              options: MergeTreesOptions = {}) {
+  constructor(
+      public inputPaths: string[], public cachePath: string, options: MergeTreesOptions = {}) {
     this.options = options || {};
   }