feature: @putout/engine-runner: replace: couple: run fix only after match

Author: coderaiser

packages/engine-runner/lib/replace/find-path.js

@@ -16,10 +16,13 @@ module.exports = (parentPath) => {
 
     return path.join('.');
 };
+
 function findKey(path, parent) {
     const {node} = path;
+    let key;
+    let value;
 
-    for (const [key, value] of entries(parent)) {
+    for ([key, value] of entries(parent)) {
         if (isArray(value)) {
             const index = value.indexOf(node);
 
@@ -30,6 +33,8 @@ function findKey(path, parent) {
         }
 
         if (value === node)
-            return key;
+            break;
     }
+    
+    return key;
 }

packages/engine-runner/lib/replace/index.js

@@ -59,7 +59,7 @@ module.exports = ({rule, plugin, msg, options}) => {
         options,
     });
 
-    const fix = getFix(replaceItems);
+    const fix = getFix(replaceItems, plugin.match, options);
     const include = packKeys(replaceItems);
 
     return {
@@ -96,9 +96,6 @@ const fix = (from, to, path) => {
     if (mark.has())
         return;
 
-    if (!compare(path, nodeFrom, {findUp: false}))
-        return;
-    
     const waysFrom = findVarsWays(nodeFrom);
     const {node} = path;
 
@@ -138,9 +135,21 @@ const fix = (from, to, path) => {
     log(from, newPath);
 };
 
-const getFix = (items) => (path) => {
-    for (const [from, to] of entries(items))
-        fix(from, to, path);
+const getFix = (items, match = stubMatch, options) => (path) => {
+    const initedMatch = match({
+        options,
+    });
+    
+    for (const [from, to] of entries(items)) {
+        const nodeFrom = template.ast(from);
+        
+        if (compare(path, nodeFrom, {findUp: false})) {
+            const matchFn = initedMatch[from];
+            
+            if (!matchFn || runMatch(path, nodeFrom, matchFn))
+                fix(from, to, path);
+        }
+    }
 };
 
 const getFilter = (match = stubMatch, options) => (path) => {
@@ -151,25 +160,29 @@ const getFilter = (match = stubMatch, options) => (path) => {
     for (const [from, matchProperty] of all) {
         const nodeFrom = template.ast(from);
 
-        if (!compare(path.node, nodeFrom))
+        if (!compare(path.node, nodeFrom, {findUp: false}))
             continue;
 
-        const waysFrom = findVarsWays(nodeFrom);
-        const {node} = path;
-        
-        const values = getValues({
-            waysFrom,
-            node,
-        });
-        
-        validateMatchProperty(matchProperty);
-        
-        return matchProperty(values, path);
+        return runMatch(path, nodeFrom, matchProperty);
     }
 
     return true;
 };
 
+function runMatch(path, nodeFrom, matchProperty) {
+    const waysFrom = findVarsWays(nodeFrom);
+    const {node} = path;
+    
+    const values = getValues({
+        waysFrom,
+        node,
+    });
+    
+    validateMatchProperty(matchProperty);
+    
+    return matchProperty(values, path);
+}
+
 function parseTo(to, values, path) {
     const toStr = isFn(to) ? to(values, path) : to;
 

packages/engine-runner/lib/replace/watermark.js

@@ -11,7 +11,7 @@ const hasWatermark = (watermark) => (path) => path.node?.[name]?.has(watermark);
 
 module.exports = (from, to, path) => {
     const {watermark, highWatermark} = create(from, to, path);
-    const program = path.findParent(isProgram) || path;
+    const program = path.findParent(isProgram);
     const options = {
         watermark,
         highWatermark,

packages/engine-runner/test/replace.js

@@ -16,6 +16,7 @@ const {print, types} = putout;
 const {
     StringLiteral,
     ReturnStatement,
+    isStringLiteral,
 } = types;
 
 const readFixture = (a) => readFileSync(join(__dirname, 'fixture', `${a}.js`), 'utf8');
@@ -1006,3 +1007,93 @@ test('putout: runner: replace: callstack', (t) => {
     t.equal(code, expected);
     t.end();
 });
+
+test('putout: runner: replace: match: double', (t) => {
+    const convert = {
+        report: noop,
+        match: () => ({
+            'createDirectory(__a, __b)': ({__b}) => {
+                if (!isStringLiteral(__b))
+                    return false;
+                
+                return __b.value.includes('/');
+            },
+            'createNestedDirectory(__a, __b)': ({__b}) => {
+                if (!isStringLiteral(__b))
+                    return false;
+                
+                return !__b.value.includes('/');
+            },
+        }),
+        replace: () => ({
+            'createDirectory(__a, __b)': 'createNestedDirectory(__a, __b)',
+            'createNestedDirectory(__a, __b)': 'createDirectory(__a, __b)',
+        }),
+    };
+    
+    const source = montag`
+        const dirPath = createDirectory(path, '/hello/world');
+    `;
+    
+    const {code} = putout(source, {
+        runPlugins,
+        plugins: [
+            ['convert', convert],
+        ],
+    });
+    
+    const expected = montag`
+        const dirPath = createNestedDirectory(path, '/hello/world');\n
+    `;
+    
+    t.equal(code, expected);
+    t.end();
+});
+
+test('putout: runner: replace: match: couple checks', (t) => {
+    const convert = {
+        report: noop,
+        match: () => ({
+            'createDirectory(__a, __b)': ({__b}) => {
+                if (!isStringLiteral(__b))
+                    return false;
+                
+                return __b.value.includes('/');
+            },
+            'createNestedDirectory(__a, __b)': ({__b}) => {
+                if (!isStringLiteral(__b))
+                    return false;
+                
+                return !__b.value.includes('/');
+            },
+        }),
+        replace: () => ({
+            '!__a in __b': '!(__a in __b)',
+            '__a in !__b': '!(__a in __b)',
+            '!__a in !__b': '!(__a in __b)',
+        }),
+    };
+    
+    const source = montag`
+        !a in b;
+        a in !b;
+        !a in !b;
+    `;
+    
+    const {code} = putout(source, {
+        runPlugins,
+        plugins: [
+            ['convert', convert],
+        ],
+    });
+    
+    const expected = montag`
+        !(a in b);
+        !(a in b);
+        !(a in b);
+    
+    `;
+    
+    t.equal(code, expected);
+    t.end();
+});