blob: ee70908ad65a944a8f54f54cb2c3e5fa62a7c34d (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var path = require("path");
var globParent = require("glob-parent");
var isGlob = require("is-glob");
var micromatch = require("micromatch");
var GLOBSTAR = '**';
/**
* Return true for static pattern.
*/
function isStaticPattern(pattern) {
return !isDynamicPattern(pattern);
}
exports.isStaticPattern = isStaticPattern;
/**
* Return true for pattern that looks like glob.
*/
function isDynamicPattern(pattern) {
return isGlob(pattern);
}
exports.isDynamicPattern = isDynamicPattern;
/**
* Convert a windows «path» to a unix-style «path».
*/
function unixifyPattern(pattern) {
return pattern.replace(/\\/g, '/');
}
exports.unixifyPattern = unixifyPattern;
/**
* Returns negative pattern as positive pattern.
*/
function convertToPositivePattern(pattern) {
return isNegativePattern(pattern) ? pattern.slice(1) : pattern;
}
exports.convertToPositivePattern = convertToPositivePattern;
/**
* Returns positive pattern as negative pattern.
*/
function convertToNegativePattern(pattern) {
return '!' + pattern;
}
exports.convertToNegativePattern = convertToNegativePattern;
/**
* Return true if provided pattern is negative pattern.
*/
function isNegativePattern(pattern) {
return pattern.startsWith('!') && pattern[1] !== '(';
}
exports.isNegativePattern = isNegativePattern;
/**
* Return true if provided pattern is positive pattern.
*/
function isPositivePattern(pattern) {
return !isNegativePattern(pattern);
}
exports.isPositivePattern = isPositivePattern;
/**
* Extracts negative patterns from array of patterns.
*/
function getNegativePatterns(patterns) {
return patterns.filter(isNegativePattern);
}
exports.getNegativePatterns = getNegativePatterns;
/**
* Extracts positive patterns from array of patterns.
*/
function getPositivePatterns(patterns) {
return patterns.filter(isPositivePattern);
}
exports.getPositivePatterns = getPositivePatterns;
/**
* Extract base directory from provided pattern.
*/
function getBaseDirectory(pattern) {
return globParent(pattern);
}
exports.getBaseDirectory = getBaseDirectory;
/**
* Return true if provided pattern has globstar.
*/
function hasGlobStar(pattern) {
return pattern.indexOf(GLOBSTAR) !== -1;
}
exports.hasGlobStar = hasGlobStar;
/**
* Return true if provided pattern ends with slash and globstar.
*/
function endsWithSlashGlobStar(pattern) {
return pattern.endsWith('/' + GLOBSTAR);
}
exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
/**
* Returns «true» when pattern ends with a slash and globstar or the last partial of the pattern is static pattern.
*/
function isAffectDepthOfReadingPattern(pattern) {
var basename = path.basename(pattern);
return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
}
exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
/**
* Return naive depth of provided pattern without depth of the base directory.
*/
function getNaiveDepth(pattern) {
var base = getBaseDirectory(pattern);
var patternDepth = pattern.split('/').length;
var patternBaseDepth = base.split('/').length;
/**
* This is a hack for pattern that has no base directory.
*
* This is related to the `*\something\*` pattern.
*/
if (base === '.') {
return patternDepth - patternBaseDepth;
}
return patternDepth - patternBaseDepth - 1;
}
exports.getNaiveDepth = getNaiveDepth;
/**
* Return max naive depth of provided patterns without depth of the base directory.
*/
function getMaxNaivePatternsDepth(patterns) {
return patterns.reduce(function (max, pattern) {
var depth = getNaiveDepth(pattern);
return depth > max ? depth : max;
}, 0);
}
exports.getMaxNaivePatternsDepth = getMaxNaivePatternsDepth;
/**
* Make RegExp for provided pattern.
*/
function makeRe(pattern, options) {
return micromatch.makeRe(pattern, options);
}
exports.makeRe = makeRe;
/**
* Convert patterns to regexps.
*/
function convertPatternsToRe(patterns, options) {
return patterns.map(function (pattern) { return makeRe(pattern, options); });
}
exports.convertPatternsToRe = convertPatternsToRe;
/**
* Returns true if the entry match any of the given RegExp's.
*/
function matchAny(entry, patternsRe) {
return patternsRe.some(function (patternRe) { return patternRe.test(entry); });
}
exports.matchAny = matchAny;
|
