Current Dev State

static/js/ketcher2/node_modules/vinyl-fs/lib/dest/index.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var defaults = require('defaults');
+var path = require('path');
+var through2 = require('through2');
+var mkdirp = require('mkdirp');
+var fs = require('graceful-fs');
+
+var writeContents = require('./writeContents');
+
+
+function dest(outFolder, opt) {
+  opt = opt || {};
+  if (typeof outFolder !== 'string' && typeof outFolder !== 'function') {
+    throw new Error('Invalid output folder');
+  }
+
+  var options = defaults(opt, {
+    cwd: process.cwd()
+  });
+
+  if (typeof options.mode === 'string') {
+    options.mode = parseInt(options.mode, 8);
+  }
+
+  var cwd = path.resolve(options.cwd);
+
+  function saveFile (file, enc, cb) {
+    var basePath;
+    if (typeof outFolder === 'string') {
+      basePath = path.resolve(cwd, outFolder);
+    }
+    if (typeof outFolder === 'function') {
+      basePath = path.resolve(cwd, outFolder(file));
+    }
+    var writePath = path.resolve(basePath, file.relative);
+    var writeFolder = path.dirname(writePath);
+
+    // wire up new properties
+    file.stat = file.stat ? file.stat : new fs.Stats();
+    file.stat.mode = (options.mode || file.stat.mode);
+    file.cwd = cwd;
+    file.base = basePath;
+    file.path = writePath;
+
+    // mkdirp the folder the file is going in
+    mkdirp(writeFolder, function(err){
+      if (err) {
+        return cb(err);
+      }
+      writeContents(writePath, file, cb);
+    });
+  }
+
+  var stream = through2.obj(saveFile);
+  // TODO: option for either backpressure or lossy
+  stream.resume();
+  return stream;
+}
+
+module.exports = dest;

static/js/ketcher2/node_modules/vinyl-fs/lib/dest/writeContents/index.js

@@ -0,0 +1,59 @@
+'use strict';
+
+var fs = require('fs');
+var writeDir = require('./writeDir');
+var writeStream = require('./writeStream');
+var writeBuffer = require('./writeBuffer');
+
+function writeContents(writePath, file, cb) {
+  var written = function(err) {
+    var done = function(err) {
+      cb(err, file);
+    };
+    if (err) {
+      return done(err);
+    }
+
+    if (!file.stat || typeof file.stat.mode !== 'number') {
+      return done();
+    }
+
+    fs.stat(writePath, function(err, st) {
+      if (err) {
+        return done(err);
+      }
+      // octal 7777 = decimal 4095
+      var currentMode = (st.mode & 4095);
+      if (currentMode === file.stat.mode) {
+        return done();
+      }
+      fs.chmod(writePath, file.stat.mode, done);
+    });
+  };
+
+  // if directory then mkdirp it
+  if (file.isDirectory()) {
+    writeDir(writePath, file, written);
+    return;
+  }
+
+  // stream it to disk yo
+  if (file.isStream()) {
+    writeStream(writePath, file, written);
+    return;
+  }
+
+  // write it like normal
+  if (file.isBuffer()) {
+    writeBuffer(writePath, file, written);
+    return;
+  }
+
+  // if no contents then do nothing
+  if (file.isNull()) {
+    cb(null, file);
+    return;
+  }
+}
+
+module.exports = writeContents;

static/js/ketcher2/node_modules/vinyl-fs/lib/dest/writeContents/writeBuffer.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var fs = require('graceful-fs');
+
+function writeBuffer(writePath, file, cb) {
+  var opt = {
+    mode: file.stat.mode
+  };
+
+  fs.writeFile(writePath, file.contents, opt, cb);
+}
+
+module.exports = writeBuffer;

static/js/ketcher2/node_modules/vinyl-fs/lib/dest/writeContents/writeDir.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var mkdirp = require('mkdirp');
+
+function writeDir (writePath, file, cb) {
+  mkdirp(writePath, file.stat.mode, cb);
+}
+
+module.exports = writeDir;

