angular-cn/gulpfile.js

var autoprefixer = require('gulp-autoprefixer');
var format = require('gulp-clang-format');
var fork = require('child_process').fork;
var gulp = require('gulp');
var gulpPlugins = require('gulp-load-plugins')();
var sass = require('gulp-sass');
var shell = require('gulp-shell');
var runSequence = require('run-sequence');
var madge = require('madge');
var merge = require('merge');
var merge2 = require('merge2');
var path = require('path');
var Q = require('q');

var gulpTraceur = require('./tools/transpiler/gulp-traceur');
var clean = require('./tools/build/clean');
var transpile = require('./tools/build/transpile');
var pubget = require('./tools/build/pubget');
var linknodemodules = require('./tools/build/linknodemodules');
var pubbuild = require('./tools/build/pubbuild');
var dartanalyzer = require('./tools/build/dartanalyzer');
var jsserve = require('./tools/build/jsserve');
var pubserve = require('./tools/build/pubserve');
var rundartpackage = require('./tools/build/rundartpackage');
var file2moduleName = require('./tools/build/file2modulename');
var karma = require('karma').server;
var minimist = require('minimist');
var runServerDartTests = require('./tools/build/run_server_dart_tests');
var sourcemaps = require('gulp-sourcemaps');
var transformCJSTests = require('./tools/build/transformCJSTests');
var tsc = require('gulp-typescript');
var util = require('./tools/build/util');
var bundler = require('./tools/build/bundle');
var replace = require('gulp-replace');
var insert = require('gulp-insert');

// dynamic require in build.broccoli.tools so we can bootstrap TypeScript compilation
function missingDynamicBroccoli() {
  throw new Error('ERROR: build.broccoli.tools task should have been run before using broccoli');
}
var getBroccoli = missingDynamicBroccoli;

// Note: when DART_SDK is not found, all gulp tasks ending with `.dart` will be skipped.

var DART_SDK = require('./tools/build/dartdetect')(gulp);

// -----------------------
// configuration

var _COMPILER_CONFIG_JS_DEFAULT = {
  sourceMaps: true,
  annotations: true, // parse annotations
  types: true, // parse types
  script: false, // parse as a module
  memberVariables: true, // parse class fields
  modules: 'instantiate'
};

var _HTML_DEFAULT_SCRIPTS_JS = [
  {src: gulpTraceur.RUNTIME_PATH, mimeType: 'text/javascript', copy: true},
  {src: 'node_modules/es6-module-loader/dist/es6-module-loader-sans-promises.src.js',
      mimeType: 'text/javascript', copy: true},
  {src: 'node_modules/zone.js/zone.js', mimeType: 'text/javascript', copy: true},
  {src: 'node_modules/zone.js/long-stack-trace-zone.js', mimeType: 'text/javascript', copy: true},
  {src: 'node_modules/systemjs/dist/system.src.js', mimeType: 'text/javascript', copy: true},
  {src: 'node_modules/systemjs/lib/extension-register.js', mimeType: 'text/javascript', copy: true},
  {src: 'node_modules/systemjs/lib/extension-cjs.js', mimeType: 'text/javascript', copy: true},
  {src: 'node_modules/rx/dist/rx.all.js', mimeType: 'text/javascript', copy: true},
  {src: 'tools/build/snippets/runtime_paths.js', mimeType: 'text/javascript', copy: true},
  {
    inline: 'System.import(\'$MODULENAME$\').then(function(m) { m.main(); }, console.error.bind(console))',
    mimeType: 'text/javascript'
  }
];

