Have you consider npm as build tool?

[zangrafx]

Since your gulp configs are so extensive, have you considered not using gulp and take npm approach like this guy: http://blog.keithcirkel.co.uk/how-to-use-npm-as-a-build-tool/ ? There is reasonig http://blog.keithcirkel.co.uk/why-we-should-stop-using-grunt/

[mcharytoniuk]

Why we should use gulp

I am using gulp instead of such NPM approach because of:

• Task dependencies without redefining script commands:

gulp.task("foo", doSomething);
gulp.task("bar", ["foo"], doSomethingElse);
gulp.task("baz", ["foo"], doAnotherThing);

• Streams for faster file processing and transformations without storing partial results in the hard drive:

gulp.task("foo", function () {
  return gulp.src("src/**/*.js")
    .pipe(firstTransform())
    .pipe(secondTransform())
    .pipe(thirdTransform())
    .pipe(gulp.dest("./output"));
});

• I still can use gulp tasks as NPM scripts:

{
  ... 
  "scripts": {
    "lint": "gulp lint",
    "test": "gulp test"
  }
  ...
}

• I can create programmatic tasks basing on enviormental variables:

gulp.task("foo", function (done) {
   if ("production" === process.env.NODE_ENV) {
    doSomething(done);
   } else {
    doSomethingElse(done);
   }
});

• This is an additional layer of abstraction over build system for edge cases and complex tasks which gives more safety in unusial situations.
• package.json scripts will not run if host OS is not configured properly (eg. PATH variable is flawed)
• package.json scripts are host OS dependent (using platform specific features will break them on other systems)
• It would be impossible or quite hard to recreate complex build tasks:

gulp.task("foo", doFoo);
gulp.task("bar", ["foo"], function () {
  return Promise(function (resolve, reject) {
    if ("development" === process.env.NODE_ENV) {
      try {
        doSomething(resolve);
      } catch (e) {
        reject(e);
      }
    } else {
      resolve();
    }
  }).then(somethingElse);
});

• Not every library I want to use in Gulp has CLI interface.
• I can abstract common part of tasks into reusable code:

function commonPart(param) {
  return new Promise(...)
}

gulp.task("foo", function () {
  return doFoo().then(commonPart);
});

gulp.task("bar", function () {
  return doBar().then(commonPart);
});

[zangrafx]

Not every library I want to use in Gulp has CLI interface

I guess you can write js wrapper in such cases.

Streams for faster file processing (...)

"scripts": {
    "lint": "jshint **.js --reporter checkstyle > checkstyle.xml"
}

Thanks for explaining, it seems you are right for most such cases.

Anyway such tools like gulp/grunt feels like workaround for npm shortcommings, not the final solution.

[mcharytoniuk]

I agree. If you find some solution more reliable than Gulp, please let me know.