Fix actions/tour

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

@@ -0,0 +1,46 @@
+'use strict';
+
+var gs = require('glob-stream');
+var pipeline = require('streamx').pipeline;
+var toThrough = require('to-through');
+var isValidGlob = require('is-valid-glob');
+var normalizePath = require('normalize-path');
+var createResolver = require('resolve-options');
+
+var config = require('./options');
+var prepare = require('./prepare');
+var wrapVinyl = require('./wrap-vinyl');
+var sourcemap = require('./sourcemap');
+var readContents = require('./read-contents');
+var resolveSymlinks = require('./resolve-symlinks');
+
+function normalize(glob) {
+  return normalizePath(glob, false);
+}
+
+function src(glob, opt) {
+  var optResolver = createResolver(config, opt);
+
+  if (!isValidGlob(glob)) {
+    throw new Error('Invalid glob argument: ' + glob);
+  }
+
+  if (!Array.isArray(glob)) {
+    glob = [glob];
+  }
+
+  glob = glob.map(normalize);
+
+  var outputStream = pipeline(
+    gs(glob, opt),
+    wrapVinyl(optResolver),
+    resolveSymlinks(optResolver),
+    prepare(optResolver),
+    readContents(optResolver),
+    sourcemap(optResolver)
+  );
+
+  return toThrough(outputStream);
+}
+
+module.exports = src;

node_modules/vinyl-fs/lib/src/options.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var DEFAULT_ENCODING = require('../constants').DEFAULT_ENCODING;
+
+var config = {
+  buffer: {
+    type: 'boolean',
+    default: true,
+  },
+  read: {
+    type: 'boolean',
+    default: true,
+  },
+  since: {
+    type: 'date',
+  },
+  removeBOM: {
+    type: 'boolean',
+    default: true,
+  },
+  encoding: {
+    type: ['string', 'boolean'],
+    default: DEFAULT_ENCODING,
+  },
+  sourcemaps: {
+    type: 'boolean',
+    default: false,
+  },
+  resolveSymlinks: {
+    type: 'boolean',
+    default: true,
+  },
+};
+
+module.exports = config;

node_modules/vinyl-fs/lib/src/prepare.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var Transform = require('streamx').Transform;
+
+function prepareRead(optResolver) {
+  function normalize(file, callback) {
+    var since = optResolver.resolve('since', file);
+
+    if (file.stat) {
+      // Skip this file if since option is set and current file is too old
+      if (Math.max(file.stat.mtime, file.stat.ctime) <= since) {
+        return callback();
+      }
+    }
+
+    return callback(null, file);
+  }
+
+  return new Transform({
+    transform: normalize,
+  });
+}
+
+module.exports = prepareRead;

node_modules/vinyl-fs/lib/src/read-contents/index.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var Transform = require('streamx').Transform;
+
+var readDir = require('./read-dir');
+var readStream = require('./read-stream');
+var readBuffer = require('./read-buffer');
+var readSymbolicLink = require('./read-symbolic-link');
+
+function readContents(optResolver) {
+  function readFile(file, callback) {
+    // Skip reading contents if read option says so
+    var read = optResolver.resolve('read', file);
+    if (!read) {
+      return callback(null, file);
+    }
+
+    // Don't fail to read a directory
+    if (file.isDirectory()) {
+      return readDir(file, optResolver, onRead);
+    }
+
+    // Process symbolic links included with `resolveSymlinks` option
+    if (file.stat && file.stat.isSymbolicLink()) {
+      return readSymbolicLink(file, optResolver, onRead);
+    }
+
+    // Read and pass full contents
+    var buffer = optResolver.resolve('buffer', file);
+    if (buffer) {
+      return readBuffer(file, optResolver, onRead);
+    }
+
+    // Don't buffer anything - just pass streams
+    return readStream(file, optResolver, onRead);
+
+    // This is invoked by the various readXxx modules when they've finished
+    // reading the contents.
+    function onRead(readErr) {
+      if (readErr) {
+        return callback(readErr);
+      }
+      callback(null, file);
+    }
+  }
+
+  return new Transform({
+    transform: readFile,
+  });
+}
+
+module.exports = readContents;

node_modules/vinyl-fs/lib/src/read-contents/read-buffer.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var fs = require('graceful-fs');
+
+var getCodec = require('../../codecs');
+var DEFAULT_ENCODING = require('../../constants').DEFAULT_ENCODING;
+
+function bufferFile(file, optResolver, onRead) {
+  var encoding = optResolver.resolve('encoding', file);
+  var codec = getCodec(encoding);
+  if (encoding && !codec) {
+    return onRead(new Error('Unsupported encoding: ' + encoding));
+  }
+
+  fs.readFile(file.path, onReadFile);
+
+  function onReadFile(readErr, contents) {
+    if (readErr) {
+      return onRead(readErr);
+    }
+
+    if (encoding) {
+      var removeBOM = codec.bomAware && optResolver.resolve('removeBOM', file);
+
+      if (removeBOM || codec.enc !== DEFAULT_ENCODING) {
+        contents = codec.decode(contents, { removeBOM: removeBOM });
+        contents = getCodec(DEFAULT_ENCODING).encode(contents);
+      }
+    }
+
+    file.contents = contents;
+
+    onRead();
+  }
+}
+
+module.exports = bufferFile;

