src/vs/platform/url/common/urlGlob.ts
163 LOC · 161 covered · 2 uncovered · 35 ranges · 82 concepts · 15 introducers · 64 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
>
/*---------------------------------------------------------------------------------------------
urlGlob.ts ×4
2
>
* Copyright (c) Microsoft Corporation. All rights reserved.
3
>
* Licensed under the MIT License. See License.txt in the project root for license information.
4
>
*--------------------------------------------------------------------------------------------*/
5
>
6
>
import { URI } from '../../../base/common/uri.js';
7
>
8
>
/**
9
>
* Normalizes a URL by removing trailing slashes and query/fragment components.
10
>
* @param url The URL to normalize.
11
>
* @returns URI - The normalized URI object.
12
>
*/
14
>
const uri = typeof url === 'string' ? URI.parse(url) : url;
15
>
return uri.with({
16
>
// Remove trailing slashes
17
>
path: uri.path.replace(/\/+$/, ''),
18
>
// Remove query and fragment
19
>
query: null,
20
>
fragment: null,
21
>
});
22
>
}
24
>
/**
25
>
* Checks if a given URL matches a glob URL pattern.
26
>
* The glob URL pattern can contain wildcards (*) and subdomain matching (*.)
27
>
* @param uri The URL to check.
28
>
* @param globUrl The glob URL pattern to match against.
29
>
* @returns boolean - True if the URL matches the glob URL pattern, false otherwise.
30
>
*/
31
>
export function testUrlMatchesGlob(uri: string | URI, globUrl: string): boolean {
33
>
let normalizedGlobUrl: URI;
34
>
35
>
const globHasScheme = /^[^./:]*:\/\//.test(globUrl);
36
>
// if the glob does not have a scheme we assume the scheme is http or https
37
>
// so if the url doesn't have a scheme of http or https we return false
38
>
if (!globHasScheme) {
41
>
}
45
>
}
47
>
return (
48
>
doMemoUrlMatch(normalizedUrl.scheme, normalizedGlobUrl.scheme) &&
50
>
doMemoUrlMatch(normalizedUrl.authority, normalizedGlobUrl.authority, true) &&
52
>
//
53
>
normalizedGlobUrl.path === '/' ||
56
>
);
57
>
}
59
>
/**
60
>
* @param normalizedUrlPart The normalized URL part to match.
61
>
* @param normalizedGlobUrlPart The normalized glob URL part to match against.
62
>
* @param includePortLogic Whether to include port logic in the matching process.
63
>
* @returns boolean - True if the URL part matches the glob URL part, false otherwise.
64
>
*/
66
>
normalizedUrlPart: string,
67
>
normalizedGlobUrlPart: string,
68
>
includePortLogic: boolean = false,
69
>
) {
70
>
const memo = Array.from({ length: normalizedUrlPart.length + 1 }).map(() =>
71
>
Array.from({ length: normalizedGlobUrlPart.length + 1 }).map(() => undefined),
72
>
);
73
>
74
>
return doUrlPartMatch(memo, includePortLogic, normalizedUrlPart, normalizedGlobUrlPart, 0, 0);
75
>
}
77
>
/**
78
>
* Recursively checks if a URL part matches a glob URL part.
79
>
* This function uses memoization to avoid recomputing results for the same inputs.
80
>
* It handles various cases such as exact matches, wildcard matches, and port logic.
81
>
* @param memo A memoization table to avoid recomputing results for the same inputs.
82
>
* @param includePortLogic Whether to include port logic in the matching process.
83
>
* @param urlPart The URL part to match with.
84
>
* @param globUrlPart The glob URL part to match against.
85
>
* @param urlOffset The current offset in the URL part.
86
>
* @param globUrlOffset The current offset in the glob URL part.
87
>
* @returns boolean - True if the URL part matches the glob URL part, false otherwise.
88
>
*/
90
>
memo: (boolean | undefined)[][],
91
>
includePortLogic: boolean,
92
>
urlPart: string,
93
>
globUrlPart: string,
94
>
urlOffset: number,
95
>
globUrlOffset: number
96
>
): boolean {
97
>
if (memo[urlOffset]?.[globUrlOffset] !== undefined) {
99
>
}
101
>
const options = [];
102
>
103
>
// We've reached the end of the url.
104
>
if (urlOffset === urlPart.length) {
105
>
// We're also at the end of the glob url as well so we have an exact match.
106
>
if (globUrlOffset === globUrlPart.length) {
108
>
}
110
>
if (includePortLogic && globUrlPart[globUrlOffset] + globUrlPart[globUrlOffset + 1] === ':*') {
urlGlob.ts ×14
111
>
// any port match. Consume a port if it exists otherwise nothing. Always consume the base.
urlGlob.ts ×1
112
>
return globUrlOffset + 2 === globUrlPart.length;
113
>
}
115
>
return false;
116
>
}
118
>
// Some path remaining in url
119
>
if (globUrlOffset === globUrlPart.length) {
121
>
return remaining[0] === '/';
122
>
}
124
>
if (urlPart[urlOffset] === globUrlPart[globUrlOffset]) {
125
>
// Exact match.
126
>
options.push(doUrlPartMatch(memo, includePortLogic, urlPart, globUrlPart, urlOffset + 1, globUrlOffset + 1));
127
>
}
128
>
129
>
if (globUrlPart[globUrlOffset] + globUrlPart[globUrlOffset + 1] === '*.') {
130
>
// Any subdomain match. Either consume one thing that's not a / or : and don't advance base or consume nothing and do.
urlGlob.ts ×2
131
>
if (!['/', ':'].includes(urlPart[urlOffset])) {
132
>
options.push(doUrlPartMatch(memo, includePortLogic, urlPart, globUrlPart, urlOffset + 1, globUrlOffset));
133
>
}
134
>
// Only skip *. if we're at the start (bare domain) or at a dot boundary
135
>
if (urlOffset === 0 || urlPart[urlOffset - 1] === '.') {
136
>
options.push(doUrlPartMatch(memo, includePortLogic, urlPart, globUrlPart, urlOffset, globUrlOffset + 2));
137
>
}
138
>
}
140
>
if (globUrlPart[globUrlOffset] === '*') {
141
>
// Any match. Either consume one thing and don't advance base or consume nothing and do.
urlGlob.ts ×1
142
>
if (urlOffset + 1 === urlPart.length) {
143
>
// If we're at the end of the input url consume one from both.
144
>
options.push(doUrlPartMatch(memo, includePortLogic, urlPart, globUrlPart, urlOffset + 1, globUrlOffset + 1));
145
>
} else {
146
>
options.push(doUrlPartMatch(memo, includePortLogic, urlPart, globUrlPart, urlOffset + 1, globUrlOffset));
147
>
}
148
>
options.push(doUrlPartMatch(memo, includePortLogic, urlPart, globUrlPart, urlOffset, globUrlOffset + 1));
149
>
}
151
>
if (includePortLogic && globUrlPart[globUrlOffset] + globUrlPart[globUrlOffset + 1] === ':*') {
152
>
// any port match. Consume a port if it exists otherwise nothing. Always consume the base.
urlGlob.ts ×2
153
>
if (urlPart[urlOffset] === ':') {
154
>
let endPortIndex = urlOffset + 1;
155
>
do { endPortIndex++; } while (/[0-9]/.test(urlPart[endPortIndex]));
156
>
options.push(doUrlPartMatch(memo, includePortLogic, urlPart, globUrlPart, endPortIndex, globUrlOffset + 2));
157
>
} else {
158
options.push(doUrlPartMatch(memo, includePortLogic, urlPart, globUrlPart, urlOffset, globUrlOffset + 2));
159
}
162
>
return (memo[urlOffset][globUrlOffset] = options.some(a => a === true));
163
>
}