Not today...

var through = require('through2');
var gutil = require('gulp-util');

module.exports.source = function(filename) {

  // this is basically a stream, I will use the javascript scoping for
  // convenience
  var ins = through();

  // here is the piping to the previous stream, we need an object stream as we
  // will push a vinyl file in it.
  // The use will be the following:
  // someLegacyStream.pipe(utils.source()).pipe(whateverInGulpWorld);
  return through.obj(function(chunk, _, cb) {

    // Checks if we have initialized the stream with a vinyl file
    // basically, this just happen once at startup of streaming.
    if (!this._ins) {
      this._ins = ins; // this is just a convenient way of keeping a state

      // Create a vinyl file and pass "ins" stream as a content,
      // and an optional filename
      this.push(new gutil.File({contents: ins, path: filename}));
    }

    // push the chunk into our new stream in order to unify output
    ins.push(chunk);

    // as this is asynchronous just notify the system that we handled
    // the chunk
    cb();

  }, function() {
    // close the stream by pushing "null"
    ins.push(null);
    this.push(null);
  });
};

// the function treats arguments as a list of streams
module.exports.merge = function(/* streams... */) {

  var sources = []; // keep a track of streams merged
  var output  = gutil.noop(); // this will be the output,
                              // a simple stream which does nothing

  // this function will be called when unpiping and when a source stream ends
  function remove(source) {
    // remove the stream from sources array
    sources = sources.filter(function(it) { return it !== source; });

    // if it is the last stream opened and if the output is not yet closed,
    // we close it
    if (!sources.length && output.readable) output.end();
  }

  // when a stream is unpiped we remove it
  output.on('unpipe', remove);

  // for each stream (arguments is not a regular array this is why we use
  // this syntax)
  Array.prototype.slice.call(arguments).forEach(function(source) {

    // add the stream to our array of sources
    sources.push(source);

    // bind the remove function to the end event of the source
    source.once('end', remove.bind(null, source));

    // pipe the stream to our output, and let it open (the output)
    // even when the stream ends (in order to handle the others)
    source.pipe(output, {end: false});
  });

  return output;
};

module.exports.buffer = function() {

  // like the others we will create a stream object
  return through.obj(function(file, _, cb) {

    var that = this; // keep an internal reference of this across js scoping
    var bufs = []; // array of buffer we will populate

    // if it is already a buffer or it contains nothing, just push and finish
    if (file.isNull() || file.isBuffer()) {
      that.push(file);
      return cb();
    }

    // otherwise we take the content of the stream and we pipe it
    file.contents.pipe(through.obj(
      function(data, _, cb) {
        // create a new buffer with data if it is not and push it to our array
        bufs.push(Buffer.isBuffer(data) ? data : new Buffer(data));
        cb();
      },
      function() {
        // when we have retrieved all the chunks, create a copy of file
        file = file.clone();
        // and replace the content with only one huge buffer
        file.contents = Buffer.concat(bufs);

        // push it and that's it
        that.push(file);
        cb();
      }
    ));
  });
};

// we need the browserify module
var browserify = require('browserify');

// we create a utils.browserify kind of plugin here, which can take options
module.exports.browserify = function(options) {

  // initialize browserify with options
  var b = browserify(options || {debug: true});

  // here we create a stream which will be pluggable through a pipe
  // in order to avoid spending resources we will use it like this
  // gulp.src('**/*.js', {read: false}).pipe(utils.browserify()).pipe(whatever)
  // note the "read: false" which will avoid reading file content and only
  // provide vinyl file object (not opened) to the stream
  var s = through.obj(

    // here we only retrieve the files provided by the stream
    function(file, _, cb) {
      b.add(file.path);
      cb();
    },

    // and at flush, we bundle the result through browserify
    function() {
      b.bundle()

      // on error we provide a helpful message to the user through gutil.log
      .on('error', function(err) {
        var message = err.annotated || err.toString();
        gutil.log(new gutil.PluginError('browserify', message).toString());

        // and here is the magic not provided before, we notice gulp that
        // the stream as ended, and it can continue to watch our files states
        s.emit('end');
      })

      // when data is provided by the stream we simply push it into the
      // returned one
      .on('data', function(chunk) { s.push(chunk); })

      // do not forget to pass the end event also
      .on('end', function() { s.emit('end'); });
    }
  );

  return s;
};