build(broccoli): add DiffingBroccoliPlugin and refactor existing plugins to use it

tree-differ:
 - export both TreeDiffer and DiffResult  interface

 diffing-broccoli-plugin:
 - factory class for wrapping DiffingBroccoliPlugins and turning them into BroccoliTrees

 broccoli-dest-copy:
 - refactor into DiffingBroccoliPlugin

 broccoli-traceur:
 - refactor into DiffingBroccoliPlugin

Author: IgorMinar

tools/broccoli/broccoli-dest-copy.ts

@@ -1,63 +1,35 @@
-/// <reference path="./broccoli.d.ts" />
 /// <reference path="../typings/node/node.d.ts" />
 /// <reference path="../typings/fs-extra/fs-extra.d.ts" />
 
 import fs = require('fs');
 import fse = require('fs-extra');
 import path = require('path');
-import TreeDiffer = require('./tree-differ');
+import {wrapDiffingPlugin, DiffingBroccoliPlugin, DiffResult} from './diffing-broccoli-plugin';
 
 /**
  * Intercepts each file as it is copied to the destination tempdir,
  * and tees a copy to the given path outside the tmp dir.
  */
-export = function destCopy(inputTree, outputRoot) { return new DestCopy(inputTree, outputRoot); }
+class DestCopy implements DiffingBroccoliPlugin {
+  constructor(private inputPath, private cachePath, private outputRoot: string) {}
 
 
-class DestCopy implements BroccoliTree {
-  treeDirtyChecker: TreeDiffer;
-  initialized = false;
-
-  // props monkey-patched by broccoli builder:
-  inputPath = null;
-  cachePath = null;
-  outputPath = null;
-
-
-  constructor(public inputTree: BroccoliTree, public outputRoot: string) {}
-
-
-  rebuild() {
-    let firstRun = !this.initialized;
-    this.init();
-
-    let diffResult = this.treeDirtyChecker.diffTree();
-    diffResult.log(!firstRun);
-
-    diffResult.changedPaths.forEach((changedFilePath) => {
+  rebuild(treeDiff: DiffResult) {
+    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);
     });
 
-    diffResult.removedPaths.forEach((removedFilePath) => {
+    treeDiff.removedPaths.forEach((removedFilePath) => {
       var destFilePath = path.join(this.outputRoot, removedFilePath);
 
       // TODO: what about obsolete directories? we are not cleaning those up yet
       fs.unlinkSync(destFilePath);
     });
   }
-
-
-  private init() {
-    if (!this.initialized) {
-      this.initialized = true;
-      this.treeDirtyChecker = new TreeDiffer(this.inputPath);
-    }
-  }
-
-
-  cleanup() {}
 }
+
+export default wrapDiffingPlugin(DestCopy);

tools/broccoli/diffing-broccoli-plugin.ts

@@ -0,0 +1,103 @@
+/// <reference path="broccoli.d.ts" />
+/// <reference path="../typings/fs-extra/fs-extra.d.ts" />
+/// <reference path="../typings/node/node.d.ts" />
+
+import fs = require('fs');
+import fse = require('fs-extra');
+import path = require('path');
+import {TreeDiffer, DiffResult} from './tree-differ';
+let symlinkOrCopy = require('symlink-or-copy');
+
+
+export {DiffResult} from './tree-differ';
+
+
+/**
+ * Makes writing diffing plugins easy.
+ *
+ * Factory method that takes a class that implements the DiffingBroccoliPlugin interface and returns
+ * an instance of BroccoliTree.
+ *
+ * @param pluginClass
+ * @returns {DiffingPlugin}
+ */
+export function wrapDiffingPlugin(pluginClass): DiffingPluginWrapperFactory {
+  return function() { return new DiffingPluginWrapper(pluginClass, arguments); };
+}
+
+
+export interface DiffingBroccoliPlugin {
+  rebuild(diff: DiffResult): (Promise<any>| void);
+  cleanup ? () : void;
+}
+
+
+type DiffingPluginWrapperFactory = (inputTrees: (BroccoliTree | BroccoliTree[]), options?) =>
+    BroccoliTree;
+
+
+class DiffingPluginWrapper implements BroccoliTree {
+  treeDiffer: TreeDiffer;
+  initialized = false;
+  wrappedPlugin: DiffingBroccoliPlugin = null;
+  inputTree = null;
+  inputTrees = null;
+  description = null;
+
+  // props monkey-patched by broccoli builder:
+  inputPath = null;
+  cachePath = null;
+  outputPath = null;
+
+
+  constructor(private pluginClass, private wrappedPluginArguments) {
+    if (Array.isArray(wrappedPluginArguments[0])) {
+      this.inputTrees = wrappedPluginArguments[0];
+    } else {
+      this.inputTree = wrappedPluginArguments[0];
+    }
+
+    this.description = this.pluginClass.name;
+  }
+
+
+  rebuild() {
+    let firstRun = !this.initialized;
+    this.init();
+
+    let diffResult = this.treeDiffer.diffTree();
+    diffResult.log(!firstRun);
+
+    var rebuildPromise = this.wrappedPlugin.rebuild(diffResult);
+
+    if (rebuildPromise) {
+      return (<Promise<any>>rebuildPromise).then(this.relinkOutputAndCachePaths.bind(this));
+    }
+
+    this.relinkOutputAndCachePaths();
+  }
+
+
+  private relinkOutputAndCachePaths() {
+    // just symlink the cache and output tree
+    fs.rmdirSync(this.outputPath);
+    symlinkOrCopy.sync(this.cachePath, this.outputPath);
+  }
+
+
+  private init() {
+    if (!this.initialized) {
+      this.initialized = true;
+      this.treeDiffer = new TreeDiffer(this.inputPath);
+      this.wrappedPlugin =
+          new this.pluginClass(this.inputPath, this.cachePath, this.wrappedPluginArguments[1]);
+    }
+  }
+
+
+  cleanup() {
+    if (this.wrappedPlugin.cleanup) {
+      this.wrappedPlugin.cleanup();
+    }
+  }
+}

tools/broccoli/traceur/index.ts

@@ -1,66 +1,38 @@
-/// <reference path="../broccoli.d.ts" />
-/// <reference path="../broccoli-writer.d.ts" />
 /// <reference path="../../typings/fs-extra/fs-extra.d.ts" />
 /// <reference path="../../typings/node/node.d.ts" />
 
 import fs = require('fs');
 import fse = require('fs-extra');
 import path = require('path');
-import TreeDiffer = require('../tree-differ');
-import Writer = require('broccoli-writer');
+import {wrapDiffingPlugin, DiffingBroccoliPlugin, DiffResult} from '../diffing-broccoli-plugin';
 
 let traceur = require('../../../../tools/transpiler');
-let symlinkOrCopy = require('symlink-or-copy');
 let xtend = require('xtend');
 
 
-export = traceurCompiler;
-
-function traceurCompiler(inputTree, destExtension, destSourceMapExtension, options) {
-  return new TraceurCompiler(inputTree, destExtension, destSourceMapExtension, options);
-}
-
-traceurCompiler['RUNTIME_PATH'] = traceur.RUNTIME_PATH;
-
-
-class TraceurCompiler implements BroccoliTree {
-  treeDiffer: TreeDiffer;
-  initialized = false;
-
-  // props monkey-patched by broccoli builder:
-  inputPath = null;
-  cachePath = null;
-  outputPath = null;
-
-
-  constructor(public inputTree: BroccoliTree, private destExtension: string,
-              private destSourceMapExtension: string, private options: {[key: string]: any}) {}
+class DiffingTraceurCompiler implements DiffingBroccoliPlugin {
+  constructor(public inputPath: string, public cachePath: string, public options) {}
 
 
-  rebuild() {
-    let firstRun = !this.initialized;
-    this.init();
-
-    let diffResult = this.treeDiffer.diffTree();
-    diffResult.log(!firstRun);
-
-    diffResult.changedPaths.forEach((changedFilePath) => {
+  rebuild(treeDiff: DiffResult) {
+    treeDiff.changedPaths.forEach((changedFilePath) => {
       var extension = path.extname(changedFilePath).toLowerCase();
       if (extension === '.js' || extension === '.es6' || extension === '.cjs') {
-        var options = xtend({filename: changedFilePath}, this.options);
+        var traceurOpts = xtend({filename: changedFilePath}, this.options.traceurOptions);
 
         var fsOpts = {encoding: 'utf-8'};
         var absoluteInputFilePath = path.join(this.inputPath, changedFilePath);
         var sourcecode = fs.readFileSync(absoluteInputFilePath, fsOpts);
 
-        var result = traceur.compile(options, changedFilePath, sourcecode);
+        var result = traceur.compile(traceurOpts, changedFilePath, sourcecode);
 
         // TODO: we should fix the sourceMappingURL written by Traceur instead of overriding
         // (but we might switch to typescript first)
-        var mapFilepath = changedFilePath.replace(/\.\w+$/, '') + this.destSourceMapExtension;
+        var mapFilepath =
+            changedFilePath.replace(/\.\w+$/, '') + this.options.destSourceMapExtension;
         result.js = result.js + '\n//# sourceMappingURL=./' + path.basename(mapFilepath);
 
-        var destFilepath = changedFilePath.replace(/\.\w+$/, this.destExtension);
+        var destFilepath = changedFilePath.replace(/\.\w+$/, this.options.destExtension);
         var destFile = path.join(this.cachePath, destFilepath);
         fse.mkdirsSync(path.dirname(destFile));
         fs.writeFileSync(destFile, result.js, fsOpts);
@@ -71,25 +43,15 @@ class TraceurCompiler implements BroccoliTree {
       }
     });
 
-    diffResult.removedPaths.forEach((removedFilePath) => {
-      var destFilepath = removedFilePath.replace(/\.\w+$/, this.destExtension);
+    treeDiff.removedPaths.forEach((removedFilePath) => {
+      var destFilepath = removedFilePath.replace(/\.\w+$/, this.options.destExtension);
       var absoluteOuputFilePath = path.join(this.cachePath, destFilepath);
       fs.unlinkSync(absoluteOuputFilePath);
     });
-
-    // just symlink the cache and output tree
-    fs.rmdirSync(this.outputPath);
-    symlinkOrCopy.sync(this.cachePath, this.outputPath);
-  }
-
-
-  private init() {
-    if (!this.initialized) {
-      this.initialized = true;
-      this.treeDiffer = new TreeDiffer(this.inputPath);
-    }
   }
+}
 
+let transpileWithTraceur = wrapDiffingPlugin(DiffingTraceurCompiler);
+let TRACEUR_RUNTIME_PATH = traceur.RUNTIME_PATH;
 
-  cleanup() {}
-}
+export {transpileWithTraceur as default, TRACEUR_RUNTIME_PATH};

tools/broccoli/tree-differ.spec.ts

@@ -3,7 +3,7 @@
 
 let mockfs = require('mock-fs');
 import fs = require('fs');
-import TreeDiffer = require('./tree-differ');
+import {TreeDiffer} from './tree-differ';
 
 
 describe('TreeDiffer', () => {

tools/broccoli/tree-differ.ts

@@ -4,9 +4,7 @@ import fs = require('fs');
 import path = require('path');
 
 
-export = TreeDiffer;
-
-class TreeDiffer {
+export class TreeDiffer {
   private fingerprints: {[key: string]: string} = Object.create(null);
   private nextFingerprints: {[key: string]: string} = Object.create(null);
   private rootDirName: string;
@@ -15,15 +13,15 @@ class TreeDiffer {
 
 
   public diffTree(): DiffResult {
-    let result = new DiffResult(this.rootDirName);
+    let result = new DirtyCheckingDiffResult(this.rootDirName);
     this.dirtyCheckPath(this.rootPath, result);
     this.detectDeletionsAndUpdateFingerprints(result);
     result.endTime = Date.now();
     return result;
   }
 
 
-  private dirtyCheckPath(rootDir: string, result: DiffResult) {
+  private dirtyCheckPath(rootDir: string, result: DirtyCheckingDiffResult) {
     fs.readdirSync(rootDir).forEach((segment) => {
       let absolutePath = path.join(rootDir, segment);
       let pathStat = fs.statSync(absolutePath);
@@ -76,7 +74,15 @@ class TreeDiffer {
 }
 
 
-class DiffResult {
+export interface DiffResult {
+  changedPaths: string[];
+  removedPaths: string[];
+  log(verbose: boolean): void;
+  toString(): string;
+}
+
+
+class DirtyCheckingDiffResult {
   public filesChecked: number = 0;
   public directoriesChecked: number = 0;
   public changedPaths: string[] = [];