var BASE_PACKAGE_JSON = require('./package.json');
var COMMON_PACKAGE_JSON = {
  version: BASE_PACKAGE_JSON.version,
  homepage: BASE_PACKAGE_JSON.homepage,
  bugs: BASE_PACKAGE_JSON.bugs,
  license: BASE_PACKAGE_JSON.license,
  contributors: BASE_PACKAGE_JSON.contributors,
  dependencies: BASE_PACKAGE_JSON.dependencies,
  devDependencies: {
    "yargs": BASE_PACKAGE_JSON.devDependencies['yargs'],
    "gulp-sourcemaps": BASE_PACKAGE_JSON.devDependencies['gulp-sourcemaps'],
    "gulp-traceur": BASE_PACKAGE_JSON.devDependencies['gulp-traceur'],
    "gulp": BASE_PACKAGE_JSON.devDependencies['gulp'],
    "gulp-rename": BASE_PACKAGE_JSON.devDependencies['gulp-rename'],
    "through2": BASE_PACKAGE_JSON.devDependencies['through2']
  }
};

var CONFIG = {
  dest: {
    js: {
      all: 'dist/js',
      dev: {
        es6: 'dist/js/dev/es6',
        es5: 'dist/js/dev/es5'
      },
      prod: {
        es6: 'dist/js/prod/es6',
        es5: 'dist/js/prod/es5'
      },
      cjs: 'dist/js/cjs',
      dart2js: 'dist/js/dart2js'
    },
    dart: 'dist/dart',
    docs: 'dist/docs'
  },
  transpile: {
    src: {
      js: ['modules/**/*.js', 'modules/**/*.es6'],
      ts: ['modules/**/*.ts'],
    },
    options: {
      js: {
        dev: merge(true, _COMPILER_CONFIG_JS_DEFAULT, {
          typeAssertionModule: 'rtts_assert/rtts_assert',
          typeAssertions: true,
          outputLanguage: 'es6'
        }),
        prod: merge(true, _COMPILER_CONFIG_JS_DEFAULT, {
          typeAssertions: false,
          outputLanguage: 'es6'
        }),
        cjs: merge(true, _COMPILER_CONFIG_JS_DEFAULT, {
          typeAssertionModule: 'rtts_assert/rtts_assert',
          // Don't use type assertions since this is partly transpiled by typescript
          typeAssertions: false,
          modules: 'commonjs'
        })
      }
    }
  },
  copy: {
    js: {
      cjs: {
        src: [
          'modules/**/*.md', '!modules/**/*.dart.md', 'modules/**/*.png',
          'modules/**/package.json'
        ],
        pipes: {
          '**/*.js.md': gulpPlugins.rename(function(file) {
            file.basename = file.basename.substring(0, file.basename.lastIndexOf('.'));
          }),
          '**/package.json': gulpPlugins.template({ 'packageJson': COMMON_PACKAGE_JSON })
        }
      },
      dev: {
        src: ['modules/**/*.css'],
        pipes: {}
      },
      prod: {
        src: ['modules/**/*.css'],
        pipes: {}
      }
    }
  },
  multicopy: {
    js: {
      cjs: {
        src: [
          'LICENSE'
        ],
        pipes: {}
      },
      dev: {
        es6: {
          src: ['tools/build/es5build.js'],
          pipes: {}
        }
      },
      prod: {
        es6: {
          src: ['tools/build/es5build.js'],
          pipes: {}
        }
      }
    },
  },
  html: {
    src: {
      js: ['modules/*/src/**/*.html'],
    },
    scriptsPerFolder: {
      js: {
        '**': _HTML_DEFAULT_SCRIPTS_JS,
        'benchmarks/**':
          [
            { src: 'tools/build/snippets/url_params_to_form.js', mimeType: 'text/javascript', copy: true }
          ].concat(_HTML_DEFAULT_SCRIPTS_JS),
        'benchmarks_external/**':
          [
            { src: 'node_modules/angular/angular.js', mimeType: 'text/javascript', copy: true },
            { src: 'tools/build/snippets/url_params_to_form.js', mimeType: 'text/javascript', copy: true }
          ].concat(_HTML_DEFAULT_SCRIPTS_JS),
        'benchmarks_external/**/*polymer*/**':
          [
            { src: 'bower_components/polymer/lib/polymer.html', copyOnly: true },
            { src: 'tools/build/snippets/url_params_to_form.js', mimeType: 'text/javascript', copy: true }
          ]
      },
    }
  },
  formatDart: {
    packageName: 'dart_style',
    args: ['dart_style:format', '-w', 'dist/dart']
  },
  test: {
    js: {
      cjs: [
        '/angular2/test/**/*_spec.js'
      ]
    }
  }
};
CONFIG.test.js.cjs = CONFIG.test.js.cjs.map(function(s) {return CONFIG.dest.js.cjs + s});
CONFIG.test.js.cjs.push('!**/core/zone/vm_turn_zone_spec.js'); //Disabled in nodejs because it relies on Zone.js

