Demo for query storing
Change-Id: I947bcac841992c3f6cfd01ab337c265b0d01cb70
diff --git a/node_modules/vinyl/index.js b/node_modules/vinyl/index.js
new file mode 100644
index 0000000..3a16e91
--- /dev/null
+++ b/node_modules/vinyl/index.js
@@ -0,0 +1,338 @@
+'use strict';
+
+var path = require('path');
+var util = require('util');
+var isBuffer = require('buffer').Buffer.isBuffer;
+
+var clone = require('clone');
+var cloneable = require('cloneable-readable');
+var replaceExt = require('replace-ext');
+var cloneStats = require('clone-stats');
+var cloneBuffer = require('clone-buffer');
+var removeTrailingSep = require('remove-trailing-separator');
+
+var isStream = require('./lib/is-stream');
+var normalize = require('./lib/normalize');
+var inspectStream = require('./lib/inspect-stream');
+
+var builtInFields = [
+ '_contents', '_symlink', 'contents', 'stat', 'history', 'path',
+ '_base', 'base', '_cwd', 'cwd',
+];
+
+function File(file) {
+ var self = this;
+
+ if (!file) {
+ file = {};
+ }
+
+ // Stat = files stats object
+ this.stat = file.stat || null;
+
+ // Contents = stream, buffer, or null if not read
+ this.contents = file.contents || null;
+
+ // Replay path history to ensure proper normalization and trailing sep
+ var history = Array.prototype.slice.call(file.history || []);
+ if (file.path) {
+ history.push(file.path);
+ }
+ this.history = [];
+ history.forEach(function(path) {
+ self.path = path;
+ });
+
+ this.cwd = file.cwd || process.cwd();
+ this.base = file.base;
+
+ this._isVinyl = true;
+
+ this._symlink = null;
+
+ // Set custom properties
+ Object.keys(file).forEach(function(key) {
+ if (self.constructor.isCustomProp(key)) {
+ self[key] = file[key];
+ }
+ });
+}
+
+File.prototype.isBuffer = function() {
+ return isBuffer(this.contents);
+};
+
+File.prototype.isStream = function() {
+ return isStream(this.contents);
+};
+
+File.prototype.isNull = function() {
+ return (this.contents === null);
+};
+
+File.prototype.isDirectory = function() {
+ if (!this.isNull()) {
+ return false;
+ }
+
+ if (this.stat && typeof this.stat.isDirectory === 'function') {
+ return this.stat.isDirectory();
+ }
+
+ return false;
+};
+
+File.prototype.isSymbolic = function() {
+ if (!this.isNull()) {
+ return false;
+ }
+
+ if (this.stat && typeof this.stat.isSymbolicLink === 'function') {
+ return this.stat.isSymbolicLink();
+ }
+
+ return false;
+};
+
+File.prototype.clone = function(opt) {
+ var self = this;
+
+ if (typeof opt === 'boolean') {
+ opt = {
+ deep: opt,
+ contents: true,
+ };
+ } else if (!opt) {
+ opt = {
+ deep: true,
+ contents: true,
+ };
+ } else {
+ opt.deep = opt.deep === true;
+ opt.contents = opt.contents !== false;
+ }
+
+ // Clone our file contents
+ var contents;
+ if (this.isStream()) {
+ contents = this.contents.clone();
+ } else if (this.isBuffer()) {
+ contents = opt.contents ? cloneBuffer(this.contents) : this.contents;
+ }
+
+ var file = new this.constructor({
+ cwd: this.cwd,
+ base: this.base,
+ stat: (this.stat ? cloneStats(this.stat) : null),
+ history: this.history.slice(),
+ contents: contents,
+ });
+
+ if (this.isSymbolic()) {
+ file.symlink = this.symlink;
+ }
+
+ // Clone our custom properties
+ Object.keys(this).forEach(function(key) {
+ if (self.constructor.isCustomProp(key)) {
+ file[key] = opt.deep ? clone(self[key], true) : self[key];
+ }
+ });
+ return file;
+};
+
+File.prototype.inspect = function() {
+ var inspect = [];
+
+ // Use relative path if possible
+ var filePath = this.path ? this.relative : null;
+
+ if (filePath) {
+ inspect.push('"' + filePath + '"');
+ }
+
+ if (this.isBuffer()) {
+ inspect.push(this.contents.inspect());
+ }
+
+ if (this.isStream()) {
+ inspect.push(inspectStream(this.contents));
+ }
+
+ return '<File ' + inspect.join(' ') + '>';
+};
+
+// Newer Node.js versions use this symbol for custom inspection.
+if (util.inspect.custom) {
+ File.prototype[util.inspect.custom] = File.prototype.inspect;
+}
+
+File.isCustomProp = function(key) {
+ return builtInFields.indexOf(key) === -1;
+};
+
+File.isVinyl = function(file) {
+ return (file && file._isVinyl === true) || false;
+};
+
+// Virtual attributes
+// Or stuff with extra logic
+Object.defineProperty(File.prototype, 'contents', {
+ get: function() {
+ return this._contents;
+ },
+ set: function(val) {
+ if (!isBuffer(val) && !isStream(val) && (val !== null)) {
+ throw new Error('File.contents can only be a Buffer, a Stream, or null.');
+ }
+
+ // Ask cloneable if the stream is a already a cloneable
+ // this avoid piping into many streams
+ // reducing the overhead of cloning
+ if (isStream(val) && !cloneable.isCloneable(val)) {
+ val = cloneable(val);
+ }
+
+ this._contents = val;
+ },
+});
+
+Object.defineProperty(File.prototype, 'cwd', {
+ get: function() {
+ return this._cwd;
+ },
+ set: function(cwd) {
+ if (!cwd || typeof cwd !== 'string') {
+ throw new Error('cwd must be a non-empty string.');
+ }
+ this._cwd = removeTrailingSep(normalize(cwd));
+ },
+});
+
+Object.defineProperty(File.prototype, 'base', {
+ get: function() {
+ return this._base || this._cwd;
+ },
+ set: function(base) {
+ if (base == null) {
+ delete this._base;
+ return;
+ }
+ if (typeof base !== 'string' || !base) {
+ throw new Error('base must be a non-empty string, or null/undefined.');
+ }
+ base = removeTrailingSep(normalize(base));
+ if (base !== this._cwd) {
+ this._base = base;
+ } else {
+ delete this._base;
+ }
+ },
+});
+
+// TODO: Should this be moved to vinyl-fs?
+Object.defineProperty(File.prototype, 'relative', {
+ get: function() {
+ if (!this.path) {
+ throw new Error('No path specified! Can not get relative.');
+ }
+ return path.relative(this.base, this.path);
+ },
+ set: function() {
+ throw new Error('File.relative is generated from the base and path attributes. Do not modify it.');
+ },
+});
+
+Object.defineProperty(File.prototype, 'dirname', {
+ get: function() {
+ if (!this.path) {
+ throw new Error('No path specified! Can not get dirname.');
+ }
+ return path.dirname(this.path);
+ },
+ set: function(dirname) {
+ if (!this.path) {
+ throw new Error('No path specified! Can not set dirname.');
+ }
+ this.path = path.join(dirname, this.basename);
+ },
+});
+
+Object.defineProperty(File.prototype, 'basename', {
+ get: function() {
+ if (!this.path) {
+ throw new Error('No path specified! Can not get basename.');
+ }
+ return path.basename(this.path);
+ },
+ set: function(basename) {
+ if (!this.path) {
+ throw new Error('No path specified! Can not set basename.');
+ }
+ this.path = path.join(this.dirname, basename);
+ },
+});
+
+// Property for getting/setting stem of the filename.
+Object.defineProperty(File.prototype, 'stem', {
+ get: function() {
+ if (!this.path) {
+ throw new Error('No path specified! Can not get stem.');
+ }
+ return path.basename(this.path, this.extname);
+ },
+ set: function(stem) {
+ if (!this.path) {
+ throw new Error('No path specified! Can not set stem.');
+ }
+ this.path = path.join(this.dirname, stem + this.extname);
+ },
+});
+
+Object.defineProperty(File.prototype, 'extname', {
+ get: function() {
+ if (!this.path) {
+ throw new Error('No path specified! Can not get extname.');
+ }
+ return path.extname(this.path);
+ },
+ set: function(extname) {
+ if (!this.path) {
+ throw new Error('No path specified! Can not set extname.');
+ }
+ this.path = replaceExt(this.path, extname);
+ },
+});
+
+Object.defineProperty(File.prototype, 'path', {
+ get: function() {
+ return this.history[this.history.length - 1];
+ },
+ set: function(path) {
+ if (typeof path !== 'string') {
+ throw new Error('path should be a string.');
+ }
+ path = removeTrailingSep(normalize(path));
+
+ // Record history only when path changed
+ if (path && path !== this.path) {
+ this.history.push(path);
+ }
+ },
+});
+
+Object.defineProperty(File.prototype, 'symlink', {
+ get: function() {
+ return this._symlink;
+ },
+ set: function(symlink) {
+ // TODO: should this set the mode to symbolic if set?
+ if (typeof symlink !== 'string') {
+ throw new Error('symlink should be a string');
+ }
+
+ this._symlink = removeTrailingSep(normalize(symlink));
+ },
+});
+
+module.exports = File;