microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-05-17 11:24:29 -05:00
Code Issues Packages Projects Releases 212 Wiki Activity

Respond to PR comment

Browse Source
This commit is contained in:
Andy Hanson
2017-01-09 06:55:42 -08:00
parent 589db585b0
commit 54d64ceb98
1 changed files with 34 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
src/compiler/core.ts
View File

@@ -164,6 +164,16 @@ namespace ts {
return undefined;
}
/** Works like Array.prototype.findIndex, returning `-1` if no element satisfying the predicate is found. */
export function findIndex<T>(array: T[], predicate: (element: T, index: number) => boolean): number {
for (let i = 0; i < array.length; i++) {
if (predicate(array[i], i)) {
return i;
}
}
return -1;
}
/**
* Returns the first truthy result of `callback`, or else fails.
* This is like `forEach`, but never returns undefined.
@@ -1810,68 +1820,43 @@ namespace ts {
// If there are no "includes", then just put everything in results[0].
const results: string[][] = includeFileRegexes ? includeFileRegexes.map(() => []) : [[]];
const comparer = useCaseSensitiveFileNames ? compareStrings : compareStringsCaseInsensitive;
for (const basePath of patterns.basePaths) {
forEachFileInRecursiveDirectories(basePath, combinePaths(currentDirectory, basePath), { useCaseSensitiveFileNames, getFileSystemEntries, includeDirectory, visitFile });
visitDirectory(basePath, combinePaths(currentDirectory, basePath));
}
return flatten(results);
function includeDirectory(absoluteDirectoryName: string): boolean {
return (!includeDirectoryRegex || includeDirectoryRegex.test(absoluteDirectoryName)) &&
(!excludeRegex || !excludeRegex.test(absoluteDirectoryName));
}
function visitDirectory(path: string, absolutePath: string) {
let { files, directories } = getFileSystemEntries(path);
files = files.slice().sort(comparer);
directories = directories.slice().sort(comparer);
function visitFile(fileName: string, absoluteFileName: string): void {
if (extensions && !fileExtensionIsAny(fileName, extensions) ||
excludeRegex && excludeRegex.test(absoluteFileName)) {
return;
}
if (!includeFileRegexes) {
results[0].push(fileName);
}
else {
for (let i = 0; i < includeFileRegexes.length; i++) {
if (includeFileRegexes[i].test(absoluteFileName)) {
results[i].push(fileName);
// Only include a file once.
break;
for (const current of files) {
const name = combinePaths(path, current);
const absoluteName = combinePaths(absolutePath, current);
if (extensions && !fileExtensionIsAny(name, extensions)) continue;
if (excludeRegex && excludeRegex.test(absoluteName)) continue;
if (!includeFileRegexes) {
results[0].push(name);
}
else {
const includeIndex = findIndex(includeFileRegexes, re => re.test(absoluteName));
if (includeIndex !== -1) {
results[includeIndex].push(name);
}
}
}
}
}
interface RecursiveDirectoryVisitor {
useCaseSensitiveFileNames: boolean;
getFileSystemEntries: (path: string) => FileSystemEntries;
includeDirectory: (absoluteDirectoryName: string) => boolean;
visitFile: (fileName: string, absoluteFileName: string) => void;
}
function forEachFileInRecursiveDirectories(start: string, absoluteStart: string, visitor: RecursiveDirectoryVisitor): void {
visitDirectory(start, absoluteStart);
function visitDirectory(path: string, absolutePath: string) {
let { files, directories } = visitor.getFileSystemEntries(path);
files = sorted(files);
directories = sorted(directories);
for (const file of files) {
visitor.visitFile(combinePaths(path, file), combinePaths(absolutePath, file));
}
for (const dir of directories) {
const absoluteName = combinePaths(absolutePath, dir);
if (visitor.includeDirectory(absoluteName)) {
visitDirectory(combinePaths(path, dir), absoluteName);
for (const current of directories) {
const name = combinePaths(path, current);
const absoluteName = combinePaths(absolutePath, current);
if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
(!excludeRegex || !excludeRegex.test(absoluteName))) {
visitDirectory(name, absoluteName);
}
}
}
function sorted(names: string[]): string[] {
return names.slice().sort(visitor.useCaseSensitiveFileNames ? compareStrings : compareStringsCaseInsensitive);
}
}
/**