// ------------
// clean

gulp.task('build/clean.js', clean(gulp, gulpPlugins, {
  path: CONFIG.dest.js.all
}));

gulp.task('build/clean.dart', clean(gulp, gulpPlugins, {
  path: CONFIG.dest.dart
}));

gulp.task('build/clean.docs', clean(gulp, gulpPlugins, {
    path: CONFIG.dest.docs
}));


// ------------
// transpile

gulp.task('build/tree.dart', ['build.broccoli.tools'], function() {
  return getBroccoli().forDartTree().buildOnce();
});

// ------------
// pubspec

// Run a top-level `pub get` for this project.
gulp.task('pubget.dart', pubget.dir(gulp, gulpPlugins, { dir: '.', command: DART_SDK.PUB }));

// Run `pub get` over CONFIG.dest.dart
gulp.task('build/pubspec.dart', pubget.subDir(gulp, gulpPlugins, {
  dir: CONFIG.dest.dart,
  command: DART_SDK.PUB
}));

// ------------
// linknodemodules

gulp.task('build/linknodemodules.js.cjs', linknodemodules(gulp, gulpPlugins, {
  dir: CONFIG.dest.js.cjs
}));

// ------------
// dartanalyzer

gulp.task('build/analyze.dart', dartanalyzer(gulp, gulpPlugins, {
  dest: CONFIG.dest.dart,
  command: DART_SDK.ANALYZER
}));

// ------------
// pubbuild

gulp.task('build/pubbuild.dart', pubbuild(gulp, gulpPlugins, {
  src: CONFIG.dest.dart,
  dest: CONFIG.dest.js.dart2js,
  command: DART_SDK.PUB
}));

// ------------
// formatting

gulp.task('build/format.dart', rundartpackage(gulp, gulpPlugins, {
  pub: DART_SDK.PUB,
  packageName: CONFIG.formatDart.packageName,
  args: CONFIG.formatDart.args
}));

function doCheckFormat() {
  return gulp.src(['Brocfile*.js', 'modules/**/*.ts', 'tools/**/*.ts', '!**/typings/**/*.d.ts'])
    .pipe(format.checkFormat('file'));
}

gulp.task('check-format', function() {
  return doCheckFormat().on('warning', function(e) {
    console.log("NOTE: this will be promoted to an ERROR in the continuous build");
  });
});

gulp.task('enforce-format', function() {
  return doCheckFormat().on('warning', function(e) {
    console.log("ERROR: Some files need formatting");
    process.exit(1);
  });
});

// ------------
// check circular dependencies in Node.js context
gulp.task('build/checkCircularDependencies', function (done) {
  var dependencyObject = madge(CONFIG.dest.js.dev.es6, {
    format: 'es6',
    paths: [CONFIG.dest.js.dev.es6],
    extensions: ['.js', '.es6'],
    onParseFile: function(data) {
      data.src = data.src.replace(/import \* as/g, "//import * as");
    }
  });
  var circularDependencies = dependencyObject.circular().getArray();
  if (circularDependencies.length > 0) {
    console.log(circularDependencies);
    process.exit(1);
  }
  done();
});

// ------------------
// web servers
gulp.task('serve.js.dev', jsserve(gulp, gulpPlugins, {
  path: CONFIG.dest.js.dev.es5,
  port: 8000
}));

