Demo for query storing
Change-Id: I947bcac841992c3f6cfd01ab337c265b0d01cb70
diff --git a/node_modules/micromatch/lib/.DS_Store b/node_modules/micromatch/lib/.DS_Store
new file mode 100644
index 0000000..5008ddf
--- /dev/null
+++ b/node_modules/micromatch/lib/.DS_Store
Binary files differ
diff --git a/node_modules/micromatch/lib/cache.js b/node_modules/micromatch/lib/cache.js
new file mode 100644
index 0000000..fffc4c1
--- /dev/null
+++ b/node_modules/micromatch/lib/cache.js
@@ -0,0 +1 @@
+module.exports = new (require('fragment-cache'))();
diff --git a/node_modules/micromatch/lib/compilers.js b/node_modules/micromatch/lib/compilers.js
new file mode 100644
index 0000000..85cda4f
--- /dev/null
+++ b/node_modules/micromatch/lib/compilers.js
@@ -0,0 +1,77 @@
+'use strict';
+
+var nanomatch = require('nanomatch');
+var extglob = require('extglob');
+
+module.exports = function(snapdragon) {
+ var compilers = snapdragon.compiler.compilers;
+ var opts = snapdragon.options;
+
+ // register nanomatch compilers
+ snapdragon.use(nanomatch.compilers);
+
+ // get references to some specific nanomatch compilers before they
+ // are overridden by the extglob and/or custom compilers
+ var escape = compilers.escape;
+ var qmark = compilers.qmark;
+ var slash = compilers.slash;
+ var star = compilers.star;
+ var text = compilers.text;
+ var plus = compilers.plus;
+ var dot = compilers.dot;
+
+ // register extglob compilers or escape exglobs if disabled
+ if (opts.extglob === false || opts.noext === true) {
+ snapdragon.compiler.use(escapeExtglobs);
+ } else {
+ snapdragon.use(extglob.compilers);
+ }
+
+ snapdragon.use(function() {
+ this.options.star = this.options.star || function(/*node*/) {
+ return '[^\\\\/]*?';
+ };
+ });
+
+ // custom micromatch compilers
+ snapdragon.compiler
+
+ // reset referenced compiler
+ .set('dot', dot)
+ .set('escape', escape)
+ .set('plus', plus)
+ .set('slash', slash)
+ .set('qmark', qmark)
+ .set('star', star)
+ .set('text', text);
+};
+
+function escapeExtglobs(compiler) {
+ compiler.set('paren', function(node) {
+ var val = '';
+ visit(node, function(tok) {
+ if (tok.val) val += (/^\W/.test(tok.val) ? '\\' : '') + tok.val;
+ });
+ return this.emit(val, node);
+ });
+
+ /**
+ * Visit `node` with the given `fn`
+ */
+
+ function visit(node, fn) {
+ return node.nodes ? mapVisit(node.nodes, fn) : fn(node);
+ }
+
+ /**
+ * Map visit over array of `nodes`.
+ */
+
+ function mapVisit(nodes, fn) {
+ var len = nodes.length;
+ var idx = -1;
+ while (++idx < len) {
+ visit(nodes[idx], fn);
+ }
+ }
+}
diff --git a/node_modules/micromatch/lib/parsers.js b/node_modules/micromatch/lib/parsers.js
new file mode 100644
index 0000000..f80498c
--- /dev/null
+++ b/node_modules/micromatch/lib/parsers.js
@@ -0,0 +1,83 @@
+'use strict';
+
+var extglob = require('extglob');
+var nanomatch = require('nanomatch');
+var regexNot = require('regex-not');
+var toRegex = require('to-regex');
+var not;
+
+/**
+ * Characters to use in negation regex (we want to "not" match
+ * characters that are matched by other parsers)
+ */
+
+var TEXT = '([!@*?+]?\\(|\\)|\\[:?(?=.*?:?\\])|:?\\]|[*+?!^$.\\\\/])+';
+var createNotRegex = function(opts) {
+ return not || (not = textRegex(TEXT));
+};
+
+/**
+ * Parsers
+ */
+
+module.exports = function(snapdragon) {
+ var parsers = snapdragon.parser.parsers;
+
+ // register nanomatch parsers
+ snapdragon.use(nanomatch.parsers);
+
+ // get references to some specific nanomatch parsers before they
+ // are overridden by the extglob and/or parsers
+ var escape = parsers.escape;
+ var slash = parsers.slash;
+ var qmark = parsers.qmark;
+ var plus = parsers.plus;
+ var star = parsers.star;
+ var dot = parsers.dot;
+
+ // register extglob parsers
+ snapdragon.use(extglob.parsers);
+
+ // custom micromatch parsers
+ snapdragon.parser
+ .use(function() {
+ // override "notRegex" created in nanomatch parser
+ this.notRegex = /^\!+(?!\()/;
+ })
+ // reset the referenced parsers
+ .capture('escape', escape)
+ .capture('slash', slash)
+ .capture('qmark', qmark)
+ .capture('star', star)
+ .capture('plus', plus)
+ .capture('dot', dot)
+
+ /**
+ * Override `text` parser
+ */
+
+ .capture('text', function() {
+ if (this.isInside('bracket')) return;
+ var pos = this.position();
+ var m = this.match(createNotRegex(this.options));
+ if (!m || !m[0]) return;
+
+ // escape regex boundary characters and simple brackets
+ var val = m[0].replace(/([[\]^$])/g, '\\$1');
+
+ return pos({
+ type: 'text',
+ val: val
+ });
+ });
+};
+
+/**
+ * Create text regex
+ */
+
+function textRegex(pattern) {
+ var notStr = regexNot.create(pattern, {contains: true, strictClose: false});
+ var prefix = '(?:[\\^]|\\\\|';
+ return toRegex(prefix + notStr + ')', {strictClose: false});
+}
diff --git a/node_modules/micromatch/lib/utils.js b/node_modules/micromatch/lib/utils.js
new file mode 100644
index 0000000..f0ba917
--- /dev/null
+++ b/node_modules/micromatch/lib/utils.js
@@ -0,0 +1,309 @@
+'use strict';
+
+var utils = module.exports;
+var path = require('path');
+
+/**
+ * Module dependencies
+ */
+
+var Snapdragon = require('snapdragon');
+utils.define = require('define-property');
+utils.diff = require('arr-diff');
+utils.extend = require('extend-shallow');
+utils.pick = require('object.pick');
+utils.typeOf = require('kind-of');
+utils.unique = require('array-unique');
+
+/**
+ * Returns true if the platform is windows, or `path.sep` is `\\`.
+ * This is defined as a function to allow `path.sep` to be set in unit tests,
+ * or by the user, if there is a reason to do so.
+ * @return {Boolean}
+ */
+
+utils.isWindows = function() {
+ return path.sep === '\\' || process.platform === 'win32';
+};
+
+/**
+ * Get the `Snapdragon` instance to use
+ */
+
+utils.instantiate = function(ast, options) {
+ var snapdragon;
+ // if an instance was created by `.parse`, use that instance
+ if (utils.typeOf(ast) === 'object' && ast.snapdragon) {
+ snapdragon = ast.snapdragon;
+ // if the user supplies an instance on options, use that instance
+ } else if (utils.typeOf(options) === 'object' && options.snapdragon) {
+ snapdragon = options.snapdragon;
+ // create a new instance
+ } else {
+ snapdragon = new Snapdragon(options);
+ }
+
+ utils.define(snapdragon, 'parse', function(str, options) {
+ var parsed = Snapdragon.prototype.parse.apply(this, arguments);
+ parsed.input = str;
+
+ // escape unmatched brace/bracket/parens
+ var last = this.parser.stack.pop();
+ if (last && this.options.strictErrors !== true) {
+ var open = last.nodes[0];
+ var inner = last.nodes[1];
+ if (last.type === 'bracket') {
+ if (inner.val.charAt(0) === '[') {
+ inner.val = '\\' + inner.val;
+ }
+
+ } else {
+ open.val = '\\' + open.val;
+ var sibling = open.parent.nodes[1];
+ if (sibling.type === 'star') {
+ sibling.loose = true;
+ }
+ }
+ }
+
+ // add non-enumerable parser reference
+ utils.define(parsed, 'parser', this.parser);
+ return parsed;
+ });
+
+ return snapdragon;
+};
+
+/**
+ * Create the key to use for memoization. The key is generated
+ * by iterating over the options and concatenating key-value pairs
+ * to the pattern string.
+ */
+
+utils.createKey = function(pattern, options) {
+ if (utils.typeOf(options) !== 'object') {
+ return pattern;
+ }
+ var val = pattern;
+ var keys = Object.keys(options);
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ val += ';' + key + '=' + String(options[key]);
+ }
+ return val;
+};
+
+/**
+ * Cast `val` to an array
+ * @return {Array}
+ */
+
+utils.arrayify = function(val) {
+ if (typeof val === 'string') return [val];
+ return val ? (Array.isArray(val) ? val : [val]) : [];
+};
+
+/**
+ * Return true if `val` is a non-empty string
+ */
+
+utils.isString = function(val) {
+ return typeof val === 'string';
+};
+
+/**
+ * Return true if `val` is a non-empty string
+ */
+
+utils.isObject = function(val) {
+ return utils.typeOf(val) === 'object';
+};
+
+/**
+ * Returns true if the given `str` has special characters
+ */
+
+utils.hasSpecialChars = function(str) {
+ return /(?:(?:(^|\/)[!.])|[*?+()|\[\]{}]|[+@]\()/.test(str);
+};
+
+/**
+ * Escape regex characters in the given string
+ */
+
+utils.escapeRegex = function(str) {
+ return str.replace(/[-[\]{}()^$|*+?.\\\/\s]/g, '\\$&');
+};
+
+/**
+ * Normalize slashes in the given filepath.
+ *
+ * @param {String} `filepath`
+ * @return {String}
+ */
+
+utils.toPosixPath = function(str) {
+ return str.replace(/\\+/g, '/');
+};
+
+/**
+ * Strip backslashes before special characters in a string.
+ *
+ * @param {String} `str`
+ * @return {String}
+ */
+
+utils.unescape = function(str) {
+ return utils.toPosixPath(str.replace(/\\(?=[*+?!.])/g, ''));
+};
+
+/**
+ * Strip the prefix from a filepath
+ * @param {String} `fp`
+ * @return {String}
+ */
+
+utils.stripPrefix = function(str) {
+ if (str.charAt(0) !== '.') {
+ return str;
+ }
+ var ch = str.charAt(1);
+ if (utils.isSlash(ch)) {
+ return str.slice(2);
+ }
+ return str;
+};
+
+/**
+ * Returns true if the given str is an escaped or
+ * unescaped path character
+ */
+
+utils.isSlash = function(str) {
+ return str === '/' || str === '\\/' || str === '\\' || str === '\\\\';
+};
+
+/**
+ * Returns a function that returns true if the given
+ * pattern matches or contains a `filepath`
+ *
+ * @param {String} `pattern`
+ * @return {Function}
+ */
+
+utils.matchPath = function(pattern, options) {
+ return (options && options.contains)
+ ? utils.containsPattern(pattern, options)
+ : utils.equalsPattern(pattern, options);
+};
+
+/**
+ * Returns true if the given (original) filepath or unixified path are equal
+ * to the given pattern.
+ */
+
+utils._equals = function(filepath, unixPath, pattern) {
+ return pattern === filepath || pattern === unixPath;
+};
+
+/**
+ * Returns true if the given (original) filepath or unixified path contain
+ * the given pattern.
+ */
+
+utils._contains = function(filepath, unixPath, pattern) {
+ return filepath.indexOf(pattern) !== -1 || unixPath.indexOf(pattern) !== -1;
+};
+
+/**
+ * Returns a function that returns true if the given
+ * pattern is the same as a given `filepath`
+ *
+ * @param {String} `pattern`
+ * @return {Function}
+ */
+
+utils.equalsPattern = function(pattern, options) {
+ var unixify = utils.unixify(options);
+ options = options || {};
+
+ return function fn(filepath) {
+ var equal = utils._equals(filepath, unixify(filepath), pattern);
+ if (equal === true || options.nocase !== true) {
+ return equal;
+ }
+ var lower = filepath.toLowerCase();
+ return utils._equals(lower, unixify(lower), pattern);
+ };
+};
+
+/**
+ * Returns a function that returns true if the given
+ * pattern contains a `filepath`
+ *
+ * @param {String} `pattern`
+ * @return {Function}
+ */
+
+utils.containsPattern = function(pattern, options) {
+ var unixify = utils.unixify(options);
+ options = options || {};
+
+ return function(filepath) {
+ var contains = utils._contains(filepath, unixify(filepath), pattern);
+ if (contains === true || options.nocase !== true) {
+ return contains;
+ }
+ var lower = filepath.toLowerCase();
+ return utils._contains(lower, unixify(lower), pattern);
+ };
+};
+
+/**
+ * Returns a function that returns true if the given
+ * regex matches the `filename` of a file path.
+ *
+ * @param {RegExp} `re` Matching regex
+ * @return {Function}
+ */
+
+utils.matchBasename = function(re) {
+ return function(filepath) {
+ return re.test(path.basename(filepath));
+ };
+};
+
+/**
+ * Determines the filepath to return based on the provided options.
+ * @return {any}
+ */
+
+utils.value = function(str, unixify, options) {
+ if (options && options.unixify === false) {
+ return str;
+ }
+ return unixify(str);
+};
+
+/**
+ * Returns a function that normalizes slashes in a string to forward
+ * slashes, strips `./` from beginning of paths, and optionally unescapes
+ * special characters.
+ * @return {Function}
+ */
+
+utils.unixify = function(options) {
+ options = options || {};
+ return function(filepath) {
+ if (utils.isWindows() || options.unixify === true) {
+ filepath = utils.toPosixPath(filepath);
+ }
+ if (options.stripPrefix !== false) {
+ filepath = utils.stripPrefix(filepath);
+ }
+ if (options.unescape === true) {
+ filepath = utils.unescape(filepath);
+ }
+ return filepath;
+ };
+};