static/js/ketcher2/node_modules/vinyl-fs/lib/dest/writeContents/writeStream.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var streamFile = require('../../src/getContents/streamFile');
+var fs = require('graceful-fs');
+
+function writeStream (writePath, file, cb) {
+  var opt = {
+    mode: file.stat.mode
+  };
+
+  var outStream = fs.createWriteStream(writePath, opt);
+
+  file.contents.once('error', cb);
+  outStream.once('error', cb);
+  outStream.once('finish', function() {
+    streamFile(file, cb);
+  });
+
+  file.contents.pipe(outStream);
+}
+
+module.exports = writeStream;

static/js/ketcher2/node_modules/vinyl-fs/lib/src/getContents/bufferFile.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var fs = require('graceful-fs');
+var stripBom = require('strip-bom');
+
+function bufferFile(file, cb) {
+  fs.readFile(file.path, function (err, data) {
+    if (err) {
+      return cb(err);
+    }
+    file.contents = stripBom(data);
+    cb(null, file);
+  });
+}
+
+module.exports = bufferFile;

static/js/ketcher2/node_modules/vinyl-fs/lib/src/getContents/index.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var through2 = require('through2');
+
+var readDir = require('./readDir');
+var bufferFile = require('./bufferFile');
+var streamFile = require('./streamFile');
+
+function getContents(opt) {
+  return through2.obj(function (file, enc, cb) {
+    // don't fail to read a directory
+    if (file.isDirectory()) {
+      return readDir(file, cb);
+    }
+
+    // read and pass full contents
+    if (opt.buffer !== false) {
+      return bufferFile(file, cb);
+    }
+
+    // dont buffer anything - just pass streams
+    return streamFile(file, cb);
+  });
+}
+
+module.exports = getContents;

static/js/ketcher2/node_modules/vinyl-fs/lib/src/getContents/readDir.js

@@ -0,0 +1,8 @@
+'use strict';
+
+function readDir(file, cb) {
+  // do nothing for now
+  cb(null, file);
+}
+
+module.exports = readDir;

static/js/ketcher2/node_modules/vinyl-fs/lib/src/getContents/streamFile.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var fs = require('graceful-fs');
+var stripBom = require('strip-bom');
+
+function streamFile(file, cb) {
+  file.contents = fs.createReadStream(file.path)
+    .pipe(stripBom.stream());
+
+  cb(null, file);
+}
+
+module.exports = streamFile;

static/js/ketcher2/node_modules/vinyl-fs/lib/src/getStats.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var through2 = require('through2');
+var fs = require('graceful-fs');
+
+function getStats() {
+  return through2.obj(fetchStats);
+}
+
+function fetchStats(file, enc, cb) {
+  fs.lstat(file.path, function (err, stat) {
+    if (stat) {
+      file.stat = stat;
+    }
+    cb(err, file);
+  });
+}
+
+module.exports = getStats;

static/js/ketcher2/node_modules/vinyl-fs/lib/src/index.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var defaults = require('defaults');
+var through = require('through2');
+var gs = require('glob-stream');
+var File = require('vinyl');
+
+var getContents = require('./getContents');
+var getStats = require('./getStats');
+
+function createFile (globFile, enc, cb) {
+  cb(null, new File(globFile));
+}
+
+function src(glob, opt) {
+  opt = opt || {};
+  var pass = through.obj();
+
+  if (!isValidGlob(glob)) {
+    throw new Error('Invalid glob argument: ' + glob);
+  }
+  // return dead stream if empty array
+  if (Array.isArray(glob) && glob.length === 0) {
+    process.nextTick(pass.end.bind(pass));
+    return pass;
+  }
+
+  var options = defaults(opt, {
+    read: true,
+    buffer: true
+  });
+
+  var globStream = gs.create(glob, options);
+
+  // when people write to use just pass it through
+  var outputStream = globStream
+    .pipe(through.obj(createFile))
+    .pipe(getStats(options));
+
+  if (options.read !== false) {
+    outputStream = outputStream
+      .pipe(getContents(options));
+  }
+
+  return outputStream.pipe(pass);
+}
+
+function isValidGlob(glob) {
+  if (typeof glob === 'string') {
+    return true;
+  }
+  if (Array.isArray(glob) && glob.length !== 0) {
+    return glob.every(isValidGlob);
+  }
+  if (Array.isArray(glob) && glob.length === 0) {
+    return true;
+  }
+  return false;
+}
+
+module.exports = src;