gulp.task('serve.js.prod', jsserve(gulp, gulpPlugins, {
  path: CONFIG.dest.js.prod.es5,
  port: 8001
}));

gulp.task('serve.js.dart2js', jsserve(gulp, gulpPlugins, {
  path: CONFIG.dest.js.dart2js,
  port: 8002
}));

gulp.task('serve/examples.dart', pubserve(gulp, gulpPlugins, {
  command: DART_SDK.PUB,
  path: CONFIG.dest.dart + '/examples'
}));

gulp.task('serve/benchmarks.dart', pubserve(gulp, gulpPlugins, {
  command: DART_SDK.PUB,
  path: CONFIG.dest.dart + '/benchmarks'
}));

gulp.task('serve/benchmarks_external.dart', pubserve(gulp, gulpPlugins, {
  command: DART_SDK.PUB,
  path: CONFIG.dest.dart + '/benchmarks_external'
}));

// --------------
// doc generation
var Dgeni = require('dgeni');
var bower = require('bower');
var jasmine = require('gulp-jasmine');
var webserver = require('gulp-webserver');

gulp.task('docs/bower', function() {
  var bowerTask = bower.commands.install(undefined, undefined, { cwd: 'docs' });
  bowerTask.on('log', function (result) {
    console.log('bower:', result.id, result.data.endpoint.name);
  });
  bowerTask.on('error', function(error) {
    console.log(error);
  });
  return bowerTask;
});


function createDocsTasks(public) {
  var dgeniPackage = public ? './docs/public-docs-package' : './docs/dgeni-package';
  var distDocsPath = public ? 'dist/public_docs' : 'dist/docs';
  var taskPrefix = public ? 'public_docs' : 'docs';

  gulp.task(taskPrefix + '/dgeni', function() {
    try {
      var dgeni = new Dgeni([require(dgeniPackage)]);
      return dgeni.generate();
    } catch(x) {
      console.log(x);
      console.log(x.stack);
      throw x;
    }
  });

  gulp.task(taskPrefix + '/assets', ['docs/bower'], function() {
    return gulp.src('docs/bower_components/**/*')
      .pipe(gulp.dest(distDocsPath + '/lib'));
  });

  gulp.task(taskPrefix + '/app', function() {
    return gulp.src('docs/app/**/*')
      .pipe(gulp.dest(distDocsPath));
  });

  gulp.task(taskPrefix, [taskPrefix + '/assets', taskPrefix + '/app', taskPrefix + '/dgeni']);
  gulp.task(taskPrefix + '/watch', function() {
    return gulp.watch('docs/app/**/*', [taskPrefix + '/app']);
  });

  gulp.task(taskPrefix + '/test', function () {
    return gulp.src('docs/**/*.spec.js')
        .pipe(jasmine({
          includeStackTrace: true
        }));
  });

  gulp.task(taskPrefix + '/serve', function() {
    gulp.src(distDocsPath + '/')
      .pipe(webserver({
        fallback: 'index.html'
      }));
  });
}

createDocsTasks(true);
createDocsTasks(false);

// ------------------
// CI tests suites

gulp.task('test.js', function(done) {
  runSequence('test.transpiler.unittest', 'docs/test', 'test.unit.js/ci',
              'test.unit.cjs/ci', done);
});

gulp.task('test.dart', function(done) {
  runSequence('test.transpiler.unittest', 'docs/test', 'test.unit.dart/ci', done);
});

// Reuse the Travis scripts
// TODO: rename test_*.sh to test_all_*.sh
gulp.task('test.all.js', shell.task(['./scripts/ci/test_js.sh']))
gulp.task('test.all.dart', shell.task(['./scripts/ci/test_dart.sh']))

