Tests

Author: slevithan

spec/recursion-spec.js

@@ -2,6 +2,70 @@ import {regex} from 'regex';
 import {recursion} from '../src/index.js';
 
 describe('recursion', () => {
+  it('should throw for invalid and unsupported recursion depths', () => {
+    const values = ['-2', '0', '1', '+2', '2.5', '101', 'a', null];
+    for (const value of values) {
+      expect(() => regex({plugins: [recursion]})({raw: [`a(?R=${value})?b`]})).toThrow();
+      expect(() => regex({plugins: [recursion]})({raw: [`(?<r>a\\g<r&R=${value}>?b)`]})).toThrow();
+    }
+  });
+
+  it('should allow recursion depths 2-100', () => {
+    const values = ['2', '100'];
+    for (const value of values) {
+      expect(() => regex({plugins: [recursion]})({raw: [`a(?R=${value})?b`]})).not.toThrow();
+      expect(() => regex({plugins: [recursion]})({raw: [`(?<r>a\\g<r&R=${value}>?b)`]})).not.toThrow();
+    }
+  });
+
+  it('should match global recursion', () => {
+    expect(regex({plugins: [recursion]})`a(?R=2)?b`.exec('aabb')?.[0]).toBe('aabb');
+  });
+
+  it('should match direct recursion', () => {
+    expect('aabb').toMatch(regex({plugins: [recursion]})`^(?<r>a\g<r&R=2>?b)$`);
+    expect('aab').not.toMatch(regex({plugins: [recursion]})`^(?<r>a\g<r&R=2>?b)$`);
+  });
+
+  it('should throw for multiple direct, overlapping recursions', () => {
+    expect(() => regex({plugins: [recursion]})`a(?R=2)?(?<r>a\g<r&R=2>?)`).toThrow();
+    expect(() => regex({plugins: [recursion]})`(?<r>a\g<r&R=2>?\g<r&R=2>?)`).toThrow();
+  });
+
+  it('should throw for multiple direct, nonoverlapping recursions', () => {
+    // TODO: Has a bug and lets invalid JS syntax through
+    expect(() => regex({plugins: [recursion]})`(?<r1>a\g<r1&R=2>?)(?<r2>a\g<r2&R=2>?)`).toThrow();
+  });
+
+  it('should throw for indirect recursion', () => {
+    expect(() => regex({plugins: [recursion]})`(?<a>(?<b>a\g<a&R=2>?)\g<b&R=2>)`).toThrow();
+    expect(() => regex({plugins: [recursion]})`(?<a>\g<b&R=2>(?<b>a\g<a&R=2>?))`).toThrow();
+    expect(() => regex({plugins: [recursion]})`(?<a>\g<b&R=2>)(?<b>a\g<a&R=2>?)`).toThrow();
+    expect(() => regex({plugins: [recursion]})`\g<a&R=2>(?<a>\g<b&R=2>)(?<b>a\g<a&R=2>?)`).toThrow();
+    expect(() => regex({plugins: [recursion]})`(?<a>\g<b&R=2>)(?<b>\g<c&R=2>)(?<c>a\g<a&R=2>?)`).toThrow();
+  });
+
+  it('should not adjust named backreferences referring outside of the recursed expression', () => {
+    expect('aababbabcc').toMatch(regex({plugins: [recursion]})`^(?<a>a)\k<a>(?<r>(?<b>b)\k<a>\k<b>\k<c>\g<r&R=2>?)(?<c>c)\k<c>$`);
+  });
+
+  // Just documenting current behavior; this could be supported in the future
+  it('should throw for numbered backreferences in interpolated regexes when using recursion', () => {
+    expect(() => regex({plugins: [recursion]})`a(?R=2)?b${/()\1/}`).toThrow();
+    expect(() => regex({plugins: [recursion]})`(?<n>a|\g<n&R=2>${/()\1/})`).toThrow();
+    expect(() => regex({plugins: [recursion]})`(?<n>a|\g<n&R=2>)${/()\1/}`).toThrow();
+    expect(() => regex({plugins: [recursion]})`${/()\1/}a(?R=2)?b`).toThrow();
+    expect(() => regex({plugins: [recursion]})`(?<n>${/()\1/}a|\g<n&R=2>)`).toThrow();
+    expect(() => regex({plugins: [recursion]})`${/()\1/}(?<n>a|\g<n&R=2>)`).toThrow();
+  });
+
+  it('should throw for subroutine definition groups when using recursion', () => {
+    expect(() => regex({plugins: [recursion]})`a(?R=2)?b(?(DEFINE))`).toThrow();
+    expect(() => regex({plugins: [recursion]})`(?<n>a|\g<n&R=2>)(?(DEFINE))`).toThrow();
+  });
+});
+
+describe('readme examples', () => {
   it('should match an equal number of two different subpatterns', () => {
     expect(regex({plugins: [recursion]})`a(?R=50)?b`.exec('test aaaaaabbb')[0]).toBe('aaabbb');
     expect('aAbb').toMatch(regex({flags: 'i', plugins: [recursion]})`a(?R=2)?b`);
@@ -50,23 +114,4 @@ describe('recursion', () => {
     \b`;
     expect('Racecar, ABBA, and redivided'.match(palindromeWords)).toEqual(['Racecar', 'ABBA']);
   });
-
-  it('should not adjust named backreferences referring outside of the recursed expression', () => {
-    expect('aababbabcc').toMatch(regex({plugins: [recursion]})`^(?<a>a)\k<a>(?<r>(?<b>b)\k<a>\k<b>\k<c>\g<r&R=2>?)(?<c>c)\k<c>$`);
-  });
-
-  // Just documenting current behavior; this could be supported in the future
-  it('should not allow numbered backreferences in interpolated regexes when using recursion', () => {
-    expect(() => regex({plugins: [recursion]})`a(?R=2)?b${/()\1/}`).toThrow();
-    expect(() => regex({plugins: [recursion]})`(?<n>a|\g<n&R=2>${/()\1/})`).toThrow();
-    expect(() => regex({plugins: [recursion]})`(?<n>a|\g<n&R=2>)${/()\1/}`).toThrow();
-    expect(() => regex({plugins: [recursion]})`${/()\1/}a(?R=2)?b`).toThrow();
-    expect(() => regex({plugins: [recursion]})`(?<n>${/()\1/}a|\g<n&R=2>)`).toThrow();
-    expect(() => regex({plugins: [recursion]})`${/()\1/}(?<n>a|\g<n&R=2>)`).toThrow();
-  });
-
-  it('should not allow subroutine definition groups when using recursion', () => {
-    expect(() => regex({plugins: [recursion]})`a(?R=2)?b(?(DEFINE))`).toThrow();
-    expect(() => regex({plugins: [recursion]})`(?<n>a|\g<n&R=2>)(?(DEFINE))`).toThrow();
-  });
 });

src/index.js

@@ -1,7 +1,7 @@
 import {Context, forEachUnescaped, getGroupContents, hasUnescaped, replaceUnescaped} from 'regex-utilities';
 
-const gRToken = String.raw`\\g<(?<gRName>[^>&]+)&R=(?<gRDepth>\d+)>`;
-const recursiveToken = String.raw`\(\?R=(?<rDepth>\d+)\)|${gRToken}`;
+const gRToken = String.raw`\\g<(?<gRName>[^>&]+)&R=(?<gRDepth>[^>]+)>`;
+const recursiveToken = String.raw`\(\?R=(?<rDepth>[^\)]+)\)|${gRToken}`;
 const namedCapturingDelim = String.raw`\(\?<(?![=!])(?<captureName>[^>]+)>`;
 const token = new RegExp(String.raw`${namedCapturingDelim}|${recursiveToken}|\\?.`, 'gsu');
 
@@ -45,16 +45,16 @@ export function recursion(expression) {
         groupContentsStartPos.set(captureName, token.lastIndex);
       // (?R=N)
       } else if (rDepth) {
+        assertMaxInBounds(rDepth);
         const maxDepth = +rDepth;
-        assertMaxInBounds(maxDepth);
         const pre = expression.slice(0, match.index);
         const post = expression.slice(token.lastIndex);
         assertNoFollowingRecursion(post);
         return makeRecursive(pre, post, maxDepth, false);
       // \g<name&R=N>
       } else if (gRName) {
+        assertMaxInBounds(gRDepth);
         const maxDepth = +gRDepth;
-        assertMaxInBounds(maxDepth);
         const outsideOwnGroupMsg = `Recursion via \\g<${gRName}&R=${gRDepth}> must be used within the referenced group`;
         // Appears before/outside the referenced group
         if (!groupContentsStartPos.has(gRName)) {
@@ -82,11 +82,16 @@ export function recursion(expression) {
 }
 
 /**
-@param {number} max
+@param {string} max
 */
 function assertMaxInBounds(max) {
+  const errMsg = `Max depth must be integer between 2 and 100; used ${max}`;
+  if (!/^[1-9]\d*$/.test(max)) {
+    throw new Error(errMsg);
+  }
+  max = +max;
   if (max < 2 || max > 100) {
-    throw new Error(`Max depth must be between 2 and 100; used ${max}`);
+    throw new Error(errMsg);
   }
 }