@mrclrchtr/supi-lsp 8.0.1 → 9.1.0

package/node_modules/ignore/index.js

@@ -13,12 +13,7 @@ const ESCAPE = '\\'
 // The characters that carry a meaning of their own inside a regular
 //   expression, so a literal one has to be escaped before it is emitted.
 const REGEX_LITERAL_SPECIAL = /[.*+?()[\]{}^$|\\/]/
-// A line of only spaces is blank -- the trailing-space trimming empties it --
-//   but a line holding a tab is a pattern for a tab-named path, since git
-//   never trims a tab.
-// A leading BOM is removed during compilation, so reject a line that would
-//   become empty after removing it and trimming spaces.
-const REGEX_TEST_BLANK_LINE = /^\uFEFF? *$/
+const BOM = '\uFEFF'
 const REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/
 const REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/
 const REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/
@@ -255,6 +250,11 @@ const REGEX_RESTORE_PLACEHOLDER = new RegExp(
 //   into a `RegExp` -- `_make` always turns it back into a real wildcard first.
 const TRAILING_WILDCARD = '\uE000'
 
+// A trailing "/**" is deferred the same way, because `checkRegex` has to tell
+//   it apart from a trailing "/*" (see `checkSourceOf`). For `.ignores()` it
+//   still never matches the folder itself (#21).
+const TRAILING_DOUBLESTAR = '\uE001'
+
 // Replace every bracket expression with a placeholder the replacers below
 //   leave alone, and translate it separately.
 const extractBrackets = pattern => {
@@ -284,11 +284,17 @@ const extractBrackets = pattern => {
       //   wildcard by `TRAILING_WILDCARD` and the wildcard replacers), `\[`
       //   (a literal bracket, the one `[` the bracket replacer still expects),
       //   `\ ` (a quoted trailing space), and `\\` (a literal backslash). A
-      //   lone trailing backslash never reaches here -- `checkPattern` throws
-      //   it out first.
+      //   lone trailing backslash can reach here after line-ending cleanup.
       const escaped = pattern[index + 1]
 
       if (
+        escaped === UNDEFINED
+        || escaped === SLASH && index + 2 === length
+      ) {
+        // Git removes a final directory slash before matching. An escape
+        //   without a character after that removal makes the pattern invalid.
+        out += hold(NEVER_MATCH)
+      } else if (
         escaped === '*'
         || escaped === '['
         || escaped === SPACE
@@ -376,42 +382,6 @@ const REGEX_INNER_SLASH = /\/(?!$)/
 //   against 400ns.
 const REPLACERS = [
 
-  [
-    // Remove BOM
-    // TODO:
-    // Other similar zero-width characters?
-    /^\uFEFF/,
-    () => EMPTY,
-    '\uFEFF'
-  ],
-
-  [
-    // A trailing line terminator, left on when a whole file's contents are
-    //   added as one pattern rather than split into lines. git never sees one
-    //   -- it reads a `.gitignore` line by line -- so it is not part of the
-    //   pattern and is dropped here, apart from the trailing-space trimming,
-    //   which follows git in touching spaces and nothing else.
-    /[\r\n]+$/,
-    () => EMPTY
-  ],
-
-  // > Trailing spaces are ignored unless they are quoted with backslash ("\")
-  [
-    // Only spaces, never tabs or other whitespace: git trims a trailing run
-    //   of `' '` and nothing else (dir.c, `trim_trailing_spaces`, a single
-    //   `case ' '`), so a pattern ending in a tab keeps it as a literal.
-    // (a\ ) -> (a )
-    // (a  ) -> (a)
-    // (a ) -> (a)
-    // (a \ ) -> (a  )
-    /((?:\\\\)*?)(\\? +)$/,
-    (_, m1, m2) => m1 + (
-      m2.indexOf('\\') === 0
-        ? SPACE
-        : EMPTY
-    )
-  ],
-
   // Replace (\ ) with ' '
   // Only a space: an escaped tab or other whitespace is already a literal by
   //   the time it reaches here, and a bare tab must be left as one, not turned
@@ -420,11 +390,14 @@ const REPLACERS = [
   // (\\ ) -> '\\ '
   // (\\\ ) -> '\\ '
   [
-    /(\\+?) /g,
-    (_, m1) => {
-      const {length} = m1
-      return m1.slice(0, length - length % 2) + SPACE
-    }
+    // A run of backslashes is taken whole, from its first one, so no match
+    //   ever starts again inside it -- `(\\+?) ` did, which made a long run
+    //   quadratic.
+    /(\\+)( ?)/g,
+    (_, run, space) => space
+      ? run.slice(0, run.length - run.length % 2) + SPACE
+      : run,
+    ESCAPE + SPACE
   ],
 
   // Escape metacharacters
@@ -553,8 +526,9 @@ const REPLACERS = [
       // case: /**
       // > A trailing `"/**"` matches everything inside.
 
-      // #21: everything inside but it should not include the current folder
-      : '\\/.+',
+      // #21: everything inside but it should not include the current folder,
+      //   resolved by `_make`
+      : `\\/${TRAILING_DOUBLESTAR}`,
     '*'
   ],
 
@@ -658,10 +632,11 @@ const REPLACERS = [
     source => {
       const last = source[source.length - 1]
 
-      // The pattern is empty, or ends in the pending trailing wildcard the next
-      //   step owns. A trailing `*` that is not the marker is a literal star,
-      //   which anchors like any other final character.
-      if (!last || last === TRAILING_WILDCARD) {
+      // The pattern is empty, or ends in a pending marker `_make` owns --
+      //   the trailing wildcard, or a trailing "/**". A trailing `*` that is
+      //   not the marker is a literal star, which anchors like any other
+      //   final character.
+      if (!last || last === TRAILING_WILDCARD || last === TRAILING_DOUBLESTAR) {
         return source
       }
 
@@ -679,38 +654,27 @@ const MODE_IGNORE = 'regex'
 const MODE_CHECK_IGNORE = 'checkRegex'
 const UNDERSCORE = '_'
 
-const TRAILING_WILD_CARD_REPLACERS = {
-  [MODE_IGNORE] (_, p1) {
-    const prefix = p1
-      // '\^':
-      // '/*' does not match EMPTY
-      // '/*' does not match everything
+const replaceTrailingWildcard = (_, p1) => {
+  const prefix = p1
+    // '\^':
+    // '/*' does not match EMPTY
+    // '/*' does not match everything
 
-      // '\\\/':
-      // 'abc/*' does not match 'abc/'
-      ? `${p1}[^/]+`
+    // '\\\/':
+    // 'abc/*' does not match 'abc/'
+    ? `${p1}[^/]+`
 
-      // 'a*' matches 'a'
-      // 'a*' matches 'aa'
-      : '[^/]*'
+    // 'a*' matches 'a'
+    // 'a*' matches 'aa'
+    : '[^/]*'
 
-    return `${prefix}(?=$|\\/$)`
-  },
-
-  [MODE_CHECK_IGNORE] (_, p1) {
-    // When doing `git check-ignore`
-    const prefix = p1
-      // '\\\/':
-      // 'abc/*' DOES match 'abc/' !
-      ? `${p1}[^/]*`
+  return `${prefix}(?=$|\\/$)`
+}
 
-      // 'a*' matches 'a'
-      // 'a*' matches 'aa'
-      : '[^/]*'
+const REGEX_REPLACE_TRAILING_DOUBLESTAR = /\uE001$/
 
-    return `${prefix}(?=$|\\/$)`
-  }
-}
+// 'abc/**' matches everything under 'abc', but not 'abc/' itself (#21)
+const replaceTrailingDoublestar = () => '.+(?=$|\\/$)'
 
 const WILDCARD = '[^\\/]*'
 
@@ -898,6 +862,28 @@ const makeRegexPrefix = pattern => {
     : replaced
 }
 
+// `checkRegex` tests a path with a trailing slash, 'abc/', the way
+//   `git check-ignore` matches that literal string once the directory itself
+//   is known not to be excluded (see `checkIgnore`): a trailing '/' of the
+//   pattern is dropped, a basename pattern sees an empty basename, and only a
+//   pattern whose last segment is a pending wildcard can match what is left
+//   after the final slash -- 'abc/*' and 'abc/**' match 'abc/', and 'abc/**'
+//   also matches 'abc/d/' (#77, #169).
+const checkSourceOf = (body, prefix) => {
+  if (body[body.length - 1] === SLASH) {
+    prefix = makeRegexPrefix(body.slice(0, - 1))
+  }
+
+  const head = prefix.slice(0, - 1)
+  const last = prefix[prefix.length - 1]
+
+  return last === TRAILING_WILDCARD
+    ? `${head}$`
+    : last === TRAILING_DOUBLESTAR
+      ? `${head}.*$`
+      : NEVER_MATCH
+}
+
 // A trailing slash does not stop a pattern being basename-only: it restricts
 //   the match to a directory, it does not let the pattern reach across one.
 //   Everything else a pattern can hold -- a wildcard, a character class, an
@@ -978,15 +964,12 @@ const parentOf = path => {
 
 const isString = subject => typeof subject === 'string'
 
-// > A blank line matches no files, so it can serve as a separator for readability.
+// Blank lines and comments are told by `createRule`, once the pattern is
+//   normalized.
 const checkPattern = pattern => pattern
   && isString(pattern)
-  && !REGEX_TEST_BLANK_LINE.test(pattern)
   && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern)
 
-  // > A line starting with # serves as a comment.
-  && pattern.indexOf('#') !== 0
-
 const splitPattern = pattern => pattern
 .split(REGEX_SPLITALL_CRLF)
 .filter(Boolean)
@@ -1039,12 +1022,13 @@ class IgnoreRule {
   }
 
   _make (mode, key) {
-    const str = pinWildcards(this.regexPrefix.replace(
-      REGEX_REPLACE_TRAILING_WILDCARD,
-
-      // It does not need to bind pattern
-      TRAILING_WILD_CARD_REPLACERS[mode]
-    ))
+    const str = pinWildcards(
+      mode === MODE_IGNORE
+        ? this.regexPrefix
+        .replace(REGEX_REPLACE_TRAILING_WILDCARD, replaceTrailingWildcard)
+        .replace(REGEX_REPLACE_TRAILING_DOUBLESTAR, replaceTrailingDoublestar)
+        : checkSourceOf(this.body, this.regexPrefix)
+    )
 
     const regex = this.ignoreCase
       ? new RegExp(str, 'i')
@@ -1054,17 +1038,79 @@ class IgnoreRule {
   }
 }
 
+const isLineEnd = char => char === '\r' || char === '\n'
+
+// Drop a line terminator, which can remain when patterns are passed as an
+//   array, and then the trailing spaces. Git trims spaces only, and a space
+//   escaped by an odd run of backslashes stays, unescaped, as the last one.
+// Scanned from the end: a regular expression can only try each start in
+//   turn, which is quadratic over a long run of spaces or backslashes.
+// 'a  ' -> 'a';  'a\ ' -> 'a ';  'a\\ ' -> 'a\\';  'a\t' -> 'a\t'
+const trimEnd = body => {
+  let end = body.length
+
+  while (end && isLineEnd(body[end - 1])) {
+    end --
+  }
+
+  const lineEnd = end
+
+  while (end && body[end - 1] === SPACE) {
+    end --
+  }
+
+  if (end === lineEnd) {
+    return body.slice(0, end)
+  }
+
+  let backslashes = 0
+
+  while (backslashes < end && body[end - backslashes - 1] === ESCAPE) {
+    backslashes ++
+  }
+
+  return backslashes % 2
+    ? body.slice(0, end - 1) + SPACE
+    : body.slice(0, end)
+}
+
 const createRule = ({
   pattern,
   mark
 }, ignoreCase) => {
+  // Git drops a BOM before it reads the first line, so before anything else.
+  let body = pattern[0] === BOM
+    ? pattern.slice(1)
+    : pattern
+
+  // > A line starting with # serves as a comment.
+  if (body[0] === '#') {
+    return
+  }
+
   let negative = false
-  let body = pattern
 
   // > An optional prefix "!" which negates the pattern;
-  if (body.indexOf('!') === 0) {
+  if (body[0] === '!') {
     negative = true
-    body = body.substr(1)
+    body = body.slice(1)
+  }
+
+  // Normalize the body before checking which slashes anchor the pattern.
+  //   Otherwise `bar/ ` is mistaken for a pattern containing an inner slash.
+  //   Only a body ending in a space or a line terminator has anything to trim.
+  const last = body[body.length - 1]
+
+  if (last === SPACE || last === '\r' || last === '\n') {
+    body = trimEnd(body)
+  }
+
+  // > A blank line matches no files, so it can serve as a separator for
+  // >   readability.
+  // Nor does a lone "!", or anything else left empty here: an empty pattern
+  //   would compile to a regex matching every path.
+  if (!body) {
+    return
   }
 
   body = body
@@ -1123,8 +1169,10 @@ class RuleManager {
       }
     }
 
-    if (checkPattern(pattern.pattern)) {
-      const rule = createRule(pattern, this._ignoreCase)
+    const rule = checkPattern(pattern.pattern)
+      && createRule(pattern, this._ignoreCase)
+
+    if (rule) {
       this._added = true
       this._rules.push(rule)
 
@@ -1147,9 +1195,54 @@ class RuleManager {
         : pattern
     ).forEach(this._add, this)
 
+    if (this._added) {
+      this._literalRules = UNDEFINED
+    }
+
     return this._added
   }
 
+  // Match the literal 'abc/' for `checkIgnore`, last rule wins. Only a rule
+  //   ending in a wildcard can match it (see `checkSourceOf`), so the rest
+  //   are left out once, rather than tested or compiled for every path.
+  testLiteral (path) {
+    const rules = this._literalRules || (
+      this._literalRules = this._rules.filter(
+        ({body}) => body[body.length - (
+          body[body.length - 1] === SLASH ? 2 : 1
+        )] === '*'
+      )
+    )
+
+    let ignored = false
+    let unignored = false
+    let matchedRule
+
+    for (let index = rules.length - 1; index >= 0; index --) {
+      const rule = rules[index]
+
+      if (rule.checkRegex.test(path)) {
+        ignored = !rule.negative
+        unignored = rule.negative
+        matchedRule = rule.negative
+          ? UNDEFINED
+          : rule
+        break
+      }
+    }
+
+    const ret = {
+      ignored,
+      unignored
+    }
+
+    if (matchedRule) {
+      ret.rule = matchedRule
+    }
+
+    return ret
+  }
+
   // Test one single path without recursively checking parent directories
   //
   // - checkUnignored `boolean` whether should check if the path is unignored,
@@ -1361,17 +1454,20 @@ class Ignore {
       return this.test(path)
     }
 
-    const parentPath = parentOf(path)
-
-    if (parentPath) {
-      const parent = this._t(parentPath, this._testCache, true)
+    // Like `git check-ignore`: a directory excluded by itself or by an
+    //   ancestor settles it, and only then is the literal 'abc/' matched
+    //   against the rules (see `checkSourceOf`).
+    const dir = this._t(path, this._testCache, true)
 
-      if (parent.ignored) {
-        return parent
-      }
+    if (dir.ignored) {
+      return dir
     }
 
-    return this._rules.test(path, false, MODE_CHECK_IGNORE)
+    const literal = this._rules.testLiteral(path)
+
+    return literal.ignored || literal.unignored
+      ? literal
+      : dir
   }
 
   _t (