Implement expandGlob()

format.ts

@@ -14,9 +14,9 @@ async function main(opts): Promise<void> {
  "--ignore",
  "node_modules",
  "--ignore",
- "testdata",
+ "**/testdata",
  "--ignore",
- "vendor",
+ "**/vendor",
  "--write"
  ];
 

fs/README.md

@@ -160,7 +160,7 @@ Iterate all files in a directory recursively.
 ```ts
 import { walk, walkSync } from "https://deno.land/std/fs/mod.ts";
 
-for (const fileInfo of walkSync()) {
+for (const fileInfo of walkSync(".")) {
  console.log(fileInfo.filename);
 }
 

fs/glob.ts

@@ -1,21 +1,17 @@
 import { globrex } from "./globrex.ts";
-import { isAbsolute, join } from "./path/mod.ts";
+import { isWindows } from "./path/constants.ts";
+import { isAbsolute, join, normalize } from "./path/mod.ts";
 import { WalkInfo, walk, walkSync } from "./walk.ts";
-const { cwd } = Deno;
+const { cwd, stat, statSync } = Deno;
+type FileInfo = Deno.FileInfo;
 
 export interface GlobOptions {
- // Allow ExtGlob features
  extended?: boolean;
- // When globstar is true, '/foo/**' is equivelant
- // to '/foo/*' when globstar is false.
- // Having globstar set to true is the same usage as
- // using wildcards in bash
  globstar?: boolean;
- // be laissez faire about mutiple slashes
  strict?: boolean;
- // Parse as filepath for extra path related features
- filepath?: boolean;
- // Flag to use in the generated RegExp
+}
+
+export interface GlobToRegExpOptions extends GlobOptions {
  flags?: string;
 }
 
@@ -27,12 +23,12 @@ export interface GlobOptions {
  *
  * Looking for all the `ts` files:
  * walkSync(".", {
- * match: [glob("*.ts")]
+ * match: [globToRegExp("*.ts")]
  * })
  *
  * Looking for all the `.json` files in any subfolder:
  * walkSync(".", {
- * match: [glob(join("a", "**", "*.json"),{
+ * match: [globToRegExp(join("a", "**", "*.json"),{
  * flags: "g",
  * extended: true,
  * globstar: true
@@ -43,12 +39,12 @@ export interface GlobOptions {
  * @param options - Specific options for the glob pattern
  * @returns A RegExp for the glob pattern
  */
-export function glob(glob: string, options: GlobOptions = {}): RegExp {
- const result = globrex(glob, options);
- if (options.filepath) {
- return result.path!.regex;
- }
- return result.regex;
+export function globToRegExp(
+ glob: string,
+ options: GlobToRegExpOptions = {}
+): RegExp {
+ const result = globrex(glob, { ...options, filepath: true });
+ return result.path!.regex;
 }
 
 /** Test whether the given string is a glob */
@@ -86,9 +82,29 @@ export function isGlob(str: string): boolean {
 
 export interface ExpandGlobOptions extends GlobOptions {
  root?: string;
+ exclude?: string[];
  includeDirs?: boolean;
 }
 
+const SEP_PATTERN = isWindows ? /[\\/]+/ : /\/+/;
+
+interface SplitPath {
+ segments: string[];
+ isAbsolute: boolean;
+ hasTrailingSep: boolean;
+}
+
+// TODO: Maybe make this public somewhere if it can be fixed for Windows.
+function split(path: string): SplitPath {
+ return {
+ segments: path
+ .replace(new RegExp(`^${SEP_PATTERN.source}|${SEP_PATTERN.source}$`), "")
+ .split(SEP_PATTERN),
+ isAbsolute: isAbsolute(path),
+ hasTrailingSep: !!path.match(new RegExp(`${SEP_PATTERN.source}$`))
+ };
+}
+
 /**
  * Expand the glob string from the specified `root` directory and yield each
  * result as a `WalkInfo` object.
@@ -100,22 +116,93 @@ export async function* expandGlob(
  globString: string,
  {
  root = cwd(),
+ exclude = [],
  includeDirs = true,
  extended = false,
  globstar = false,
- strict = false,
- filepath = true,
- flags = ""
+ strict = false
  }: ExpandGlobOptions = {}
 ): AsyncIterableIterator<WalkInfo> {
- const absoluteGlob = isAbsolute(globString)
- ? globString
- : join(root, globString);
- const globOptions = { extended, globstar, strict, filepath, flags };
- yield* walk(root, {
- match: [glob(absoluteGlob, globOptions)],
- includeDirs
- });
+ const resolveFromRoot = (path: string): string =>
+ isAbsolute(path) ? normalize(path) : join(root, path);
+ const globOptions: GlobOptions = { extended, globstar, strict };
+ const excludePatterns = exclude
+ .map(resolveFromRoot)
+ .map((s: string): RegExp => globToRegExp(s, globOptions));
+ const shouldInclude = ({ filename }: WalkInfo): boolean =>
+ !excludePatterns.some((p: RegExp): boolean => !!filename.match(p));
+ const { segments, hasTrailingSep } = split(resolveFromRoot(globString));
+
+ let fixedRoot = isWindows ? segments.shift()! : "/";
+ while (segments.length > 0 && !isGlob(segments[0])) {
+ fixedRoot = join(fixedRoot, segments.shift()!);
+ }
+
+ let fixedRootInfo: WalkInfo;
+ try {
+ fixedRootInfo = { filename: fixedRoot, info: await stat(fixedRoot) };
+ } catch {
+ return;
+ }
+
+ async function* advanceMatch(
+ walkInfo: WalkInfo,
+ globSegment: string
+ ): AsyncIterableIterator<WalkInfo> {
+ if (!walkInfo.info.isDirectory()) {
+ return;
+ } else if (globSegment == "..") {
+ const parentPath = join(walkInfo.filename, "..");
+ try {
+ return yield* [
+ { filename: parentPath, info: await stat(parentPath) }
+ ].filter(shouldInclude);
+ } catch {
+ return;
+ }
+ } else if (globSegment == "**") {
+ return yield* walk(walkInfo.filename, {
+ includeFiles: false,
+ includeDirs: true,
+ skip: excludePatterns
+ });
+ }
+ yield* walk(walkInfo.filename, {
+ maxDepth: 1,
+ includeDirs: true,
+ match: [globToRegExp(join(walkInfo.filename, globSegment), globOptions)],
+ skip: excludePatterns
+ });
+ }
+
+ let currentMatches: WalkInfo[] = [fixedRootInfo];
+ for (const segment of segments) {
+ // Advancing the list of current matches may introduce duplicates, so we
+ // pass everything through this Map.
+ const nextMatchMap: Map<string, FileInfo> = new Map();
+ for (const currentMatch of currentMatches) {
+ for await (const nextMatch of advanceMatch(currentMatch, segment)) {
+ nextMatchMap.set(nextMatch.filename, nextMatch.info);
+ }
+ }
+ currentMatches = [...nextMatchMap].sort().map(
+ ([filename, info]): WalkInfo => ({
+ filename,
+ info
+ })
+ );
+ }
+ if (hasTrailingSep) {
+ currentMatches = currentMatches.filter(({ info }): boolean =>
+ info.isDirectory()
+ );
+ }
+ if (!includeDirs) {
+ currentMatches = currentMatches.filter(
+ ({ info }): boolean => !info.isDirectory()
+ );
+ }
+ yield* currentMatches;
 }
 
 /** Synchronous version of `expandGlob()`. */
@@ -124,20 +211,91 @@ export function* expandGlobSync(
  globString: string,
  {
  root = cwd(),
+ exclude = [],
  includeDirs = true,
  extended = false,
  globstar = false,
- strict = false,
- filepath = true,
- flags = ""
+ strict = false
  }: ExpandGlobOptions = {}
 ): IterableIterator<WalkInfo> {
- const absoluteGlob = isAbsolute(globString)
- ? globString
- : join(root, globString);
- const globOptions = { extended, globstar, strict, filepath, flags };
- yield* walkSync(root, {
- match: [glob(absoluteGlob, globOptions)],
- includeDirs
- });
+ const resolveFromRoot = (path: string): string =>
+ isAbsolute(path) ? normalize(path) : join(root, path);
+ const globOptions: GlobOptions = { extended, globstar, strict };
+ const excludePatterns = exclude
+ .map(resolveFromRoot)
+ .map((s: string): RegExp => globToRegExp(s, globOptions));
+ const shouldInclude = ({ filename }: WalkInfo): boolean =>
+ !excludePatterns.some((p: RegExp): boolean => !!filename.match(p));
+ const { segments, hasTrailingSep } = split(resolveFromRoot(globString));
+
+ let fixedRoot = isWindows ? segments.shift()! : "/";
+ while (segments.length > 0 && !isGlob(segments[0])) {
+ fixedRoot = join(fixedRoot, segments.shift()!);
+ }
+
+ let fixedRootInfo: WalkInfo;
+ try {
+ fixedRootInfo = { filename: fixedRoot, info: statSync(fixedRoot) };
+ } catch {
+ return;
+ }
+
+ function* advanceMatch(
+ walkInfo: WalkInfo,
+ globSegment: string
+ ): IterableIterator<WalkInfo> {
+ if (!walkInfo.info.isDirectory()) {
+ return;
+ } else if (globSegment == "..") {
+ const parentPath = join(walkInfo.filename, "..");
+ try {
+ return yield* [
+ { filename: parentPath, info: statSync(parentPath) }
+ ].filter(shouldInclude);
+ } catch {
+ return;
+ }
+ } else if (globSegment == "**") {
+ return yield* walkSync(walkInfo.filename, {
+ includeFiles: false,
+ includeDirs: true,
+ skip: excludePatterns
+ });
+ }
+ yield* walkSync(walkInfo.filename, {
+ maxDepth: 1,
+ includeDirs: true,
+ match: [globToRegExp(join(walkInfo.filename, globSegment), globOptions)],
+ skip: excludePatterns
+ });
+ }
+
+ let currentMatches: WalkInfo[] = [fixedRootInfo];
+ for (const segment of segments) {
+ // Advancing the list of current matches may introduce duplicates, so we
+ // pass everything through this Map.
+ const nextMatchMap: Map<string, FileInfo> = new Map();
+ for (const currentMatch of currentMatches) {
+ for (const nextMatch of advanceMatch(currentMatch, segment)) {
+ nextMatchMap.set(nextMatch.filename, nextMatch.info);
+ }
+ }
+ currentMatches = [...nextMatchMap].sort().map(
+ ([filename, info]): WalkInfo => ({
+ filename,
+ info
+ })
+ );
+ }
+ if (hasTrailingSep) {
+ currentMatches = currentMatches.filter(({ info }): boolean =>
+ info.isDirectory()
+ );
+ }
+ if (!includeDirs) {
+ currentMatches = currentMatches.filter(
+ ({ info }): boolean => !info.isDirectory()
+ );
+ }
+ yield* currentMatches;
 }