// karma tests
//     These tests run in the browser and are allowed to access
//     HTML DOM APIs.
function getBrowsersFromCLI() {
  var args = minimist(process.argv.slice(2));
  return [args.browsers?args.browsers:'DartiumWithWebPlatform']
}
gulp.task('test.unit.js', function (done) {
  karma.start({configFile: __dirname + '/karma-js.conf.js'}, done);
});
gulp.task('test.unit.dart', function (done) {
  karma.start({configFile: __dirname + '/karma-dart.conf.js'}, done);
});
gulp.task('test.unit.js/ci', function (done) {
  karma.start({configFile: __dirname + '/karma-js.conf.js',
      singleRun: true, reporters: ['dots'], browsers: getBrowsersFromCLI()}, done);
});
gulp.task('test.unit.dart/ci', function (done) {
  karma.start({configFile: __dirname + '/karma-dart.conf.js',
      singleRun: true, reporters: ['dots'], browsers: getBrowsersFromCLI()}, done);
});
gulp.task('test.unit.cjs/ci', function () {
  return gulp.src(CONFIG.test.js.cjs).pipe(jasmine({includeStackTrace: true, timeout: 1000}));
});
gulp.task('test.unit.cjs', ['build.js.cjs'], function () {
  //Run tests once
  runSequence('test.unit.cjs/ci', function() {});
});

function runNodeJasmineTests() {
  var doneDeferred = Q.defer();
  var jasmineProcess = fork('./tools/traceur-jasmine', ['dist/js/cjs/angular2/test/**/*_spec.js'], {
    stdio: 'inherit'
  });

  jasmineProcess.on('close', function (code) {
    doneDeferred.resolve();
  });

  return doneDeferred.promise;
}

gulp.task('test.unit.cjs/ci', runNodeJasmineTests);

gulp.task('test.unit.cjs', ['build.broccoli.tools'], function (done) {
  //Run tests once
  var nodeBroccoliBuilder = getBroccoli().forNodeTree();


  nodeBroccoliBuilder.doBuild().then(function() {
    gulp.start('build/linknodemodules.js.cjs');
    return runNodeJasmineTests();
  }).then(function() {
    //Watcher to transpile file changed
    gulp.watch('modules/**', function(event) {
      console.log("fs changes detected", event);
      nodeBroccoliBuilder.doBuild().then(runNodeJasmineTests);
    });
  });
});


gulp.task('test.unit.broccoli/ci', ['build.broccoli.tools'], function(done) {
  fork('./tools/traceur-jasmine', ['dist/broccoli/**/*.spec.js'], {
    stdio: 'inherit'
  }).on('close', done);
});


gulp.task('test.unit.broccoli', ['test.unit.broccoli/ci'], function() {
  gulp.watch('tools/broccoli/**', ['test.unit.broccoli/ci']);
});

// ------------------
// server tests
//     These tests run on the VM on the command-line and are
//     allowed to access the file system and network.
gulp.task('test.server.dart', runServerDartTests(gulp, gulpPlugins, {
  dest: 'dist/dart'
}));

// -----------------
// test builders
gulp.task('test.transpiler.unittest', function() {
  return gulp.src('tools/transpiler/unittest/**/*.js')
      .pipe(jasmine({
        includeStackTrace: true
      }));
});

// -----------------
// orchestrated targets

// Pure Dart packages only contain Dart code and conform to pub package layout.
// These packages need no transpilation. All code is copied over to `dist`
// unmodified and directory structure is preserved.
//
// This task also fixes relative `dependency_overrides` paths in `pubspec.yaml`
// files.
gulp.task('build/pure-packages.dart', function() {
  var through2 = require('through2');
  var yaml = require('js-yaml');
  var originalPrefix = '../../dist/dart/';

  return gulp
    .src([
      'modules_dart/**/*.dart',
      'modules_dart/**/pubspec.yaml',
    ])
    .pipe(through2.obj(function(file, enc, done) {
      if (file.path.endsWith('pubspec.yaml')) {
        // Pure packages specify dependency_overrides relative to
        // `modules_dart`, so they have to walk up and into `dist`.
        //
        // Example:
        //
        // dependency_overrides:
        //   angular2:
        //     path: ../../dist/dart/angular2
        //
        // When we copy a pure package into `dist` the relative path
        // must be updated. The code below replaces paths accordingly.
        // So the example above is turned into:
        //
        // dependency_overrides:
        //   angular2:
        //     path: ../angular2
        //
        var pubspec = yaml.safeLoad(file.contents.toString());
        var overrides = pubspec['dependency_overrides'];
        if (overrides) {
          Object.keys(overrides).forEach(function(pkg) {
            var overridePath = overrides[pkg]['path'];
            if (overridePath.startsWith(originalPrefix)) {
              overrides[pkg]['path'] = overridePath.replace(originalPrefix, '../');
            }
          });
          file.contents = new Buffer(yaml.safeDump(pubspec));
        }
      }
      this.push(file);
      done();
    }))
    .pipe(gulp.dest('dist/dart'));
});

