Initial

Client/node_modules/vinyl-fs/lib/dest/index.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var through2 = require('through2');
+var sourcemaps = require('gulp-sourcemaps');
+var duplexify = require('duplexify');
+var sink = require('../sink');
+var prepareWrite = require('../prepareWrite');
+var writeContents = require('./writeContents');
+
+function dest(outFolder, opt) {
+  if (!opt) {
+    opt = {};
+  }
+
+  function saveFile(file, enc, cb) {
+    prepareWrite(outFolder, file, opt, function(err, writePath) {
+      if (err) {
+        return cb(err);
+      }
+      writeContents(writePath, file, cb);
+    });
+  }
+
+  var saveStream = through2.obj(opt, saveFile);
+  if (!opt.sourcemaps) {
+    // Sink the save stream to start flowing
+    // Do this on nextTick, it will flow at slowest speed of piped streams
+    process.nextTick(sink(saveStream));
+
+    return saveStream;
+  }
+
+  var sourcemapOpt = opt.sourcemaps;
+  if (typeof sourcemapOpt === 'boolean') {
+    sourcemapOpt = {};
+  }
+  if (typeof sourcemapOpt === 'string') {
+    sourcemapOpt = {
+      path: sourcemapOpt,
+    };
+  }
+
+  var mapStream = sourcemaps.write(sourcemapOpt.path, sourcemapOpt);
+  var outputStream = duplexify.obj(mapStream, saveStream);
+  mapStream.pipe(saveStream);
+
+  // Sink the output stream to start flowing
+  // Do this on nextTick, it will flow at slowest speed of piped streams
+  process.nextTick(sink(outputStream));
+
+  return outputStream;
+}
+
+module.exports = dest;

Client/node_modules/vinyl-fs/lib/dest/writeContents/index.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var writeDir = require('./writeDir');
+var writeStream = require('./writeStream');
+var writeBuffer = require('./writeBuffer');
+var writeSymbolicLink = require('./writeSymbolicLink');
+
+function writeContents(writePath, file, callback) {
+  // If directory then mkdirp it
+  if (file.isDirectory()) {
+    return writeDir(writePath, file, written);
+  }
+
+  // Stream it to disk yo
+  if (file.isStream()) {
+    return writeStream(writePath, file, written);
+  }
+
+  // Write it as a symlink
+  if (file.symlink) {
+    return writeSymbolicLink(writePath, file, written);
+  }
+
+  // Write it like normal
+  if (file.isBuffer()) {
+    return writeBuffer(writePath, file, written);
+  }
+
+  // If no contents then do nothing
+  if (file.isNull()) {
+    return written();
+  }
+
+  // This is invoked by the various writeXxx modules when they've finished
+  // writing the contents.
+  function written(err) {
+    if (isErrorFatal(err)) {
+      return callback(err);
+    }
+
+    callback(null, file);
+  }
+
+  function isErrorFatal(err) {
+    if (!err) {
+      return false;
+    }
+
+    if (err.code === 'EEXIST' && file.flag === 'wx') {
+      // Handle scenario for file overwrite failures.
+      return false;   // "These aren't the droids you're looking for"
+    }
+
+    // Otherwise, this is a fatal error
+    return true;
+  }
+}
+
+module.exports = writeContents;

Client/node_modules/vinyl-fs/lib/dest/writeContents/writeBuffer.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var fo = require('../../fileOperations');
+
+function writeBuffer(writePath, file, written) {
+  var opt = {
+    mode: file.stat.mode,
+    flag: file.flag,
+  };
+
+  fo.writeFile(writePath, file.contents, opt, onWriteFile);
+
+  function onWriteFile(writeErr, fd) {
+    if (writeErr) {
+      return fo.closeFd(writeErr, fd, written);
+    }
+
+    fo.updateMetadata(fd, file, onUpdate);
+  }
+
+  function onUpdate(statErr, fd) {
+    fo.closeFd(statErr, fd, written);
+  }
+}
+
+module.exports = writeBuffer;

Client/node_modules/vinyl-fs/lib/dest/writeContents/writeDir.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var fs = require('graceful-fs');
+var mkdirp = require('mkdirp');
+
+var fo = require('../../fileOperations');
+
+function writeDir(writePath, file, written) {
+  var mkdirpOpts = {
+    mode: file.stat.mode,
+    fs: fs,
+  };
+  mkdirp(writePath, mkdirpOpts, onMkdirp);
+
+  function onMkdirp(mkdirpErr) {
+    if (mkdirpErr) {
+      return written(mkdirpErr);
+    }
+
+    fs.open(writePath, 'r', onOpen);
+  }
+
+  function onOpen(openErr, fd) {
+    // If we don't have access, just move along
+    if (isInaccessible(openErr)) {
+      return fo.closeFd(null, fd, written);
+    }
+
+    if (openErr) {
+      return fo.closeFd(openErr, fd, written);
+    }
+
+    fo.updateMetadata(fd, file, onUpdate);
+  }
+
+  function onUpdate(statErr, fd) {
+    fo.closeFd(statErr, fd, written);
+  }
+}
+
+function isInaccessible(err) {
+    if (!err) {
+      return false;
+    }
+
+    if (err.code === 'EACCES') {
+      return true;
+    }
+
+    return false;
+  }
+
+module.exports = writeDir;

Client/node_modules/vinyl-fs/lib/dest/writeContents/writeStream.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var fs = require('graceful-fs');
+
+var fo = require('../../fileOperations');
+var streamFile = require('../../src/getContents/streamFile');
+
+function writeStream(writePath, file, written) {
+  var opt = {
+    mode: file.stat.mode,
+    flag: file.flag,
+  };
+
+  var outStream = fs.createWriteStream(writePath, opt);
+
+  file.contents.once('error', complete);
+  file.contents.once('end', readStreamEnd);
+  outStream.once('error', complete);
+  outStream.once('finish', complete);
+
+  // Streams are piped with end disabled, this prevents the
+  // WriteStream from closing the file descriptor after all
+  // data is written.
+  file.contents.pipe(outStream, { end: false });
+
+  function readStreamEnd() {
+    streamFile(file, complete);
+  }
+
+  function end(propagatedErr) {
+    outStream.end(onEnd);
+
+    function onEnd(endErr) {
+      written(propagatedErr || endErr);
+    }
+  }
+
+  // Cleanup
+  function complete(streamErr) {
+    file.contents.removeListener('error', complete);
+    file.contents.removeListener('end', readStreamEnd);
+    outStream.removeListener('error', complete);
+    outStream.removeListener('finish', complete);
+
+    if (streamErr) {
+      return end(streamErr);
+    }
+
+    if (typeof outStream.fd !== 'number') {
+      return end();
+    }
+
+    fo.updateMetadata(outStream.fd, file, end);
+  }
+}
+
+module.exports = writeStream;

Client/node_modules/vinyl-fs/lib/dest/writeContents/writeSymbolicLink.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var fs = require('graceful-fs');
+
+function writeSymbolicLink(writePath, file, written) {
+  // TODO handle symlinks properly
+  fs.symlink(file.symlink, writePath, function(err) {
+    if (isFatalError(err)) {
+      return written(err);
+    }
+
+    written();
+  });
+}
+
+function isFatalError(err) {
+  return (err && err.code !== 'EEXIST');
+}
+
+module.exports = writeSymbolicLink;