feature: @putout/compare: add plain compare

Author: coderaiser

packages/compare/lib/comparators/compare-plain.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const {types} = require('@putout/babel');
+const {isObject, isArrays} = require('../is');
+const {comparePrimitives} = require('./compare-primitives');
+
+const {isIdentifier} = types;
+
+module.exports.comparePlain = (node, template, {add}) => {
+    if (!node && node === template)
+        return true;
+    
+    if (!node)
+        return false;
+    
+    if (comparePrimitives(node, template))
+        return true;
+    
+    if (isIdentifier(node) && node.name === template.name)
+        return true;
+    
+    if (isObject(template) && !Array.isArray(template))
+        return add(node, template, {
+            plain: true,
+        });
+    
+    if (isArrays(node, template))
+        return add(node, template, {
+            plain: true,
+        });
+    
+    return false;
+};

packages/compare/lib/comparators/compare-primitives.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const {is} = require('../is');
+
+const isPrimitive = (a) => typeof a !== 'object' || a === null;
+
+module.exports.comparePrimitives = (node, template) => {
+    return isPrimitive(template) && !is(template) && template === node;
+};

packages/compare/lib/compare.js

@@ -9,7 +9,7 @@ const {
     getTemplateValues,
 } = require('./vars');
 
-const {runComparators} = require('./comparators');
+const {runComparators} = require('./run-comparators');
 const {runTopLevelComparators} = require('./top-level-comparators');
 
 const {
@@ -21,14 +21,15 @@ const {
 } = require('./is');
 
 const {extractExpression} = template;
+const addWaterMark = (a) => a;
 
 const {keys} = Object;
 const {isArray} = Array;
 const noop = () => {};
 const isEmptyArray = (a) => isArray(a) && !a.length;
 
 const compareType = (type) => (path) => path.type === type;
-const superPush = (array) => (a, b) => array.push([a, b]);
+const superPush = (array) => (a, b, c = {}) => array.push([a, b, c]);
 const maybeArray = (a) => isArray(a) ? a : [a];
 
 const findParent = (path, type) => {
@@ -71,7 +72,7 @@ function compare(path, template, options = {}, equal = noop) {
     if (!template)
         return false;
 
-    const node = extractExpression(parseNode(path));
+    const node = addWaterMark(extractExpression(parseNode(path)));
     const templateNode = extractExpression(parseNode(template));
 
     equal(node, templateNode);
@@ -114,7 +115,8 @@ module.exports.compareAll = (path, templateNodes, options) => {
     return true;
 };
 
-// @babel/template creates empty array directives// extra duplicate value
+// @babel/template creates empty array directives
+// extra duplicate value
 const ignore = [
     'loc',
     'start',
@@ -141,7 +143,7 @@ function superCompareIterate(node, template) {
     const add = superPush(array);
 
     while (item = array.pop()) {
-        const [node, template] = item;
+        const [node, template, {plain} = {}] = item;
 
         if (!node || isEmptyArray(node) && !isEmptyArray(template))
             return false;
@@ -156,6 +158,7 @@ function superCompareIterate(node, template) {
             const is = runComparators(nodeValue, value, {
                 add,
                 templateStore,
+                plain,
             });
 
             if (!is)

packages/compare/lib/link.js

@@ -40,7 +40,9 @@ module.exports = ({add, value, nodeValue, templateStore}) => {
     if (isIdentifier(templateStore[name]) && isTSTypeReference(nodeValue))
         return true;
 
-    add(templateStore[name], nodeValue);
+    add(templateStore[name], nodeValue, {
+        plain: true,
+    });
 
     return true;
 };

packages/compare/lib/comparators.js packages/compare/lib/run-comparators.jspackages/compare/lib/comparators.js renamed to packages/compare/lib/run-comparators.js

@@ -1,10 +1,11 @@
 'use strict';
 
+const {types} = require('@putout/babel');
+
 const log = require('./log');
 const link = require('./link');
 
 const {
-    is,
     isId,
     isBool,
     isObject,
@@ -29,7 +30,9 @@ const {
     isLinkedRegExp,
 } = require('./is');
 
-const {types} = require('@putout/babel');
+const {comparePlain} = require('./comparators/compare-plain');
+const {comparePrimitives} = require('./comparators/compare-primitives');
+
 const {
     isClassBody,
     isBlock,
@@ -38,15 +41,14 @@ const {
 } = types;
 
 const isEmptyBlock = (a) => isBlock(a) && !a.body.length;
-const isPrimitive = (a) => typeof a !== 'object' || a === null;
 
 const second = (f) => (a, b) => f(b);
 
 const comparators = [
+    comparePrimitives,
     compareTemplateElements,
     compareJSXTexts,
     compareAny,
-    comparePrimitives,
     second(isClassBody),
     second(isEmptyBlock),
     second(isAny),
@@ -70,12 +72,17 @@ const comparators = [
     compareArrays,
 ];
 
-module.exports.runComparators = (node, template, {add, templateStore}) => {
+module.exports.runComparators = (node, template, {add, templateStore, plain}) => {
     let i = -1;
     const n = comparators.length;
 
     log(template, node);
 
+    if (plain)
+        return comparePlain(node, template, {
+            add,
+        });
+    
     while (++i < n) {
         const compare = comparators[i];
 
@@ -90,10 +97,6 @@ function compareAny(node, template) {
     return template === '__';
 }
 
-function comparePrimitives(node, template) {
-    return isPrimitive(template) && !is(template) && template === node;
-}
-
 function compareArrays(node, template, {add}) {
     const is = isArrays(node, template);
 
@@ -115,7 +118,7 @@ function compareTemplateElements(node, template) {
 }
 
 function linkNodes(node, template, {add, templateStore}) {
-    if (node && isLinkedNode(template, node) || isLinkedArgs(template) || isLinkedId(node, template) || isLinkedBool(node, template))
+    if (node && isLinkedNode(template) || isLinkedArgs(template) || isLinkedId(node, template) || isLinkedBool(node, template))
         return link({
             add,
             value: template,

packages/compare/test/compare.js

@@ -943,6 +943,7 @@ test('compare: typescript: arrow function type: no args', (t) => {
 test('compare: __args__a', (t) => {
     const node = '((a) => fn(42))(value)';
     const template = '((__args__a) => __c(__args__a))(__args__b)';
+    
     const result = compare(node, template);
 
     t.notOk(result);
@@ -1007,6 +1008,41 @@ test('compare: TSMappedType', (t) => {
     t.end();
 });
 
+test('compare: different template values', (t) => {
+    const result = compare('__b.body.length === 1 && __c.body.length === 1', '__a && __a');
+    
+    t.notOk(result);
+    t.end();
+});
+
+test('compare: different template values: literals', (t) => {
+    const result = compare(`isNameStr('__a') && isNameStr('__b')`, '__a && __a');
+    
+    t.notOk(result);
+    t.end();
+});
+
+test('compareAny: node is null', (t) => {
+    const result = compareAny('a => isIdentifier(a, {\n  name: BODY\n})', ['(__args__a) => __a.__b(__args__a)', '(__args__a) => {__a.__b(__args__a)}']);
+    
+    t.notOk(result);
+    t.end();
+});
+
+test('compare: same member expressions', (t) => {
+    const result = compare('hello.world && hello.world && ls && hello.world', '__a && __a && __b && __a');
+    
+    t.ok(result);
+    t.end();
+});
+
+test('compare: different literals', (t) => {
+    const result = compare('/.tsx?$/.test(name) || /{tsx?}$/.test(name)', '__a || __a');
+    
+    t.notOk(result);
+    t.end();
+});
+
 function getProgramPath(str) {
     let result;
     const ast = parse(str);