// Builds all Dart packages, but does not compile them
gulp.task('build/packages.dart', function(done) {
  runSequence(
    'build/tree.dart',
    // Run after 'build/tree.dart' because broccoli clears the dist/dart folder
    'build/pure-packages.dart',
    'build/format.dart',
    done);
});

// Builds and compiles all Dart packages
gulp.task('build.dart', function(done) {
  runSequence(
    'build/packages.dart',
    'build/pubspec.dart',
    'build/analyze.dart',
    'build/pubbuild.dart',
    done
  );
});

gulp.task('build.broccoli.tools', function() {
  var mergedStream;

  var tsResult = gulp.src('tools/broccoli/**/*.ts')
                     .pipe(sourcemaps.init())
                     .pipe(tsc({target: 'ES5', module: 'commonjs', reporter: tsc.reporter.nullReporter()}))
                     .on('error', function(error) {
                        // gulp-typescript doesn't propagate errors from the src stream into the js stream so we are
                        // forwarding the error into the merged stream
                        mergedStream.emit('error', error);
                     });

  var destDir = gulp.dest('dist/broccoli');

  mergedStream = merge2([
    tsResult.js.pipe(sourcemaps.write('.')).pipe(destDir),
    tsResult.js.pipe(destDir)
  ]).on('end', function() {
    var BroccoliBuilder = require('./dist/broccoli/broccoli_builder').BroccoliBuilder;
    getBroccoli = function() { return BroccoliBuilder; };
  });

  return mergedStream;
});

gulp.task('broccoli.js.dev', ['build.broccoli.tools'], function() {
  return getBroccoli().forDevTree().buildOnce();
});

gulp.task('broccoli.js.prod', ['build.broccoli.tools'], function() {
  return getBroccoli().forProdTree().buildOnce();
});

gulp.task('build.js.dev', function(done) {
  runSequence(
    'broccoli.js.dev',
    'build/checkCircularDependencies',
    'check-format',
    done
  );
});

gulp.task('build.js.prod', ['broccoli.js.prod']);

gulp.task('broccoli.js.cjs', ['build.broccoli.tools'], function() {
  return getBroccoli().forNodeTree().buildOnce();
});
gulp.task('build.js.cjs', function(done) {
  runSequence(
    'broccoli.js.cjs',
    'build/linknodemodules.js.cjs',
    done
  );
});

var bundleConfig = {
  paths: {
    "*": "dist/js/prod/es6/*.es6",
    "rx/*": "node_modules/rx/*.js"
  },
  meta: {
    // auto-detection fails to detect properly here - https://github.com/systemjs/builder/issues/123
    'rx/dist/rx.all': {
        format: 'cjs'
      }
    }
};

// production build
gulp.task('bundle.js.prod', ['build.js.prod'], function() {
  return bundler.bundle(
      bundleConfig,
      'angular2/angular2',
      './dist/build/angular2.js',
      {
        sourceMaps: true
      });
});

// minified production build
// TODO: minify zone.js
gulp.task('bundle.js.min', ['build.js.prod'], function() {
  return bundler.bundle(
      bundleConfig,
      'angular2/angular2',
      './dist/build/angular2.min.js',
      {
        sourceMaps: true,
        minify: true
      });
});

