| '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; |