feature: @putout/plugin-regexp: remove-useless-group: transformRegExp

Author: coderaiser

packages/plugin-regexp/lib/remove-duplicates-from-character-class/fixture/class-range.js

@@ -0,0 +1 @@
+/[a-zA-Z]/g

packages/plugin-regexp/lib/remove-duplicates-from-character-class/index.spec.js

@@ -16,3 +16,8 @@ test('regexp: remove-duplicates-from-character-class: transform', (t) => {
     t.transform('remove-duplicates-from-character-class');
     t.end();
 });
+
+test('regexp: remove-duplicates-from-character-class: no report: class-range', (t) => {
+    t.noReport('class-range');
+    t.end();
+});

packages/plugin-regexp/lib/remove-duplicates-from-character-class/regexp.js

@@ -1,3 +1,5 @@
+const isChar = ({type}) => type === 'Char';
+
 export const report = () => 'Remove duplicates from character class';
 export const fix = ({path, j}) => delete path.node.expressions[j];
 export const traverse = ({push}) => ({
@@ -12,6 +14,9 @@ export const traverse = ({push}) => ({
                 if (!a || !b)
                     continue;
 
+                if (!isChar(a) || !isChar(b))
+                    continue;
+                
                 if (a.value === b.value)
                     push({
                         j,

packages/plugin-regexp/lib/remove-useless-group/index.js

@@ -1,11 +1,10 @@
-import regexpTree from 'regexp-tree';
 import {operator} from 'putout';
-import {
-    isDisjunction,
-    isParentDisjunction,
-} from '../types.js';
+import * as regexp from './regexp.js';
 
-const {compare} = operator;
+const {
+    compare,
+    transformRegExp,
+} = operator;
 
 export const report = ({from, to}) => `Remove useless group from RegExp ${from}, use ${to}`;
 
@@ -32,73 +31,22 @@ export const traverse = ({push}) => ({
             return;
 
         const from = path.node.extra.raw;
-        const [is, to] = removeUselessGroup(from);
+        const [to, places] = transformRegExp(from, regexp);
 
-        if (is)
-            push({
-                path,
-                from,
-                to,
-            });
+        if (!places.length)
+            return;
+        
+        push({
+            path,
+            from,
+            to,
+        });
     },
 });
 
-function removeUselessGroup(str) {
-    const ast = regexpTree.parse(str);
-    let is = false;
-    
-    regexpTree.traverse(ast, {
-        Group(path) {
-            const {type} = path.parent;
-            
-            if (!/RegExp|Alternative/.test(type))
-                return;
-            
-            const nextNode = getNextSibling(path);
-            
-            if (nextNode?.type === 'Repetition')
-                return;
-            
-            const {node} = path;
-            
-            if (node.name)
-                return;
-            
-            if (!node.expression)
-                return;
-            
-            if (isParentDisjunction(path))
-                return;
-            
-            if (isDisjunction(node.expression))
-                return;
-            
-            is = true;
-            path.replace(node.expression);
-        },
-    });
-    
-    return [is, regexpTree.generate(ast)];
-}
-
 function includes({parentPath}) {
     if (compare(parentPath.parentPath, '/__a/.test(__b)'))
         return true;
 
     return compare(parentPath, '__.search(/__a/)');
 }
-
-function getNextSibling(path) {
-    let found = false;
-    const {expressions = []} = path.parent;
-    
-    for (const current of expressions) {
-        if (found)
-            return current;
-        
-        if (current === path.node)
-            found = true;
-    }
-    
-    return null;
-}

packages/plugin-regexp/lib/remove-useless-group/regexp.js

@@ -0,0 +1,58 @@
+import {
+    isDisjunction,
+    isParentDisjunction,
+} from '../types.js';
+
+export const report = () => 'Remove useless group';
+
+export const fix = ({path, node}) => {
+    path.replace(node.expression);
+};
+
+export const traverse = ({push}) => ({
+    Group(path) {
+        const {type} = path.parent;
+        
+        if (!/RegExp|Alternative/.test(type))
+            return;
+        
+        const nextNode = getNextSibling(path);
+        
+        if (nextNode?.type === 'Repetition')
+            return;
+        
+        const {node} = path;
+        
+        if (node.name)
+            return;
+        
+        if (!node.expression)
+            return;
+        
+        if (isParentDisjunction(path))
+            return;
+        
+        if (isDisjunction(node.expression))
+            return;
+        
+        push({
+            path,
+            node,
+        });
+    },
+});
+
+function getNextSibling(path) {
+    let found = false;
+    const {expressions = []} = path.parent;
+    
+    for (const current of expressions) {
+        if (found)
+            return current;
+        
+        if (current === path.node)
+            found = true;
+    }
+    
+    return null;
+}