aboutsummaryrefslogtreecommitdiff
path: root/node_modules/expand-brackets/index.js
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/expand-brackets/index.js')
-rw-r--r--node_modules/expand-brackets/index.js211
1 files changed, 211 insertions, 0 deletions
diff --git a/node_modules/expand-brackets/index.js b/node_modules/expand-brackets/index.js
new file mode 100644
index 0000000..74b8b15
--- /dev/null
+++ b/node_modules/expand-brackets/index.js
@@ -0,0 +1,211 @@
+'use strict';
+
+/**
+ * Local dependencies
+ */
+
+var compilers = require('./lib/compilers');
+var parsers = require('./lib/parsers');
+
+/**
+ * Module dependencies
+ */
+
+var debug = require('debug')('expand-brackets');
+var extend = require('extend-shallow');
+var Snapdragon = require('snapdragon');
+var toRegex = require('to-regex');
+
+/**
+ * Parses the given POSIX character class `pattern` and returns a
+ * string that can be used for creating regular expressions for matching.
+ *
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Object}
+ * @api public
+ */
+
+function brackets(pattern, options) {
+ debug('initializing from <%s>', __filename);
+ var res = brackets.create(pattern, options);
+ return res.output;
+}
+
+/**
+ * Takes an array of strings and a POSIX character class pattern, and returns a new
+ * array with only the strings that matched the pattern.
+ *
+ * ```js
+ * var brackets = require('expand-brackets');
+ * console.log(brackets.match(['1', 'a', 'ab'], '[[:alpha:]]'));
+ * //=> ['a']
+ *
+ * console.log(brackets.match(['1', 'a', 'ab'], '[[:alpha:]]+'));
+ * //=> ['a', 'ab']
+ * ```
+ * @param {Array} `arr` Array of strings to match
+ * @param {String} `pattern` POSIX character class pattern(s)
+ * @param {Object} `options`
+ * @return {Array}
+ * @api public
+ */
+
+brackets.match = function(arr, pattern, options) {
+ arr = [].concat(arr);
+ var opts = extend({}, options);
+ var isMatch = brackets.matcher(pattern, opts);
+ var len = arr.length;
+ var idx = -1;
+ var res = [];
+
+ while (++idx < len) {
+ var ele = arr[idx];
+ if (isMatch(ele)) {
+ res.push(ele);
+ }
+ }
+
+ if (res.length === 0) {
+ if (opts.failglob === true) {
+ throw new Error('no matches found for "' + pattern + '"');
+ }
+
+ if (opts.nonull === true || opts.nullglob === true) {
+ return [pattern.split('\\').join('')];
+ }
+ }
+ return res;
+};
+
+/**
+ * Returns true if the specified `string` matches the given
+ * brackets `pattern`.
+ *
+ * ```js
+ * var brackets = require('expand-brackets');
+ *
+ * console.log(brackets.isMatch('a.a', '[[:alpha:]].[[:alpha:]]'));
+ * //=> true
+ * console.log(brackets.isMatch('1.2', '[[:alpha:]].[[:alpha:]]'));
+ * //=> false
+ * ```
+ * @param {String} `string` String to match
+ * @param {String} `pattern` Poxis pattern
+ * @param {String} `options`
+ * @return {Boolean}
+ * @api public
+ */
+
+brackets.isMatch = function(str, pattern, options) {
+ return brackets.matcher(pattern, options)(str);
+};
+
+/**
+ * Takes a POSIX character class pattern and returns a matcher function. The returned
+ * function takes the string to match as its only argument.
+ *
+ * ```js
+ * var brackets = require('expand-brackets');
+ * var isMatch = brackets.matcher('[[:lower:]].[[:upper:]]');
+ *
+ * console.log(isMatch('a.a'));
+ * //=> false
+ * console.log(isMatch('a.A'));
+ * //=> true
+ * ```
+ * @param {String} `pattern` Poxis pattern
+ * @param {String} `options`
+ * @return {Boolean}
+ * @api public
+ */
+
+brackets.matcher = function(pattern, options) {
+ var re = brackets.makeRe(pattern, options);
+ return function(str) {
+ return re.test(str);
+ };
+};
+
+/**
+ * Create a regular expression from the given `pattern`.
+ *
+ * ```js
+ * var brackets = require('expand-brackets');
+ * var re = brackets.makeRe('[[:alpha:]]');
+ * console.log(re);
+ * //=> /^(?:[a-zA-Z])$/
+ * ```
+ * @param {String} `pattern` The pattern to convert to regex.
+ * @param {Object} `options`
+ * @return {RegExp}
+ * @api public
+ */
+
+brackets.makeRe = function(pattern, options) {
+ var res = brackets.create(pattern, options);
+ var opts = extend({strictErrors: false}, options);
+ return toRegex(res.output, opts);
+};
+
+/**
+ * Parses the given POSIX character class `pattern` and returns an object
+ * with the compiled `output` and optional source `map`.
+ *
+ * ```js
+ * var brackets = require('expand-brackets');
+ * console.log(brackets('[[:alpha:]]'));
+ * // { options: { source: 'string' },
+ * // input: '[[:alpha:]]',
+ * // state: {},
+ * // compilers:
+ * // { eos: [Function],
+ * // noop: [Function],
+ * // bos: [Function],
+ * // not: [Function],
+ * // escape: [Function],
+ * // text: [Function],
+ * // posix: [Function],
+ * // bracket: [Function],
+ * // 'bracket.open': [Function],
+ * // 'bracket.inner': [Function],
+ * // 'bracket.literal': [Function],
+ * // 'bracket.close': [Function] },
+ * // output: '[a-zA-Z]',
+ * // ast:
+ * // { type: 'root',
+ * // errors: [],
+ * // nodes: [ [Object], [Object], [Object] ] },
+ * // parsingErrors: [] }
+ * ```
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Object}
+ * @api public
+ */
+
+brackets.create = function(pattern, options) {
+ var snapdragon = (options && options.snapdragon) || new Snapdragon(options);
+ compilers(snapdragon);
+ parsers(snapdragon);
+
+ var ast = snapdragon.parse(pattern, options);
+ ast.input = pattern;
+ var res = snapdragon.compile(ast, options);
+ res.input = pattern;
+ return res;
+};
+
+/**
+ * Expose `brackets` constructor, parsers and compilers
+ */
+
+brackets.compilers = compilers;
+brackets.parsers = parsers;
+
+/**
+ * Expose `brackets`
+ * @type {Function}
+ */
+
+module.exports = brackets;