CHANGELOG.md

@@ -32,6 +32,12 @@ Changelog entries are classified using the following labels _(from [keep-a-chang
 
 </details>
 
+## 2.2.2 (2020-03-21)
+
+### Fixed
+
+* Correctly handle parts of the pattern after parentheses in the `scan` method ([e15b920](https://github.com/micromatch/picomatch/commit/e15b920)).
+
 ## 2.2.1 (2020-01-04)
 
 * Fixes [#49](https://github.com/micromatch/picomatch/issues/49), so that braces with no sets or ranges are now propertly treated as literals.

README.md

@@ -234,27 +234,28 @@ console.log(result);
   negated: true }
 ```
 
-### [.compileRe](lib/picomatch.js#L249)
+### [.compileRe](lib/picomatch.js#L250)
 
-Create a regular expression from a glob pattern.
+Create a regular expression from a parsed glob pattern.
 
 **Params**
 
-* `input` **{String}**: A glob pattern to convert to regex.
+* `state` **{String}**: The object returned from the `.parse` method.
 * `options` **{Object}**
 * `returns` **{RegExp}**: Returns a regex created from the given pattern.
 
 **Example**
 
 ```js
 const picomatch = require('picomatch');
-// picomatch.makeRe(input[, options]);
+const state = picomatch.parse('*.js');
+// picomatch.compileRe(state[, options]);
 
-console.log(picomatch.makeRe('*.js'));
+console.log(picomatch.compileRe(state));
 //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
 ```
 
-### [.toRegex](lib/picomatch.js#L317)
+### [.toRegex](lib/picomatch.js#L318)
 
 Create a regular expression from the given regex source string.
 

lib/parse.js

@@ -228,8 +228,6 @@ const parse = (input, options) => {
     const output = (opts.capture ? '(' : '') + token.open;
 
     increment('parens');
-
-
     push({ type, value, output: state.output ? '' : ONE_CHAR });
     push({ type: 'paren', extglob: true, value: advance(), output });
     extglobs.push(token);
@@ -585,7 +583,7 @@ const parse = (input, options) => {
         const out = state.output.slice(0, brace.outputIndex);
         const toks = state.tokens.slice(brace.tokensIndex);
         brace.value = brace.output = '\\{';
-        value = output = `\\}`;
+        value = output = '\\}';
         state.output = out;
         for (const t of toks) {
           state.output += (t.output || t.value);

lib/picomatch.js

@@ -231,16 +231,17 @@ picomatch.parse = (pattern, options) => {
 picomatch.scan = (input, options) => scan(input, options);
 
 /**
- * Create a regular expression from a glob pattern.
+ * Create a regular expression from a parsed glob pattern.
  *
  * ```js
  * const picomatch = require('picomatch');
- * // picomatch.makeRe(input[, options]);
+ * const state = picomatch.parse('*.js');
+ * // picomatch.compileRe(state[, options]);
  *
- * console.log(picomatch.makeRe('*.js'));
+ * console.log(picomatch.compileRe(state));
  * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
  * ```
- * @param {String} `input` A glob pattern to convert to regex.
+ * @param {String} `state` The object returned from the `.parse` method.
  * @param {Object} `options`
  * @return {RegExp} Returns a regex created from the given pattern.
  * @api public

lib/scan.js

@@ -247,23 +247,24 @@ const scan = (input, options) => {
     }
 
     if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
-      while (eos() !== true && (code = advance())) {
-        if (code === CHAR_BACKWARD_SLASH) {
-          backslashes = token.backslashes = true;
-          code = advance();
-          continue;
-        }
-
-        if (code === CHAR_RIGHT_PARENTHESES) {
-          isGlob = token.isGlob = true;
-          finished = true;
+      isGlob = token.isGlob = true;
 
-          if (scanToEnd === true) {
+      if (scanToEnd === true) {
+        while (eos() !== true && (code = advance())) {
+          if (code === CHAR_LEFT_PARENTHESES) {
+            backslashes = token.backslashes = true;
+            code = advance();
             continue;
           }
-          break;
+
+          if (code === CHAR_RIGHT_PARENTHESES) {
+            finished = true;
+            break;
+          }
         }
+        continue;
       }
+      break;
     }
 
     if (isGlob === true) {

package.json

@@ -1,7 +1,7 @@
 {
   "name": "picomatch",
   "description": "Blazing fast and accurate glob matcher written in JavaScript, with no dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions.",
-  "version": "2.2.1",
+  "version": "2.2.2",
   "homepage": "https://github.com/micromatch/picomatch",
   "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
   "funding": "https://github.com/sponsors/jonschlinkert",
@@ -22,7 +22,7 @@
     "lint": "eslint --cache --cache-location node_modules/.cache/.eslintcache --report-unused-disable-directives --ignore-path .gitignore .",
     "mocha": "mocha --reporter dot",
     "test": "npm run lint && npm run mocha",
-    "test:ci": "npm run lint && npm run test:cover",
+    "test:ci": "npm run test:cover",
     "test:cover": "nyc npm run mocha"
   },
   "devDependencies": {

test/api.scan.js

@@ -8,6 +8,16 @@ const both = (...args) => {
   return [base, glob];
 };
 
+/**
+ * @param {String} pattern
+ * @param {String[]} parts
+ */
+function assertParts(pattern, parts) {
+  const info = scan(pattern, { parts: true });
+
+  assert.deepStrictEqual(info.parts, parts);
+}
+
 /**
  * Most of the unit tests in this file were from https://github.com/es128/glob-parent
  * and https://github.com/jonschlinkert/glob-base. Both libraries use a completely
@@ -252,6 +262,56 @@ describe('picomatch', () => {
         negated: false
       });
     });
+
+    it('should return parts of the pattern', () => {
+      // Right now it returns []
+      // assertParts('', ['']);
+      // assertParts('*', ['*']);
+      // assertParts('.*', ['.*']);
+      // assertParts('**', ['**']);
+      // assertParts('foo', ['foo']);
+      // assertParts('foo*', ['foo*']);
+      // assertParts('/', ['', '']);
+      // assertParts('/*', ['', '*']);
+      // assertParts('./', ['']);
+      // assertParts('{1..9}', ['{1..9}']);
+      // assertParts('c!(.)z', ['c!(.)z']);
+      // assertParts('(b|a).(a)', ['(b|a).(a)']);
+      // assertParts('+(a|b\\[)*', ['+(a|b\\[)*']);
+      // assertParts('@(a|b).md', ['@(a|b).md']);
+      // assertParts('(a/b)', ['(a/b)']);
+      // assertParts('(a\\b)', ['(a\\b)']);
+      // assertParts('foo\\[a\\/]', ['foo\\[a\\/]']);
+      // assertParts('foo[/]bar', ['foo[/]bar']);
+      // assertParts('/dev\\/@(tcp|udp)\\/*\\/*', ['', '/dev\\/@(tcp|udp)\\/*\\/*']);
+
+      // Right now it returns ['*']
+      // assertParts('*/', ['*', '']);
+
+      // Right now it returns ['!(!(bar)', 'baz)']
+      // assertParts('!(!(bar)/baz)', ['!(!(bar)/baz)']);
+
+      assertParts('./foo', ['foo']);
+      assertParts('../foo', ['..', 'foo']);
+
+      assertParts('foo/bar', ['foo', 'bar']);
+      assertParts('foo/*', ['foo', '*']);
+      assertParts('foo/**', ['foo', '**']);
+      assertParts('foo/**/*', ['foo', '**', '*']);
+      assertParts('フォルダ/**/*', ['フォルダ', '**', '*']);
+
+      assertParts('foo/!(abc)', ['foo', '!(abc)']);
+      assertParts('c/!(z)/v', ['c', '!(z)', 'v']);
+      assertParts('c/@(z)/v', ['c', '@(z)', 'v']);
+      assertParts('foo/(bar|baz)', ['foo', '(bar|baz)']);
+      assertParts('foo/(bar|baz)*', ['foo', '(bar|baz)*']);
+      assertParts('**/*(W*, *)*', ['**', '*(W*, *)*']);
+      assertParts('a/**@(/x|/z)/*.md', ['a', '**@(/x|/z)', '*.md']);
+      assertParts('foo/(bar|baz)/*.js', ['foo', '(bar|baz)', '*.js']);
+
+      assertParts('XXX/*/*/12/*/*/m/*/*', ['XXX', '*', '*', '12', '*', '*', 'm', '*', '*']);
+      assertParts('foo/\\"**\\"/bar', ['foo', '\\"**\\"', 'bar']);
+    });
   });
 
   describe('.base (glob2base test patterns)', () => {