add windowsPathsNoEscape option

Fix: #468

README.md

@@ -210,10 +210,26 @@ parallel glob operations will be sped up by sharing information about
 the filesystem.
 
 * `cwd` The current working directory in which to search.  Defaults
-  to `process.cwd()`.
+  to `process.cwd()`.  This option is always coerced to use
+  forward-slashes as a path separator, because it is not tested
+  as a glob pattern, so there is no need to escape anything.
 * `root` The place where patterns starting with `/` will be mounted
   onto.  Defaults to `path.resolve(options.cwd, "/")` (`/` on Unix
-  systems, and `C:\` or some such on Windows.)
+  systems, and `C:\` or some such on Windows.)  This option is
+  always coerced to use forward-slashes as a path separator,
+  because it is not tested as a glob pattern, so there is no need
+  to escape anything.
+* `windowsPathsNoEscape` Use `\\` as a path separator _only_, and
+  _never_ as an escape character.  If set, all `\\` characters
+  are replaced with `/` in the pattern.  Note that this makes it
+  **impossible** to match against paths containing literal glob
+  pattern characters, but allows matching with patterns constructed
+  using `path.join()` and `path.resolve()` on Windows platforms,
+  mimicking the (buggy!) behavior of Glob v7 and before on
+  Windows.  Please use with caution, and be mindful of [the caveat
+  below about Windows paths](#windows).  (For legacy reasons,
+  this is also set if `allowWindowsEscape` is set to the exact
+  value `false`.)
 * `dot` Include `.dot` files in normal matches and `globstar` matches.
   Note that an explicit dot in a portion of the pattern will always
   match dot files.
@@ -332,6 +348,11 @@ Results from absolute patterns such as `/foo/*` are mounted onto the
 root setting using `path.join`.  On windows, this will by default result
 in `/foo/*` matching `C:\foo\bar.txt`.
 
+To automatically coerce all `\` characters to `/` in pattern
+strings, **thus making it impossible to escape literal glob
+characters**, you may set the `windowsPathsNoEscape` option to
+`true`.
+
 ## Race Conditions
 
 Glob searching, by its very nature, is susceptible to race conditions,

changelog.md

@@ -1,3 +1,7 @@
+## 8.1
+
+- Add `windowsPathsNoEscape` option
+
 ## 8.0
 
 - Only support node v12 and higher

common.js

@@ -57,6 +57,12 @@ function setopts (self, pattern, options) {
     pattern = "**/" + pattern
   }
 
+  self.windowsPathsNoEscape = !!options.windowsPathsNoEscape ||
+    options.allowWindowsEscape === false
+  if (self.windowsPathsNoEscape) {
+    pattern = pattern.replace(/\\/g, '/')
+  }
+
   self.silent = !!options.silent
   self.pattern = pattern
   self.strict = options.strict !== false
@@ -112,8 +118,6 @@ function setopts (self, pattern, options) {
   // Note that they are not supported in Glob itself anyway.
   options.nonegate = true
   options.nocomment = true
-  // always treat \ in patterns as escapes, not path separators
-  options.allowWindowsEscape = true
 
   self.minimatch = new Minimatch(pattern, options)
   self.options = self.minimatch.options

test/windows-paths-no-escape.js

@@ -0,0 +1,45 @@
+const t = require('tap')
+const g = require('../')
+
+const platforms = ['win32', 'posix']
+const originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform')
+for (const p of platforms) {
+  t.test(p, t => {
+    Object.defineProperty(process, 'platform', {
+      value: p,
+      enumerable: true,
+      configurable: true,
+      writable: true,
+    })
+    t.equal(process.platform, p, 'gut check: actually set platform')
+    const pattern = '/a/b/c/x\\[a-b\\]y\\*'
+    const def = new g.Glob(pattern, { noprocess: true })
+    const winpath = new g.Glob(pattern, {
+      windowsPathsNoEscape: true,
+      noprocess: true,
+    })
+    const winpathLegacy = new g.Glob(pattern, {
+      allowWindowsEscape: false,
+      noprocess: true,
+    })
+    const nowinpath = new g.Glob(pattern, {
+      windowsPathsNoEscape: false,
+      noprocess: true,
+    })
+
+    t.strictSame([
+      def.pattern,
+      nowinpath.pattern,
+      winpath.pattern,
+      winpathLegacy.pattern,
+    ], [
+      '/a/b/c/x\\[a-b\\]y\\*',
+      '/a/b/c/x\\[a-b\\]y\\*',
+      '/a/b/c/x/[a-b/]y/*',
+      '/a/b/c/x/[a-b/]y/*',
+    ])
+    t.end()
+  })
+}
+
+Object.defineProperty(process, 'platform', originalPlatform)