node_modules/vinyl-fs/lib/src/read-contents/read-dir.js

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

node_modules/vinyl-fs/lib/src/read-contents/read-stream.js

@@ -0,0 +1,46 @@
+'use strict';
+
+var fs = require('graceful-fs');
+var Composer = require('stream-composer');
+
+var getCodec = require('../../codecs');
+var DEFAULT_ENCODING = require('../../constants').DEFAULT_ENCODING;
+
+function streamFile(file, optResolver, onRead) {
+  var encoding = optResolver.resolve('encoding', file);
+  var codec = getCodec(encoding);
+  if (encoding && !codec) {
+    return onRead(new Error('Unsupported encoding: ' + encoding));
+  }
+
+  var filePath = file.path;
+
+  file.contents = new Composer({
+    open: function (cb) {
+      var contents = fs.createReadStream(filePath);
+      var streams = [contents];
+
+      if (encoding) {
+        var removeBOM =
+          codec.bomAware && optResolver.resolve('removeBOM', file);
+
+        if (removeBOM || codec.enc !== DEFAULT_ENCODING) {
+          streams.push(codec.decodeStream({ removeBOM: removeBOM }));
+          streams.push(getCodec(DEFAULT_ENCODING).encodeStream());
+        }
+      }
+
+      if (streams.length > 1) {
+        this.setPipeline(streams);
+      } else {
+        this.setReadable(contents);
+      }
+
+      cb();
+    },
+  });
+
+  onRead();
+}
+
+module.exports = streamFile;

node_modules/vinyl-fs/lib/src/read-contents/read-symbolic-link.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var fs = require('graceful-fs');
+
+function readLink(file, optResolver, onRead) {
+  fs.readlink(file.path, onReadlink);
+
+  function onReadlink(readErr, target) {
+    if (readErr) {
+      return onRead(readErr);
+    }
+
+    // Store the link target path
+    file.symlink = target;
+
+    onRead();
+  }
+}
+
+module.exports = readLink;

node_modules/vinyl-fs/lib/src/resolve-symlinks.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var Transform = require('streamx').Transform;
+var fo = require('../file-operations');
+
+function resolveSymlinks(optResolver) {
+  // A stat property is exposed on file objects as a (wanted) side effect
+  function resolveFile(file, callback) {
+    fo.reflectLinkStat(file.path, file, onReflect);
+
+    function onReflect(statErr) {
+      if (statErr) {
+        return callback(statErr);
+      }
+
+      if (!file.stat.isSymbolicLink()) {
+        return callback(null, file);
+      }
+
+      var resolveSymlinks = optResolver.resolve('resolveSymlinks', file);
+
+      if (!resolveSymlinks) {
+        return callback(null, file);
+      }
+
+      fo.findSymlinkHardpath(file.path, onSymlinkHardpath);
+    }
+
+    function onSymlinkHardpath(readlinkErr, path) {
+      if (readlinkErr) {
+        return callback(readlinkErr);
+      }
+
+      // Get target's stats
+      fo.reflectStat(path, file, onReflect);
+    }
+  }
+
+  return new Transform({
+    transform: resolveFile,
+  });
+}
+
+module.exports = resolveSymlinks;

node_modules/vinyl-fs/lib/src/sourcemap.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var Transform = require('streamx').Transform;
+var sourcemap = require('vinyl-sourcemap');
+
+function sourcemapStream(optResolver) {
+  function addSourcemap(file, callback) {
+    var srcMap = optResolver.resolve('sourcemaps', file);
+
+    if (!srcMap) {
+      return callback(null, file);
+    }
+
+    sourcemap.add(file, onAdd);
+
+    function onAdd(sourcemapErr, updatedFile) {
+      if (sourcemapErr) {
+        return callback(sourcemapErr);
+      }
+
+      callback(null, updatedFile);
+    }
+  }
+
+  return new Transform({
+    transform: addSourcemap,
+  });
+}
+
+module.exports = sourcemapStream;

node_modules/vinyl-fs/lib/src/wrap-vinyl.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var File = require('vinyl');
+var Transform = require('streamx').Transform;
+
+function wrapVinyl() {
+  function wrapFile(globFile, callback) {
+    var file = new File(globFile);
+
+    callback(null, file);
+  }
+
+  return new Transform({
+    transform: wrapFile,
+  });
+}
+
+module.exports = wrapVinyl;