[patch] simplify pseudo greps before converting to regular expression (#31)

Author: mmisty

.github/workflows/build.yml

@@ -63,7 +63,7 @@ jobs:
         run: npm run cov:show
 
       - name: Archive code coverage results
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: code-coverage-report
           path: ./reports/coverage-full-total/

src/utils/regexp.ts

@@ -1,13 +1,24 @@
 type Replacement = { order: number; mapName: string; exp: string; inverse: boolean };
 
+export const simplifyParentheses = (input: string): string => {
+  // Replace deeply nested parentheses with a single group
+  let simplified = input;
+
+  while (/\(\(([^()]+)\)\)/.test(simplified)) {
+    simplified = simplified.replace(/\(\(([^()]+)\)\)/, '($1)');
+  }
+
+  return simplified.replace(/&\(\.\*\)/g, '');
+};
+
 /**
  * replace all parenthesis groups with placeholder
  * @param input
  * @param replacements
  * @param num
  */
-const replaceParenthesisGroups = (input: string, replacements: Replacement[], num = 1): string => {
-  let replaced = input;
+export const replaceParenthesisGroups = (input: string, replacements: Replacement[], num = 1): string => {
+  let replaced = simplifyParentheses(input);
   const groupsNeg = input.match(/!\(([^()]*)\)/);
   const groups = input.match(/\(([^()]*)\)/);
 
@@ -26,6 +37,10 @@ const replaceParenthesisGroups = (input: string, replacements: Replacement[], nu
   if (groupsNeg) {
     return replaceExpression(groupsNeg[0], groupsNeg[1], true);
   } else if (groups) {
+    if (replaced === '(.*)') {
+      return '';
+    }
+
     return replaceExpression(groups[0], groups[1], false);
   }
 
@@ -37,7 +52,7 @@ const replaceParenthesisGroups = (input: string, replacements: Replacement[], nu
  * @param exp
  * @param inverse
  */
-const convertOneGroup = (exp: string, inverse: boolean): string => {
+export const convertOneGroup = (exp: string, inverse: boolean): string => {
   const reg = exp
     .split('/')
     .map(t => (t.startsWith('!') ? t.replace(/^!(.*)/, '^(?!.*$1.*)') : t))
@@ -83,6 +98,7 @@ export const selectionTestGrep = (str: string): RegExp => {
     });
 
   convertedString = convertedString
+    .replace(/\.\*\.\*/g, '.*')
     .replace(new RegExp(leftParenth, 'g'), '\\(')
     .replace(new RegExp(rightParenth, 'g'), '\\)');
 

tests/test-folder/regexp.test.ts

@@ -1,4 +1,4 @@
-import { selectionTestGrep } from '../../src/utils/regexp';
+import { convertOneGroup, selectionTestGrep, simplifyParentheses } from '../../src/utils/regexp';
 import expect from 'expect';
 
 describe('suite', () => {
@@ -68,7 +68,7 @@ describe('suite', () => {
         {
           desc: 'parenthesis several more complex - many parent parenthesis',
           GREP: '((((((.*)&!((my test)|(his test))&(.*))))))',
-          regExpected: /(?=.*.*)+(?=.*^(?!.*(my test|his test).*))+(?=.*.*)+.*/i,
+          regExpected: /(?=.*)+(?=.*^(?!.*(my test|his test).*))+.*/i,
           cases: [
             { expectMatch: true, testLine: 'test her' },
             { expectMatch: true, testLine: 'her test' },
@@ -376,6 +376,23 @@ describe('suite', () => {
             { expectMatch: false, testLine: '@otherTest' },
           ],
         },
+        {
+          desc: 'simplify regexp',
+          GREP: '(.*)&((((.*))))',
+          regExpected: /.*/i,
+          cases: [{ expectMatch: true, testLine: '@test sdd @test2 dsd' }],
+        },
+        {
+          desc: 'simplify regexp',
+          GREP: '((((((((((((((@V1&!@V2)&(.*)))&(.*)))&(.*)))&(@V1&!@V2)))&(.*)))&(.*))))', // '(@V1&!@V2)&(@V1&!@V2)',
+          regExpected: /(?=.*(?=.*@V1)+^(?!.*@V2.*)+)+(?=.*(?=.*@V1)+^(?!.*@V2.*)+)+.*/i,
+          cases: [
+            { expectMatch: false, testLine: '@V1 sdd @V2 dsd' },
+            { expectMatch: false, testLine: '@V2 sdd @V1 dsd' },
+            { expectMatch: true, testLine: '@V1 sdd  dsd' },
+            { expectMatch: false, testLine: '@V3 sdd  dsd' },
+          ],
+        },
       ])
       .each(t => t.cases)
       // .only(t => t.id === '1')
@@ -395,4 +412,94 @@ describe('suite', () => {
         }
       });
   });
+
+  it('should simplify expression', () => {
+    const grep = '(.*)&((((.*))))';
+    const regActual = selectionTestGrep(grep);
+
+    expect(regActual).toEqual(/.*/i);
+  });
+
+  describe('simplifyParentheses', () => {
+    it('simplifyParentheses 1', () => {
+      const grep = '(.*)&((((.*))))';
+      expect(simplifyParentheses(grep)).toEqual('(.*)');
+    });
+
+    it('simplifyParentheses 2', () => {
+      const grep = '(.*)&((((.*))))&((((something))))';
+      expect(simplifyParentheses(grep)).toEqual('(.*)&(something)');
+    });
+
+    it('simplifyParentheses 3', () => {
+      const grep = '(.*)&((((.*))))&((((something))))';
+      expect(simplifyParentheses(grep)).toEqual('(.*)&(something)');
+    });
+
+    it('simplifyParentheses 4', () => {
+      const grep = '(.*)&((((.*))))&(((((A)&(B|(V&D))))))&((((something))))';
+      expect(simplifyParentheses(grep)).toEqual('(.*)&(((((A)&(B|(V&D))))))&(something)');
+    });
+
+    it('simplifyParentheses incorrect', () => {
+      const grep = '(.*)&((((.*))))&((((something)))))';
+      expect(simplifyParentheses(grep)).toEqual('(.*)&(something))');
+    });
+  });
+
+  describe('simplify expression', () => {
+    it('should simplify expression 1', () => {
+      const grep = '(.*)&((((.*))))';
+      const regActual = selectionTestGrep(grep);
+
+      expect(regActual).toEqual(/.*/i);
+    });
+
+    it('should simplify expression 2', () => {
+      const grep = '(A)&((((C))))';
+      const regActual = selectionTestGrep(grep);
+
+      expect(regActual).toEqual(/(?=.*A)+(?=.*C)+.*/i);
+    });
+
+    it('should simplify expression - groups inside parenthesis', () => {
+      const grep = '(.*)&((((.*))))&(((((A)&(B|(V&D))))))&((((something))))';
+      const regActual = selectionTestGrep(grep);
+
+      expect(regActual).toEqual(/(?=.*)+(?=.*(?=.*A)+(?=.*(B|(?=.*V)+(?=.*D)+))+)+(?=.*something)+.*/i);
+      expect(regActual.test('A')).toEqual(false);
+      expect(regActual.test('A gogo B else something')).toEqual(true);
+      expect(regActual.test('B gogo A else something')).toEqual(true);
+      expect(regActual.test('V gogo A else something D')).toEqual(true);
+      expect(regActual.test('V gogo A else something')).toEqual(false);
+      expect(regActual.test('X')).toEqual(false);
+    });
+
+    it('should simplify expression 4', () => {
+      const grep = '(.*)&((((.*))))&((((something))))';
+      const regActual = selectionTestGrep(grep);
+
+      expect(regActual).toEqual(/(?=.*)+(?=.*something)+.*/i);
+    });
+  });
+
+  describe('convertOneGroup', () => {
+    it('convertOneGroup 1', () => {
+      const grep = '.*';
+      const regActual = convertOneGroup(grep, false);
+      expect(regActual).toEqual('.*');
+    });
+
+    it('convertOneGroup 2 - or', () => {
+      const grep = 'A|C';
+      const regActual = convertOneGroup(grep, false);
+      expect(regActual).toEqual('(A|C)');
+    });
+
+    it('convertOneGroup 3 - and', () => {
+      const grep = 'A&C';
+      const regActual = convertOneGroup(grep, false);
+      expect(regActual).toEqual('(?=.*A)+(?=.*C)+');
+    });
+  });
 });