You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
211 lines
5.1 KiB
211 lines
5.1 KiB
'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;
|