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,16 @@
 import { globrex } from "./globrex.ts";
-import { isAbsolute, join } from "./path/mod.ts";
+import { SEP, SEP_PATTERN, isWindows } from "./path/constants.ts";
+import { isAbsolute, join, normalize } from "./path/mod.ts";
 import { WalkInfo, walk, walkSync } from "./walk.ts";
-const { cwd } = Deno;
+const { DenoError, ErrorKind, 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 +22,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 +38,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, strict: false, filepath: true });
+  return result.path!.regex;
 }
 
 /** Test whether the given string is a glob */
@@ -84,11 +79,78 @@ export function isGlob(str: string): boolean {
   return false;
 }
 
+/** Like normalize(), but doesn't collapse "**\/.." when `globstar` is true. */
+export function normalizeGlob(
+  glob: string,
+  { globstar = false }: GlobOptions = {}
+): string {
+  if (!!glob.match(/\0/g)) {
+    throw new DenoError(
+      ErrorKind.InvalidPath,
+      `Glob contains invalid characters: "${glob}"`
+    );
+  }
+  if (!globstar) {
+    return normalize(glob);
+  }
+  const s = SEP_PATTERN.source;
+  const badParentPattern = new RegExp(
+    `(?<=(${s}|^)\\*\\*${s})\\.\\.(?=${s}|$)`,
+    "g"
+  );
+  return normalize(glob.replace(badParentPattern, "\0")).replace(/\0/g, "..");
+}
+
+/** Like join(), but doesn't collapse "**\/.." when `globstar` is true. */
+export function joinGlobs(
+  globs: string[],
+  { extended = false, globstar = false }: GlobOptions = {}
+): string {
+  if (!globstar || globs.length == 0) {
+    return join(...globs);
+  }
+  if (globs.length === 0) return ".";
+  let joined: string | undefined;
+  for (let i = 0, len = globs.length; i < len; ++i) {
+    let path = globs[i];
+    if (path.length > 0) {
+      if (!joined) joined = path;
+      else joined += `${SEP}${path}`;
+    }
+  }
+  if (!joined) return ".";
+  return normalizeGlob(joined, { extended, globstar });
+}
+
 export interface ExpandGlobOptions extends GlobOptions {
   root?: string;
+  exclude?: string[];
   includeDirs?: boolean;
 }
 
+interface SplitPath {
+  segments: string[];
+  isAbsolute: boolean;
+  hasTrailingSep: boolean;
+  // Defined for any absolute Windows path.
+  winRoot?: string;
+}
+
+// TODO: Maybe make this public somewhere.
+function split(path: string): SplitPath {
+  const s = SEP_PATTERN.source;
+  const segments = path
+    .replace(new RegExp(`^${s}|${s}$`, "g"), "")
+    .split(SEP_PATTERN);
+  const isAbsolute_ = isAbsolute(path);
+  return {
+    segments,
+    isAbsolute: isAbsolute_,
+    hasTrailingSep: !!path.match(new RegExp(`${s}$`)),
+    winRoot: isWindows && isAbsolute_ ? segments.shift() : undefined
+  };
+}
+
 /**
  * Expand the glob string from the specified `root` directory and yield each
  * result as a `WalkInfo` object.
@@ -97,47 +159,187 @@ export interface ExpandGlobOptions extends GlobOptions {
 // This is a very incomplete solution. The whole directory tree from `root` is
 // walked and parent paths are not supported.
 export async function* expandGlob(
-  globString: string,
+  glob: string,
   {
     root = cwd(),
+    exclude = [],
     includeDirs = true,
     extended = false,
-    globstar = false,
-    strict = false,
-    filepath = true,
-    flags = ""
+    globstar = 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 };
+  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, winRoot } = split(resolveFromRoot(glob));
+
+  let fixedRoot = winRoot != undefined ? winRoot : "/";
+  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()`. */
 // TODO: As `expandGlob()`.
 export function* expandGlobSync(
-  globString: string,
+  glob: string,
   {
     root = cwd(),
+    exclude = [],
     includeDirs = true,
     extended = false,
-    globstar = false,
-    strict = false,
-    filepath = true,
-    flags = ""
+    globstar = 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 };
+  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, winRoot } = split(resolveFromRoot(glob));
+
+  let fixedRoot = winRoot != undefined ? winRoot : "/";
+  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;
 }