minimatch 4.1.0 → 5.0.0

package/LICENSE

@@ -1,6 +1,6 @@
 The ISC License
 
-Copyright (c) Isaac Z. Schlueter and Contributors
+Copyright (c) 2011-2022 Isaac Z. Schlueter and Contributors
 
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted, provided that the above

package/README.md

@@ -35,6 +35,20 @@ See:
 * `man 3 fnmatch`
 * `man 5 gitignore`
 
+## Windows
+
+**Please only use forward-slashes in glob expressions.**
+
+Though windows uses either `/` or `\` as its path separator, only `/`
+characters are used by this glob implementation.  You must use
+forward-slashes **only** in glob expressions.  Back-slashes in patterns
+will always be interpreted as escape characters, not path separators.
+
+Note that `\` or `/` _will_ be interpreted as path separators in paths on
+Windows, and will match against `/` in glob expressions.
+
+So just always use `/` in patterns.
+
 ## Minimatch Class
 
 Create a minimatch object by instantiating the `minimatch.Minimatch` class.
@@ -187,12 +201,6 @@ minimatch('/a/b', '/**/d', { partial: true })     // true, might be /a/b/.../d
 minimatch('/x/y/z', '/a/**/z', { partial: true }) // false, because x !== a
 ```
 
-### allowWindowsEscape
-
-Windows path separator `\` is by default converted to `/`, which
-prohibits the usage of `\` as a escape character. This flag skips that
-behavior and allows using the escape character.
-
 ## Comparisons to other fnmatch/glob implementations
 
 While strict compliance with the existing standards is a worthwhile

package/minimatch.js

@@ -17,6 +17,7 @@ const path = (() => { try { return require('path') } catch (e) {}})() || {
 minimatch.sep = path.sep
 
 const GLOBSTAR = Symbol('globstar **')
+minimatch.GLOBSTAR = GLOBSTAR
 const expand = require('brace-expansion')
 
 const plTypes = {
@@ -166,11 +167,6 @@ class Minimatch {
 
     if (!options) options = {}
 
-    // windows support: need to use /, not \
-    if (!options.allowWindowsEscape && path.sep !== '/') {
-      pattern = pattern.split(path.sep).join('/')
-    }
-
     this.options = options
     this.set = []
     this.pattern = pattern
@@ -363,11 +359,7 @@ class Minimatch {
       // patterns with magic have been turned into regexps.
       var hit
       if (typeof p === 'string') {
-        if (options.nocase) {
-          hit = f.toLowerCase() === p.toLowerCase()
-        } else {
-          hit = f === p
-        }
+        hit = f === p
         this.debug('string match', p, f, hit)
       } else {
         hit = f.match(p)
@@ -430,7 +422,7 @@ class Minimatch {
     if (pattern === '') return ''
 
     let re = ''
-    let hasMagic = false
+    let hasMagic = !!options.nocase
     let escaping = false
     // ? => one single character
     const patternListStack = []
@@ -475,8 +467,16 @@ class Minimatch {
       this.debug('%s\t%s %s %j', pattern, i, re, c)
 
       // skip over any that are escaped.
-      if (escaping && reSpecials[c]) {
-        re += '\\' + c
+      if (escaping) {
+        /* istanbul ignore next - completely not allowed, even escaped. */
+        if (c === '/') {
+          return false
+        }
+
+        if (reSpecials[c]) {
+          re += '\\'
+        }
+        re += c
         escaping = false
         continue
       }
@@ -484,7 +484,6 @@ class Minimatch {
       switch (c) {
         /* istanbul ignore next */
         case '/': {
-          // completely not allowed, even escaped.
           // Should already be path-split by now.
           return false
         }
@@ -567,9 +566,8 @@ class Minimatch {
         continue
 
         case '|':
-          if (inClass || !patternListStack.length || escaping) {
+          if (inClass || !patternListStack.length) {
             re += '\\|'
-            escaping = false
             continue
           }
 
@@ -600,7 +598,6 @@ class Minimatch {
           //  first in the list.  -- POSIX.2 2.8.3.2
           if (i === classStart + 1 || !inClass) {
             re += '\\' + c
-            escaping = false
             continue
           }
 
@@ -635,15 +632,12 @@ class Minimatch {
           // swallow any state char that wasn't consumed
           clearStateChar()
 
-          if (escaping) {
-            // no need
-            escaping = false
-          } else if (reSpecials[c]
-            && !(c === '^' && inClass)) {
+          if (reSpecials[c] && !(c === '^' && inClass)) {
             re += '\\'
           }
 
           re += c
+          break
 
       } // switch
     } // for
@@ -673,6 +667,7 @@ class Minimatch {
       this.debug('setting tail', re, pl)
       // maybe some even number of \, then maybe 1 \, followed by a |
       tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, (_, $1, $2) => {
+        /* istanbul ignore else - should already be done */
         if (!$2) {
           // the | isn't already escaped, so escape it.
           $2 = '\\'
@@ -794,13 +789,42 @@ class Minimatch {
       : twoStarNoDot
     const flags = options.nocase ? 'i' : ''
 
-    let re = set.map(pattern =>
-      pattern.map(p =>
-        (p === GLOBSTAR) ? twoStar
-        : (typeof p === 'string') ? regExpEscape(p)
+    // coalesce globstars and regexpify non-globstar patterns
+    // if it's the only item, then we just do one twoStar
+    // if it's the first, and there are more, prepend (\/|twoStar\/)? to next
+    // if it's the last, append (\/twoStar|) to previous
+    // if it's in the middle, append (\/|\/twoStar\/) to previous
+    // then filter out GLOBSTAR symbols
+    let re = set.map(pattern => {
+      pattern = pattern.map(p =>
+        typeof p === 'string' ? regExpEscape(p)
+        : p === GLOBSTAR ? GLOBSTAR
         : p._src
-      ).join('\\\/')
-    ).join('|')
+      ).reduce((set, p) => {
+        if (!(set[set.length - 1] === GLOBSTAR && p === GLOBSTAR)) {
+          set.push(p)
+        }
+        return set
+      }, [])
+      pattern.forEach((p, i) => {
+        if (p !== GLOBSTAR || pattern[i-1] === GLOBSTAR) {
+          return
+        }
+        if (i === 0) {
+          if (pattern.length > 1) {
+            pattern[i+1] = '(?:\\\/|' + twoStar + '\\\/)?' + pattern[i+1]
+          } else {
+            pattern[i] = twoStar
+          }
+        } else if (i === pattern.length - 1) {
+          pattern[i-1] += '(?:\\\/|' + twoStar + ')?'
+        } else {
+          pattern[i-1] += '(?:\\\/|\\\/' + twoStar + '\\\/)' + pattern[i+1]
+          pattern[i+1] = GLOBSTAR
+        }
+      })
+      return pattern.filter(p => p !== GLOBSTAR).join('/')
+    }).join('|')
 
     // must match entire pattern
     // ending in a * or ** will make it less strict.

package/package.json

@@ -2,7 +2,7 @@
   "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me)",
   "name": "minimatch",
   "description": "a glob matcher in javascript",
-  "version": "4.1.0",
+  "version": "5.0.0",
   "repository": {
     "type": "git",
     "url": "git://github.com/isaacs/minimatch.git"
@@ -10,6 +10,7 @@
   "main": "minimatch.js",
   "scripts": {
     "test": "tap",
+    "snap": "tap",
     "preversion": "npm test",
     "postversion": "npm publish",
     "prepublishOnly": "git push origin --follow-tags"
@@ -18,7 +19,7 @@
     "node": ">=10"
   },
   "dependencies": {
-    "brace-expansion": "^1.1.7"
+    "brace-expansion": "^2.0.1"
   },
   "devDependencies": {
     "tap": "^15.1.6"