@macula-io/martha 0.0.0 → 1.0.0

package/node_modules/glob/src/processor.ts

@@ -0,0 +1,333 @@
+// synchronous utility for filtering entries and calculating subwalks
+
+import { GLOBSTAR } from 'minimatch'
+import type { Path } from 'path-scurry'
+import type { MMMatcher, MMPattern, Pattern } from './pattern.js'
+import type { GlobWalkerOpts } from './walker.js'
+
+/**
+ * A cache of which patterns have been processed for a given Path, in
+ * this walk step and the steps that led to it.
+ *
+ * A step only adds to it before it makes the caches for the next
+ * steps, so a copy can look up the chain of caches before it, in
+ * place of copying their entries. A pattern for a path that a cache
+ * up the chain has already seen is added to that cache's set, so that
+ * the other steps that share it see it too. Paths are keyed by their
+ * full path, because path-scurry can make a new Path object for the
+ * same path once its cache of children is full.
+ */
+export class HasWalkedCache {
+  parent?: HasWalkedCache
+  store?: Map<string, Set<string>>
+  constructor(parent?: HasWalkedCache) {
+    this.parent = parent
+  }
+  copy() {
+    return new HasWalkedCache(this)
+  }
+  // the set for the path in this cache, or the closest one before it
+  #find(fullpath: string): Set<string> | undefined {
+    const set = this.store?.get(fullpath)
+    return set || !this.parent ? set : this.parent.#find(fullpath)
+  }
+
+  hasWalked(target: Path, pattern: Pattern) {
+    return !!this.#find(target.fullpath())?.has(pattern.globString())
+  }
+  storeWalked(target: Path, pattern: Pattern) {
+    const fullpath = target.fullpath()
+    const cached = this.#find(fullpath)
+    if (cached) cached.add(pattern.globString())
+    else
+      (this.store ??= new Map()).set(
+        fullpath,
+        new Set([pattern.globString()]),
+      )
+  }
+}
+
+/**
+ * A record of which paths have been matched in a given walk step,
+ * and whether they only are considered a match if they are a directory,
+ * and whether their absolute or relative path should be returned.
+ * The store maps each path to {@link MatchRecord.ABSOLUTE} and
+ * {@link MatchRecord.IF_DIR} flags.
+ */
+export class MatchRecord {
+  static readonly ABSOLUTE = 2
+  static readonly IF_DIR = 1
+  store: Map<Path, number> = new Map()
+  add(target: Path, absolute: boolean, ifDir: boolean) {
+    const n =
+      (absolute ? MatchRecord.ABSOLUTE : 0) |
+      (ifDir ? MatchRecord.IF_DIR : 0)
+    const current = this.store.get(target)
+    this.store.set(target, current === undefined ? n : n & current)
+  }
+}
+
+/**
+ * A collection of patterns that must be processed in a subsequent step
+ * for a given path.
+ */
+export class SubWalks {
+  store: Map<Path, Pattern[]> = new Map()
+  add(target: Path, pattern: Pattern) {
+    if (!target.canReaddir()) {
+      return
+    }
+    const subs = this.store.get(target)
+    if (subs) {
+      if (!subs.find(p => p.globString() === pattern.globString())) {
+        subs.push(pattern)
+      }
+    } else this.store.set(target, [pattern])
+  }
+  get(target: Path): Pattern[] {
+    const subs = this.store.get(target)
+    /* c8 ignore start */
+    if (!subs) {
+      throw new Error('attempting to walk unknown path')
+    }
+    /* c8 ignore stop */
+    return subs
+  }
+  entries(): [Path, Pattern[]][] {
+    return this.keys().map(k => [k, this.store.get(k) as Pattern[]])
+  }
+  keys(): Path[] {
+    return [...this.store.keys()].filter(t => t.canReaddir())
+  }
+}
+
+/**
+ * The class that processes patterns for a given path.
+ *
+ * Handles child entry filtering, and determining whether a path's
+ * directory contents must be read.
+ */
+export class Processor {
+  hasWalkedCache: HasWalkedCache
+  matches = new MatchRecord()
+  subwalks = new SubWalks()
+  patterns?: Pattern[]
+  follow: boolean
+  dot: boolean
+  opts: GlobWalkerOpts
+
+  constructor(opts: GlobWalkerOpts, hasWalkedCache?: HasWalkedCache) {
+    this.opts = opts
+    this.follow = !!opts.follow
+    this.dot = !!opts.dot
+    this.hasWalkedCache =
+      hasWalkedCache ? hasWalkedCache.copy() : new HasWalkedCache()
+  }
+
+  processPatterns(target: Path, patterns: Pattern[]) {
+    this.patterns = patterns
+    const processingSet: [Path, Pattern][] = patterns.map(p => [target, p])
+
+    // map of paths to the magic-starting subwalks they need to walk
+    // first item in patterns is the filter
+
+    for (let [t, pattern] of processingSet) {
+      this.hasWalkedCache.storeWalked(t, pattern)
+
+      const root = pattern.root()
+      const absolute = pattern.isAbsolute() && this.opts.absolute !== false
+
+      // start absolute patterns at root
+      if (root) {
+        t = t.resolve(
+          root === '/' && this.opts.root !== undefined ?
+            this.opts.root
+          : root,
+        )
+        const rest = pattern.rest()
+        if (!rest) {
+          this.matches.add(t, true, false)
+          continue
+        } else {
+          pattern = rest
+        }
+      }
+
+      if (t.isENOENT()) continue
+
+      let p: MMPattern
+      let rest: Pattern | null
+      let changed = false
+      while (
+        typeof (p = pattern.pattern()) === 'string' &&
+        (rest = pattern.rest())
+      ) {
+        const c = t.resolve(p)
+        t = c
+        pattern = rest
+        changed = true
+      }
+      p = pattern.pattern()
+      rest = pattern.rest()
+      if (changed) {
+        if (this.hasWalkedCache.hasWalked(t, pattern)) continue
+        this.hasWalkedCache.storeWalked(t, pattern)
+      }
+
+      // now we have either a final string for a known entry,
+      // more strings for an unknown entry,
+      // or a pattern starting with magic, mounted on t.
+      if (typeof p === 'string') {
+        // must not be final entry, otherwise we would have
+        // concatenated it earlier.
+        const ifDir = p === '..' || p === '' || p === '.'
+        this.matches.add(t.resolve(p), absolute, ifDir)
+        continue
+      } else if (p === GLOBSTAR) {
+        // if no rest, match and subwalk pattern
+        // if rest, process rest and subwalk pattern
+        // if it's a symlink, but we didn't get here by way of a
+        // globstar match (meaning it's the first time THIS globstar
+        // has traversed a symlink), then we follow it. Otherwise, stop.
+        if (
+          !t.isSymbolicLink() ||
+          this.follow ||
+          pattern.checkFollowGlobstar()
+        ) {
+          this.subwalks.add(t, pattern)
+        }
+        const rp = rest?.pattern()
+        const rrest = rest?.rest()
+        if (!rest || ((rp === '' || rp === '.') && !rrest)) {
+          // only HAS to be a dir if it ends in **/ or **/.
+          // but ending in ** will match files as well.
+          this.matches.add(t, absolute, rp === '' || rp === '.')
+        } else {
+          if (rp === '..') {
+            // this would mean you're matching **/.. at the fs root,
+            // and no thanks, I'm not gonna test that specific case.
+            /* c8 ignore start */
+            const tp = t.parent || t
+            /* c8 ignore stop */
+            if (!rrest) this.matches.add(tp, absolute, true)
+            else if (!this.hasWalkedCache.hasWalked(tp, rrest)) {
+              this.subwalks.add(tp, rrest)
+            }
+          }
+        }
+      } else if (typeof p === 'object') {
+        this.subwalks.add(t, pattern)
+      }
+    }
+
+    return this
+  }
+
+  subwalkTargets(): Path[] {
+    return this.subwalks.keys()
+  }
+
+  child() {
+    return new Processor(this.opts, this.hasWalkedCache)
+  }
+
+  // return a new Processor containing the subwalks for each
+  // child entry, and a set of matches, and
+  // a hasWalkedCache that's a copy of this one
+  // then we're going to call
+  filterEntries(parent: Path, entries: Path[]): Processor {
+    const patterns = this.subwalks.get(parent)
+    // put matches and entry walks into the results processor
+    const results = this.child()
+    for (const e of entries) {
+      for (const pattern of patterns) {
+        const absolute = pattern.isAbsolute()
+        const p = pattern.pattern()
+        const rest = pattern.rest()
+        if (p === GLOBSTAR) {
+          results.testGlobstar(e, pattern, rest, absolute)
+        } else if (typeof p === 'object') {
+          results.testMatcher(e, p, rest, absolute)
+        } else {
+          results.testString(e, p, rest, absolute)
+        }
+      }
+    }
+    return results
+  }
+
+  testGlobstar(
+    e: Path,
+    pattern: Pattern,
+    rest: Pattern | null,
+    absolute: boolean,
+  ) {
+    if (this.dot || !e.name.startsWith('.')) {
+      if (!pattern.hasMore()) {
+        this.matches.add(e, absolute, false)
+      }
+      if (e.canReaddir()) {
+        // if we're in follow mode or it's not a symlink, just keep
+        // testing the same pattern. If there's more after the globstar,
+        // then this symlink consumes the globstar. If not, then we can
+        // follow at most ONE symlink along the way, so we mark it, which
+        // also checks to ensure that it wasn't already marked.
+        if (this.follow || !e.isSymbolicLink()) {
+          this.subwalks.add(e, pattern)
+        } else if (e.isSymbolicLink()) {
+          if (rest && pattern.checkFollowGlobstar()) {
+            this.subwalks.add(e, rest)
+          } else if (pattern.markFollowGlobstar()) {
+            this.subwalks.add(e, pattern)
+          }
+        }
+      }
+    }
+    // if the NEXT thing matches this entry, then also add
+    // the rest.
+    if (rest) {
+      const rp = rest.pattern()
+      if (
+        typeof rp === 'string' &&
+        // dots and empty were handled already
+        rp !== '..' &&
+        rp !== '' &&
+        rp !== '.'
+      ) {
+        this.testString(e, rp, rest.rest(), absolute)
+      } else if (rp === '..') {
+        /* c8 ignore start */
+        const ep = e.parent || e
+        /* c8 ignore stop */
+        this.subwalks.add(ep, rest)
+      } else if (typeof rp === 'object') {
+        this.testMatcher(e, rp, rest.rest(), absolute)
+      }
+    }
+  }
+
+  testMatcher(
+    e: Path,
+    p: MMMatcher,
+    rest: Pattern | null,
+    absolute: boolean,
+  ) {
+    // an entry name is one path portion, with no `/`
+    if (!p.testUnchecked(e.name)) return
+    if (!rest) {
+      this.matches.add(e, absolute, false)
+    } else {
+      this.subwalks.add(e, rest)
+    }
+  }
+
+  testString(e: Path, p: string, rest: Pattern | null, absolute: boolean) {
+    // should never happen?
+    if (!e.isNamed(p)) return
+    if (!rest) {
+      this.matches.add(e, absolute, false)
+    } else {
+      this.subwalks.add(e, rest)
+    }
+  }
+}