gulpfile.js

// Load Gulp and all of our Gulp plugins
const gulp = require('gulp');
const $ = require('gulp-load-plugins')();
const shell = require('gulp-shell');
const sass = require('gulp-sass');

// Load other npm modules
const del = require('del');
const glob = require('glob');
const path = require('path');
const isparta = require('isparta');
const babelify = require('babelify');
const watchify = require('watchify');
const buffer = require('vinyl-buffer');
const browserify = require('browserify');
const runSequence = require('run-sequence');
const source = require('vinyl-source-stream');

// Gather the library data from `package.json`
const manifest = require('./package.json');
const config = manifest.babelBoilerplateOptions;
const mainFile = manifest.main;
const destinationFolder = path.dirname(mainFile);
const exportFileName = path.basename(mainFile, path.extname(mainFile));

// Remove the built files
gulp.task('clean', function(cb) {
  del([destinationFolder]).then( function() {
    cb()
  });
});

// Remove our temporary files
gulp.task('clean-tmp', function(cb) {
  del(['tmp']).then( function() {
    cb()
  });
});

// Send a notification when JSCS fails,
// so that you know your changes didn't build
function jscsNotify(file) {
  if (!file.jscs) { return; }
  return file.jscs.success ? false : 'JSCS failed';
}

function createLintTask(taskName, files) {
  gulp.task(taskName, function() {
    return gulp.src(files)
      .pipe($.plumber())
      .pipe($.eslint())
      .pipe($.eslint.format())
      .pipe($.eslint.failOnError())
      .pipe($.jscs())
      .pipe($.notify(jscsNotify));
  });
}

// Lint our source code
createLintTask('lint-src', ['src/**/*.js']);

// Lint our test code
createLintTask('lint-test', ['test/**/*.js']);

// Build N versions
gulp.task( 'build', [ 'lint-src', 'sass', 'clean' ], function() {
  return gulp.src('src/starcitizen-webgl-map.js', { read: false })
    .pipe(shell([
      'jspm install'
    ]))
    .pipe(shell([
      'jspm bundle-sfx src/starcitizen-webgl-map build/starcitizen-webgl-map.js'
    ]))
    .pipe(shell([
      'jspm bundle-sfx src/starcitizen-webgl-map --minify build/starcitizen-webgl-map.min.js'
    ]));
    //.pipe(shell([
    //  'jspm bundle-sfx js/myapp _site/js/steve.js --minify --no-mangle'
    //]));
    //.pipe(shell([
    //  'jspm bundle-sfx js/myapp _site/js/steve.js --minify --no-mangle'
    //]));
});

gulp.task( 'sass', function () {
  gulp.src( './sass/**/*.scss' )
    .pipe( sass({
      outputStyle: 'compressed',
    }).on( 'error', sass.logError ) )
    .pipe( gulp.dest( './css' ) );
});

gulp.task( 'sass:watch', function () {
  gulp.watch( './sass/**/*.scss', [ 'sass' ] );
});

//function bundle(bundler) {
//  return bundler.bundle()
//    .on('error', function(err) {
//      console.log(err.message);
//      this.emit('end');
//    })
//    .pipe($.plumber())
//    .pipe(source('./tmp/__spec-build.js'))
//    .pipe(buffer())
//    .pipe(gulp.dest(''))
//    .pipe($.livereload());
//}

//function getBundler() {
//  // Our browserify bundle is made up of our unit tests, which
//  // should individually load up pieces of our application.
//  // We also include the browserify setup file.
//  var testFiles = glob.sync('./test/unit/**/*');
//  var allFiles = ['./test/setup/browserify.js'].concat(testFiles);
//
//  // Create our bundler, passing in the arguments required for watchify
//  var bundler = browserify(allFiles, watchify.args);
//
//  // Watch the bundler, and re-bundle it whenever files change
//  bundler = watchify(bundler);
//  bundler.on('update', function() {
//    bundle(bundler);
//  });
//
//  // Set up Babelify so that ES6 works in the tests
//  bundler.transform(babelify.configure({
//    sourceMapRelative: __dirname + '/src'
//  }));
//
//  return bundler;
//};

// Build the unit test suite for running tests
// in the browser
//gulp.task('browserify', function() {
//  return bundle(getBundler());
//});

function test() {
  return gulp.src( [ 'test/setup/node.js', 'test/unit/**/*.js' ], { read: false } )
    .pipe( $.mocha({ reporter: 'spec', globals: config.mochaGlobals }) );
}

gulp.task('coverage', ['lint-src', 'lint-test'], function(done) {
  require('babel-core/register');
  gulp.src(['src/**/*.js'])
    .pipe($.istanbul({ instrumenter: isparta.Instrumenter }))
    .pipe($.istanbul.hookRequire())
    .on('finish', function() {
      return test()
        .pipe($.istanbul.writeReports())
        .on('end', done);
    });
});

// Lint and run our tests
gulp.task('test', ['lint-src', 'lint-test'], function() {
  require('babel-core/register');
  return test();
});

// Ensure that linting occurs before browserify runs. This prevents
// the build from breaking due to poorly formatted code.
gulp.task('build-in-sequence', function(callback) {
  runSequence(['lint-src', 'lint-test'], 'browserify', callback);
});

// These are JS files that should be watched by Gulp. When running tests in the browser,
// watchify is used instead, so these aren't included.
const jsWatchFiles = ['src/**/*', 'test/**/*'];
// These are files other than JS files which are to be watched. They are always watched.
const otherWatchFiles = ['package.json', '**/.eslintrc', '.jscsrc'];

// Run the headless unit tests as you make changes.
gulp.task('watch', function() {
  const watchFiles = jsWatchFiles.concat(otherWatchFiles);
  gulp.watch(watchFiles, ['test']);
});

// Set up a livereload environment for our spec runner
gulp.task('test-browser', ['build-in-sequence'], function() {
  $.livereload.listen({port: 35729, host: 'localhost', start: true});
  return gulp.watch(otherWatchFiles, ['build-in-sequence']);
});

// An alias of test
gulp.task('default', ['test']);