// development build
gulp.task('bundle.js.dev', ['build.js.dev'], function() {
  var devBundleConfig = merge(true, bundleConfig);
  devBundleConfig.paths =
      merge(true, devBundleConfig.paths, {
       "*": "dist/js/dev/es6/*.es6"
      });
  return bundler.bundle(
      devBundleConfig,
      'angular2/angular2',
      './dist/build/angular2.dev.js',
      { sourceMaps: true });
});

// self-executing development build
// This bundle executes its main module - angular2_sfx, when loaded, without
// a corresponding System.import call. It is aimed at ES5 developers that do not
// use System loader polyfills (like system.js and es6 loader).
// see: https://github.com/systemjs/builder (SFX bundles).
gulp.task('bundle.js.sfx.dev', ['build.js.dev'], function() {
  var devBundleConfig = merge(true, bundleConfig);
  devBundleConfig.paths =
      merge(true, devBundleConfig.paths, {
       '*': 'dist/js/dev/es6/*.es6'
      });
  return bundler.bundle(
      devBundleConfig,
      'angular2/angular2_sfx',
      './dist/build/angular2.sfx.dev.js',
      { sourceMaps: true },
      /* self-exectuting */ true);
});

gulp.task('bundle.js.prod.deps', ['bundle.js.prod'], function() {
  return bundler.modify(
      ['node_modules/zone.js/zone.js', 'dist/build/angular2.js'], 'angular2.js')
      .pipe(gulp.dest('dist/bundle'));
});

gulp.task('bundle.js.min.deps', ['bundle.js.min'], function() {
  return bundler.modify(
      ['node_modules/zone.js/zone.js', 'dist/build/angular2.min.js'], 'angular2.min.js')
      .pipe(gulp.dest('dist/bundle'));
});

var JS_DEV_DEPS = ['node_modules/zone.js/zone.js', 'node_modules/zone.js/long-stack-trace-zone.js'];

gulp.task('bundle.js.dev.deps', ['bundle.js.dev'], function() {
  return bundler.modify(JS_DEV_DEPS.concat(['dist/build/angular2.dev.js']), 'angular2.dev.js')
      .pipe(insert.append('\nzone = zone.fork(Zone.longStackTraceZone);\n'))
      .pipe(gulp.dest('dist/bundle'));
});

gulp.task('bundle.js.sfx.dev.deps', ['bundle.js.sfx.dev'], function() {
  return bundler.modify(JS_DEV_DEPS.concat(['dist/build/angular2.sfx.dev.js']),
                        'angular2.sfx.dev.js')
      .pipe(insert.append('\nzone = zone.fork(Zone.longStackTraceZone);\n'))
      .pipe(gulp.dest('dist/bundle'));
});

gulp.task('bundle.js.deps', ['bundle.js.prod.deps', 'bundle.js.dev.deps', 'bundle.js.min.deps', 'bundle.js.sfx.dev.deps']);

gulp.task('build.js', ['build.js.dev', 'build.js.prod', 'build.js.cjs', 'bundle.js.deps']);

gulp.task('clean', ['build/clean.js', 'build/clean.dart', 'build/clean.docs']);

gulp.task('build', ['build.js', 'build.dart']);


// ------------
// angular material testing rules
gulp.task('build/css.js.dev', function() {
  return gulp.src('modules/*/src/**/*.scss')
      .pipe(sass())
      .pipe(autoprefixer())
      .pipe(gulp.dest(CONFIG.dest.js.dev.es5));
});

// TODO: this target is temporary until we find a way to use the SASS transformer
gulp.task('build/css.dart', function() {
  return gulp.src('dist/dart/angular2_material/lib/src/**/*.scss')
      .pipe(sass())
      .pipe(autoprefixer())
      .pipe(gulp.dest('dist/dart/angular2_material/lib/src'));
});

gulp.task('build.material', ['build.js.dev', 'build/css.js.dev']);