@threadedstack/wmd-web 0.1.16 → 0.1.18

package/src/build/dockerignore.js

@@ -0,0 +1,270 @@
+// .dockerignore: a port of github.com/moby/patternmatcher (patternmatcher.go and ignorefile/ignorefile.go).
+// BuildKit v0.33 pins patternmatcher v0.6.1 (third_party/buildkit/go.mod); this port was written against the
+// source at github.com/moby/patternmatcher main (5a6d8429a19bb6948a372ff19e86fe83599a04b7), whose matching
+// code is the same as v0.6.1's for the functions ported here (except the escape set, see compile()): New, MatchesOrParentMatches, Pattern.compile and
+// Pattern.match, plus ReadAll. Only Unix separators exist here (the page has no Windows paths).
+//
+// Differences that cannot be matched exactly:
+// - Go's regexp is RE2; patterns compile to JavaScript RegExp. RE2-only syntax is not translated: POSIX classes
+//   such as `[[:alpha:]]` and `\Q...\E` literal runs behave as JavaScript reads them, not as Go does.
+//   Pattern classes use the same '[a-z]' / '[^a-z]' / '\\x' forms in both, so the shared syntax behaves the same.
+// - Go's `regexp` treats `\a`, `\f`, `\v` etc. as control characters; JavaScript's non-unicode mode treats an
+//   unknown escape as the literal character. Only reachable through a backslash before a letter.
+
+/** filepath.Clean on '/' paths (Go's lexical Clean). */
+export function cleanPath(p) {
+  if (p === '') return '.'
+  const rooted = p[0] === '/'
+  const out = []
+  for (const seg of p.split('/')) {
+    if (seg === '' || seg === '.') continue
+    if (seg === '..') {
+      if (out.length && out[out.length - 1] !== '..') out.pop()
+      else if (!rooted) out.push('..')
+      continue
+    }
+    out.push(seg)
+  }
+  const s = out.join('/')
+  if (rooted) return `/${s}`
+  return s === '' ? '.' : s
+}
+
+/** filepath.Dir on '/' paths. */
+function dirOf(p) {
+  const i = p.lastIndexOf('/')
+  if (i < 0) return '.'
+  return cleanPath(p.slice(0, i + 1))
+}
+
+/** ignorefile.ReadAll: the pattern list of a .dockerignore text. */
+export function parseDockerignore(text) {
+  const out = []
+  const lines = String(text).split('\n')
+  if (lines.length && lines[lines.length - 1] === '') lines.pop() // bufio.ScanLines: no phantom last line
+  lines.forEach((raw, idx) => {
+    let line = raw.endsWith('\r') ? raw.slice(0, -1) : raw
+    if (idx === 0 && line.charCodeAt(0) === 0xfeff) line = line.slice(1)
+    if (line.startsWith('#')) return
+    let pattern = goTrim(line)
+    if (pattern === '') return
+    const invert = pattern[0] === '!'
+    if (invert) pattern = goTrim(pattern.slice(1))
+    if (pattern.length > 0) {
+      pattern = cleanPath(pattern)
+      if (pattern.length > 1 && pattern[0] === '/') pattern = pattern.slice(1)
+    }
+    out.push(invert ? `!${pattern}` : pattern)
+  })
+  return out
+}
+
+// strings.TrimSpace: Unicode White_Space (JS trim() also strips U+FEFF, which Go does not).
+function goTrim(s) {
+  const ws = (c) => {
+    const n = c.charCodeAt(0)
+    return (n >= 9 && n <= 13) || n === 32 || n === 0x85 || n === 0xa0 || n === 0x1680 || (n >= 0x2000 && n <= 0x200a) ||
+      n === 0x2028 || n === 0x2029 || n === 0x202f || n === 0x205f || n === 0x3000
+  }
+  let a = 0
+  let b = s.length
+  while (a < b && ws(s[a])) a++
+  while (b > a && ws(s[b - 1])) b--
+  return s.slice(a, b)
+}
+
+const BAD = 'syntax error in pattern'
+
+/** The syntax check New does through filepath.Match(p, "."): throws on a malformed pattern. */
+export function checkPatternSyntax(p) {
+  const cs = Array.from(p)
+  let i = 0
+  const getEsc = () => {
+    if (i >= cs.length || cs[i] === '-' || cs[i] === ']') throw new Error(BAD)
+    if (cs[i] === '\\') {
+      i++
+      if (i >= cs.length) throw new Error(BAD)
+    }
+    i++
+  }
+  while (i < cs.length) {
+    const c = cs[i]
+    if (c === '[') {
+      i++
+      if (cs[i] === '^') i++
+      let nrange = 0
+      for (;;) {
+        if (cs[i] === ']' && nrange > 0) {
+          i++
+          break
+        }
+        getEsc()
+        if (cs[i] === '-') {
+          i++
+          getEsc()
+        }
+        nrange++
+        if (i >= cs.length) throw new Error(BAD)
+      }
+    } else if (c === '\\') {
+      i++
+      if (i >= cs.length) throw new Error(BAD)
+      i++
+    } else i++
+  }
+}
+
+const EXACT = 1
+const PREFIX = 2
+const SUFFIX = 3
+const REGEXP = 4
+const SL = '/'
+
+class Pattern {
+  constructor(cleaned, exclusion) {
+    this.cleanedPattern = cleaned
+    this.exclusion = exclusion
+    this.dirs = cleaned.split(SL)
+    this.matchType = 0
+    this.regexp = null
+  }
+  toString() {
+    return this.cleanedPattern
+  }
+  match(path) {
+    if (this.matchType === 0) this.compile()
+    switch (this.matchType) {
+      case EXACT:
+        return path === this.cleanedPattern
+      case PREFIX:
+        return path.startsWith(this.cleanedPattern.slice(0, -2))
+      case SUFFIX: {
+        const suffix = this.cleanedPattern.slice(2)
+        if (path.endsWith(suffix)) return true
+        return suffix[0] === SL && path === suffix.slice(1) // **/foo matches "foo"
+      }
+      case REGEXP:
+        if (!this.regexp) throw new Error(BAD)
+        return this.regexp.test(path)
+      default:
+        throw new Error(BAD)
+    }
+  }
+  compile() {
+    let reg = '^'
+    let type = EXACT
+    const cs = Array.from(this.cleanedPattern)
+    let p = 0
+    for (let i = 0; p < cs.length; i++) {
+      const ch = cs[p++]
+      if (ch === '*') {
+        if (cs[p] === '*') {
+          p++
+          if (cs[p] === SL) p++ // treat **/ as **
+          if (p >= cs.length) {
+            // "**EOF": accept all, as .gitignore
+            if (type === EXACT) type = PREFIX
+            else {
+              reg += '.*'
+              type = REGEXP
+            }
+          } else {
+            reg += `(.*${SL})?`
+            type = REGEXP
+          }
+          if (i === 0) type = SUFFIX
+        } else {
+          reg += `[^${SL}]*`
+          type = REGEXP
+        }
+      } else if (ch === '?') {
+        reg += `[^${SL}]`
+        type = REGEXP
+      } else if ('.+()$'.includes(ch)) {
+        // v0.6.1 escapes only these: its escapeBytes bitset is [8]byte indexed b%8 with bit 1<<(b/8), and for
+        // '|' (124), '{' (123) and '}' (125) b/8 is 15, which overflows the byte, so they are never escaped.
+        // Mirrored on purpose: `{1,2}` is a repeat and `|` an alternation, as in Go.
+        reg += `\\${ch}`
+      } else if (ch === '\\') {
+        if (p < cs.length) {
+          reg += `\\${cs[p++]}`
+          type = REGEXP
+        } else reg += '\\'
+      } else if (ch === '[' || ch === ']') {
+        reg += ch
+        type = REGEXP
+      } else reg += ch
+    }
+    if (type === REGEXP) {
+      reg += '$'
+      let re = null
+      try {
+        re = new RegExp(reg, 'u')
+      } catch {
+        try {
+          re = new RegExp(reg)
+        } catch {
+          throw new Error(BAD)
+        }
+      }
+      this.regexp = re
+    }
+    this.matchType = type
+  }
+}
+
+/**
+ * patternmatcher.New: build a matcher from the patterns ParseDockerignore returns (or any list; blank ones are
+ * skipped). Throws on '!' alone or a malformed pattern.
+ * `ignored(path, isDir)`: moby's MatchesOrParentMatches (a path is ignored when a pattern matches it or any
+ * parent directory, and no later '!' pattern re-includes it). isDir is accepted for callers' symmetry; moby does
+ * not use it. `hasExceptions` is moby's Exclusions(): when false, an ignored directory can be skipped whole.
+ */
+export function matcher(patterns) {
+  const list = []
+  let hasExceptions = false
+  for (let raw of patterns) {
+    let p = goTrim(raw)
+    if (p === '') continue
+    p = cleanPath(p)
+    let exclusion = false
+    if (p[0] === '!') {
+      if (p.length === 1) throw new Error('illegal exclusion pattern: "!"')
+      exclusion = true
+      p = p.slice(1)
+      hasExceptions = true
+    }
+    checkPatternSyntax(p)
+    list.push(new Pattern(p, exclusion))
+  }
+  function matchesOrParentMatches(file) {
+    let matched = false
+    const parentPath = dirOf(file)
+    const parentDirs = parentPath.split(SL)
+    for (const pattern of list) {
+      if (pattern.exclusion !== matched) continue
+      let match = pattern.match(file)
+      if (!match && parentPath !== '.') {
+        for (let i = 0; i < parentDirs.length; i++) {
+          try {
+            match = pattern.match(parentDirs.slice(0, i + 1).join(SL))
+          } catch {
+            match = false
+          }
+          if (match) break
+        }
+      }
+      if (match) matched = !pattern.exclusion
+    }
+    return matched
+  }
+  return {
+    patterns: list,
+    hasExceptions,
+    ignored(path, _isDir) {
+      const f = cleanPath(path)
+      if (f === '.') return false // never exclude everything
+      return matchesOrParentMatches(f)
+    },
+  }
+}