123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499 |
- /*---------------------------------------------------------------------------------------------
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
- import { isThenable } from './async.js';
- import * as extpath from './extpath.js';
- import { LRUCache } from './map.js';
- import * as paths from './path.js';
- import * as strings from './strings.js';
- const GLOBSTAR = '**';
- const GLOB_SPLIT = '/';
- const PATH_REGEX = '[/\\\\]'; // any slash or backslash
- const NO_PATH_REGEX = '[^/\\\\]'; // any non-slash and non-backslash
- const ALL_FORWARD_SLASHES = /\//g;
- function starsToRegExp(starCount) {
- switch (starCount) {
- case 0:
- return '';
- case 1:
- return `${NO_PATH_REGEX}*?`; // 1 star matches any number of characters except path separator (/ and \) - non greedy (?)
- default:
- // Matches: (Path Sep OR Path Val followed by Path Sep OR Path Sep followed by Path Val) 0-many times
- // Group is non capturing because we don't need to capture at all (?:...)
- // Overall we use non-greedy matching because it could be that we match too much
- return `(?:${PATH_REGEX}|${NO_PATH_REGEX}+${PATH_REGEX}|${PATH_REGEX}${NO_PATH_REGEX}+)*?`;
- }
- }
- export function splitGlobAware(pattern, splitChar) {
- if (!pattern) {
- return [];
- }
- const segments = [];
- let inBraces = false;
- let inBrackets = false;
- let curVal = '';
- for (const char of pattern) {
- switch (char) {
- case splitChar:
- if (!inBraces && !inBrackets) {
- segments.push(curVal);
- curVal = '';
- continue;
- }
- break;
- case '{':
- inBraces = true;
- break;
- case '}':
- inBraces = false;
- break;
- case '[':
- inBrackets = true;
- break;
- case ']':
- inBrackets = false;
- break;
- }
- curVal += char;
- }
- // Tail
- if (curVal) {
- segments.push(curVal);
- }
- return segments;
- }
- function parseRegExp(pattern) {
- if (!pattern) {
- return '';
- }
- let regEx = '';
- // Split up into segments for each slash found
- const segments = splitGlobAware(pattern, GLOB_SPLIT);
- // Special case where we only have globstars
- if (segments.every(s => s === GLOBSTAR)) {
- regEx = '.*';
- }
- // Build regex over segments
- else {
- let previousSegmentWasGlobStar = false;
- segments.forEach((segment, index) => {
- // Globstar is special
- if (segment === GLOBSTAR) {
- // if we have more than one globstar after another, just ignore it
- if (!previousSegmentWasGlobStar) {
- regEx += starsToRegExp(2);
- previousSegmentWasGlobStar = true;
- }
- return;
- }
- // States
- let inBraces = false;
- let braceVal = '';
- let inBrackets = false;
- let bracketVal = '';
- for (const char of segment) {
- // Support brace expansion
- if (char !== '}' && inBraces) {
- braceVal += char;
- continue;
- }
- // Support brackets
- if (inBrackets && (char !== ']' || !bracketVal) /* ] is literally only allowed as first character in brackets to match it */) {
- let res;
- // range operator
- if (char === '-') {
- res = char;
- }
- // negation operator (only valid on first index in bracket)
- else if ((char === '^' || char === '!') && !bracketVal) {
- res = '^';
- }
- // glob split matching is not allowed within character ranges
- // see http://man7.org/linux/man-pages/man7/glob.7.html
- else if (char === GLOB_SPLIT) {
- res = '';
- }
- // anything else gets escaped
- else {
- res = strings.escapeRegExpCharacters(char);
- }
- bracketVal += res;
- continue;
- }
- switch (char) {
- case '{':
- inBraces = true;
- continue;
- case '[':
- inBrackets = true;
- continue;
- case '}':
- const choices = splitGlobAware(braceVal, ',');
- // Converts {foo,bar} => [foo|bar]
- const braceRegExp = `(?:${choices.map(c => parseRegExp(c)).join('|')})`;
- regEx += braceRegExp;
- inBraces = false;
- braceVal = '';
- break;
- case ']':
- regEx += ('[' + bracketVal + ']');
- inBrackets = false;
- bracketVal = '';
- break;
- case '?':
- regEx += NO_PATH_REGEX; // 1 ? matches any single character except path separator (/ and \)
- continue;
- case '*':
- regEx += starsToRegExp(1);
- continue;
- default:
- regEx += strings.escapeRegExpCharacters(char);
- }
- }
- // Tail: Add the slash we had split on if there is more to come and the remaining pattern is not a globstar
- // For example if pattern: some/**/*.js we want the "/" after some to be included in the RegEx to prevent
- // a folder called "something" to match as well.
- // However, if pattern: some/**, we tolerate that we also match on "something" because our globstar behaviour
- // is to match 0-N segments.
- if (index < segments.length - 1 && (segments[index + 1] !== GLOBSTAR || index + 2 < segments.length)) {
- regEx += PATH_REGEX;
- }
- // reset state
- previousSegmentWasGlobStar = false;
- });
- }
- return regEx;
- }
- // regexes to check for trivial glob patterns that just check for String#endsWith
- const T1 = /^\*\*\/\*\.[\w\.-]+$/; // **/*.something
- const T2 = /^\*\*\/([\w\.-]+)\/?$/; // **/something
- const T3 = /^{\*\*\/[\*\.]?[\w\.-]+\/?(,\*\*\/[\*\.]?[\w\.-]+\/?)*}$/; // {**/*.something,**/*.else} or {**/package.json,**/project.json}
- const T3_2 = /^{\*\*\/[\*\.]?[\w\.-]+(\/(\*\*)?)?(,\*\*\/[\*\.]?[\w\.-]+(\/(\*\*)?)?)*}$/; // Like T3, with optional trailing /**
- const T4 = /^\*\*((\/[\w\.-]+)+)\/?$/; // **/something/else
- const T5 = /^([\w\.-]+(\/[\w\.-]+)*)\/?$/; // something/else
- const CACHE = new LRUCache(10000); // bounded to 10000 elements
- const FALSE = function () {
- return false;
- };
- const NULL = function () {
- return null;
- };
- function parsePattern(arg1, options) {
- if (!arg1) {
- return NULL;
- }
- // Handle IRelativePattern
- let pattern;
- if (typeof arg1 !== 'string') {
- pattern = arg1.pattern;
- }
- else {
- pattern = arg1;
- }
- // Whitespace trimming
- pattern = pattern.trim();
- // Check cache
- const patternKey = `${pattern}_${!!options.trimForExclusions}`;
- let parsedPattern = CACHE.get(patternKey);
- if (parsedPattern) {
- return wrapRelativePattern(parsedPattern, arg1);
- }
- // Check for Trivials
- let match;
- if (T1.test(pattern)) { // common pattern: **/*.txt just need endsWith check
- const base = pattern.substr(4); // '**/*'.length === 4
- parsedPattern = function (path, basename) {
- return typeof path === 'string' && path.endsWith(base) ? pattern : null;
- };
- }
- else if (match = T2.exec(trimForExclusions(pattern, options))) { // common pattern: **/some.txt just need basename check
- parsedPattern = trivia2(match[1], pattern);
- }
- else if ((options.trimForExclusions ? T3_2 : T3).test(pattern)) { // repetition of common patterns (see above) {**/*.txt,**/*.png}
- parsedPattern = trivia3(pattern, options);
- }
- else if (match = T4.exec(trimForExclusions(pattern, options))) { // common pattern: **/something/else just need endsWith check
- parsedPattern = trivia4and5(match[1].substr(1), pattern, true);
- }
- else if (match = T5.exec(trimForExclusions(pattern, options))) { // common pattern: something/else just need equals check
- parsedPattern = trivia4and5(match[1], pattern, false);
- }
- // Otherwise convert to pattern
- else {
- parsedPattern = toRegExp(pattern);
- }
- // Cache
- CACHE.set(patternKey, parsedPattern);
- return wrapRelativePattern(parsedPattern, arg1);
- }
- function wrapRelativePattern(parsedPattern, arg2) {
- if (typeof arg2 === 'string') {
- return parsedPattern;
- }
- return function (path, basename) {
- if (!extpath.isEqualOrParent(path, arg2.base)) {
- return null;
- }
- return parsedPattern(paths.relative(arg2.base, path), basename);
- };
- }
- function trimForExclusions(pattern, options) {
- return options.trimForExclusions && pattern.endsWith('/**') ? pattern.substr(0, pattern.length - 2) : pattern; // dropping **, tailing / is dropped later
- }
- // common pattern: **/some.txt just need basename check
- function trivia2(base, originalPattern) {
- const slashBase = `/${base}`;
- const backslashBase = `\\${base}`;
- const parsedPattern = function (path, basename) {
- if (typeof path !== 'string') {
- return null;
- }
- if (basename) {
- return basename === base ? originalPattern : null;
- }
- return path === base || path.endsWith(slashBase) || path.endsWith(backslashBase) ? originalPattern : null;
- };
- const basenames = [base];
- parsedPattern.basenames = basenames;
- parsedPattern.patterns = [originalPattern];
- parsedPattern.allBasenames = basenames;
- return parsedPattern;
- }
- // repetition of common patterns (see above) {**/*.txt,**/*.png}
- function trivia3(pattern, options) {
- const parsedPatterns = aggregateBasenameMatches(pattern.slice(1, -1).split(',')
- .map(pattern => parsePattern(pattern, options))
- .filter(pattern => pattern !== NULL), pattern);
- const n = parsedPatterns.length;
- if (!n) {
- return NULL;
- }
- if (n === 1) {
- return parsedPatterns[0];
- }
- const parsedPattern = function (path, basename) {
- for (let i = 0, n = parsedPatterns.length; i < n; i++) {
- if (parsedPatterns[i](path, basename)) {
- return pattern;
- }
- }
- return null;
- };
- const withBasenames = parsedPatterns.find(pattern => !!pattern.allBasenames);
- if (withBasenames) {
- parsedPattern.allBasenames = withBasenames.allBasenames;
- }
- const allPaths = parsedPatterns.reduce((all, current) => current.allPaths ? all.concat(current.allPaths) : all, []);
- if (allPaths.length) {
- parsedPattern.allPaths = allPaths;
- }
- return parsedPattern;
- }
- // common patterns: **/something/else just need endsWith check, something/else just needs and equals check
- function trivia4and5(targetPath, pattern, matchPathEnds) {
- const usingPosixSep = paths.sep === paths.posix.sep;
- const nativePath = usingPosixSep ? targetPath : targetPath.replace(ALL_FORWARD_SLASHES, paths.sep);
- const nativePathEnd = paths.sep + nativePath;
- const targetPathEnd = paths.posix.sep + targetPath;
- const parsedPattern = matchPathEnds ? function (testPath, basename) {
- return typeof testPath === 'string' &&
- ((testPath === nativePath || testPath.endsWith(nativePathEnd))
- || !usingPosixSep && (testPath === targetPath || testPath.endsWith(targetPathEnd)))
- ? pattern : null;
- } : function (testPath, basename) {
- return typeof testPath === 'string' &&
- (testPath === nativePath
- || (!usingPosixSep && testPath === targetPath))
- ? pattern : null;
- };
- parsedPattern.allPaths = [(matchPathEnds ? '*/' : './') + targetPath];
- return parsedPattern;
- }
- function toRegExp(pattern) {
- try {
- const regExp = new RegExp(`^${parseRegExp(pattern)}$`);
- return function (path) {
- regExp.lastIndex = 0; // reset RegExp to its initial state to reuse it!
- return typeof path === 'string' && regExp.test(path) ? pattern : null;
- };
- }
- catch (error) {
- return NULL;
- }
- }
- export function match(arg1, path, hasSibling) {
- if (!arg1 || typeof path !== 'string') {
- return false;
- }
- return parse(arg1)(path, undefined, hasSibling);
- }
- export function parse(arg1, options = {}) {
- if (!arg1) {
- return FALSE;
- }
- // Glob with String
- if (typeof arg1 === 'string' || isRelativePattern(arg1)) {
- const parsedPattern = parsePattern(arg1, options);
- if (parsedPattern === NULL) {
- return FALSE;
- }
- const resultPattern = function (path, basename) {
- return !!parsedPattern(path, basename);
- };
- if (parsedPattern.allBasenames) {
- resultPattern.allBasenames = parsedPattern.allBasenames;
- }
- if (parsedPattern.allPaths) {
- resultPattern.allPaths = parsedPattern.allPaths;
- }
- return resultPattern;
- }
- // Glob with Expression
- return parsedExpression(arg1, options);
- }
- export function isRelativePattern(obj) {
- const rp = obj;
- return rp && typeof rp.base === 'string' && typeof rp.pattern === 'string';
- }
- function parsedExpression(expression, options) {
- const parsedPatterns = aggregateBasenameMatches(Object.getOwnPropertyNames(expression)
- .map(pattern => parseExpressionPattern(pattern, expression[pattern], options))
- .filter(pattern => pattern !== NULL));
- const n = parsedPatterns.length;
- if (!n) {
- return NULL;
- }
- if (!parsedPatterns.some(parsedPattern => !!parsedPattern.requiresSiblings)) {
- if (n === 1) {
- return parsedPatterns[0];
- }
- const resultExpression = function (path, basename) {
- for (let i = 0, n = parsedPatterns.length; i < n; i++) {
- // Pattern matches path
- const result = parsedPatterns[i](path, basename);
- if (result) {
- return result;
- }
- }
- return null;
- };
- const withBasenames = parsedPatterns.find(pattern => !!pattern.allBasenames);
- if (withBasenames) {
- resultExpression.allBasenames = withBasenames.allBasenames;
- }
- const allPaths = parsedPatterns.reduce((all, current) => current.allPaths ? all.concat(current.allPaths) : all, []);
- if (allPaths.length) {
- resultExpression.allPaths = allPaths;
- }
- return resultExpression;
- }
- const resultExpression = function (path, basename, hasSibling) {
- let name = undefined;
- for (let i = 0, n = parsedPatterns.length; i < n; i++) {
- // Pattern matches path
- const parsedPattern = parsedPatterns[i];
- if (parsedPattern.requiresSiblings && hasSibling) {
- if (!basename) {
- basename = paths.basename(path);
- }
- if (!name) {
- name = basename.substr(0, basename.length - paths.extname(path).length);
- }
- }
- const result = parsedPattern(path, basename, name, hasSibling);
- if (result) {
- return result;
- }
- }
- return null;
- };
- const withBasenames = parsedPatterns.find(pattern => !!pattern.allBasenames);
- if (withBasenames) {
- resultExpression.allBasenames = withBasenames.allBasenames;
- }
- const allPaths = parsedPatterns.reduce((all, current) => current.allPaths ? all.concat(current.allPaths) : all, []);
- if (allPaths.length) {
- resultExpression.allPaths = allPaths;
- }
- return resultExpression;
- }
- function parseExpressionPattern(pattern, value, options) {
- if (value === false) {
- return NULL; // pattern is disabled
- }
- const parsedPattern = parsePattern(pattern, options);
- if (parsedPattern === NULL) {
- return NULL;
- }
- // Expression Pattern is <boolean>
- if (typeof value === 'boolean') {
- return parsedPattern;
- }
- // Expression Pattern is <SiblingClause>
- if (value) {
- const when = value.when;
- if (typeof when === 'string') {
- const result = (path, basename, name, hasSibling) => {
- if (!hasSibling || !parsedPattern(path, basename)) {
- return null;
- }
- const clausePattern = when.replace('$(basename)', name);
- const matched = hasSibling(clausePattern);
- return isThenable(matched) ?
- matched.then(m => m ? pattern : null) :
- matched ? pattern : null;
- };
- result.requiresSiblings = true;
- return result;
- }
- }
- // Expression is Anything
- return parsedPattern;
- }
- function aggregateBasenameMatches(parsedPatterns, result) {
- const basenamePatterns = parsedPatterns.filter(parsedPattern => !!parsedPattern.basenames);
- if (basenamePatterns.length < 2) {
- return parsedPatterns;
- }
- const basenames = basenamePatterns.reduce((all, current) => {
- const basenames = current.basenames;
- return basenames ? all.concat(basenames) : all;
- }, []);
- let patterns;
- if (result) {
- patterns = [];
- for (let i = 0, n = basenames.length; i < n; i++) {
- patterns.push(result);
- }
- }
- else {
- patterns = basenamePatterns.reduce((all, current) => {
- const patterns = current.patterns;
- return patterns ? all.concat(patterns) : all;
- }, []);
- }
- const aggregate = function (path, basename) {
- if (typeof path !== 'string') {
- return null;
- }
- if (!basename) {
- let i;
- for (i = path.length; i > 0; i--) {
- const ch = path.charCodeAt(i - 1);
- if (ch === 47 /* Slash */ || ch === 92 /* Backslash */) {
- break;
- }
- }
- basename = path.substr(i);
- }
- const index = basenames.indexOf(basename);
- return index !== -1 ? patterns[index] : null;
- };
- aggregate.basenames = basenames;
- aggregate.patterns = patterns;
- aggregate.allBasenames = basenames;
- const aggregatedPatterns = parsedPatterns.filter(parsedPattern => !parsedPattern.basenames);
- aggregatedPatterns.push(aggregate);
- return aggregatedPatterns;
- }
|