@putout/plugin-conditions 4.3.0 → 5.0.0

package/README.md

@@ -19,6 +19,7 @@ npm i @putout/plugin-conditions -D
 - ✅ [apply-if](#apply-if);
 - ✅ [convert-comparison-to-boolean](#convert-comparison-to-boolean);
 - ✅ [convert-equal-to-strict-equal](#convert-equal-to-strict-equal);
+- ✅ [convert-arrow-to-condition](#convert-arrow-to-condition);
 - ✅ [evaluate](#evaluate);
 - ✅ [merge-if-statements](#merge-if-statements);
 - ✅ [remove-boolean](#remove-boolean);
@@ -39,6 +40,7 @@ npm i @putout/plugin-conditions -D
         "conditions/add-return": "on",
         "conditions/convert-comparison-to-boolean": "on",
         "conditions/convert-equal-to-strict-equal": "on",
+        "conditions/convert-arrow-to-condition": "on",
         "conditions/evaluate": "on",
         "conditions/remove-boolean": "on",
         "conditions/remove-constant": "on",
@@ -56,7 +58,10 @@ npm i @putout/plugin-conditions -D
 >
 > (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/block)
 
-Check out in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/9035db21bae7b6c76d1dc875d4c74828/07edbfd755060ae263949caf08b31aa43609375a).
+Check out in 🐊**Putout Editor**:
+
+- [Replacer](https://putout.cloudcmd.io/#/gist/9035db21bae7b6c76d1dc875d4c74828/07edbfd755060ae263949caf08b31aa43609375a);
+- [Traverser](https://putout.cloudcmd.io/#/gist/77f84f100d82707925c73c1784f589f2/25923f46973b99f72378104778499ff75b550d2c);
 
 ### ❌ Example of incorrect code
 
@@ -163,6 +168,22 @@ if (a)
     return false;
 ```
 
+## convert-arrow-to-condition
+
+Checkout in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/4d489393cd08dc771c6324eb0bb2e42f/9e85c4b7b7f2d0f82c660c6db618b31270d3a85e).
+
+## ❌ Example of incorrect code
+
+```js
+if ((a) => b) {}
+```
+
+## ✅ Example of correct code
+
+```js
+if (a <= b) {}
+```
+
 ## convert-comparison-to-boolean
 
 > Strict equality compares two values for equality. Neither value is implicitly converted to some other value before being compared. If the values have different types, the values are considered unequal.

package/lib/apply-consistent-blocks/index.js

@@ -1,47 +1,108 @@
 'use strict';
 
-const {types} = require('putout');
+const {types, operator} = require('putout');
+const {replaceWith} = operator;
 const {
     isBlockStatement,
-    isIfStatement,
+    BlockStatement,
 } = types;
 
 module.exports.report = () => `Use consistent blocks`;
 
-const notBlock = ({__b}) => !isBlockStatement(__b);
+module.exports.fix = (path) => {
+    const paths = getAllNodes(path);
+    
+    if (isAllBlocks(paths))
+        for (const path of paths) {
+            if (isBlockStatement(path))
+                continue;
+            
+            const {node} = path;
+            replaceWith(path, BlockStatement([node]));
+        }
+    else
+        for (const path of paths) {
+            if (!isBlockStatement(path))
+                continue;
+            
+            const [node] = path.node.body;
+            replaceWith(path, node);
+        }
+};
 
-module.exports.match = () => ({
-    'if (__a) {__b} else {__c}': () => true,
-    'if (__a) {__b} else __c': () => true,
-    'if (__a) __b; else __body': notBlock,
-    'if (__a) __body; else __b': ({__b}) => !isIfStatement(__b),
-    'if (__a) {__b}': (vars, path) => {
-        const {parentPath} = path;
-        const __bPath = path.get('consequent.body.0');
-        const {
-            leadingComments,
-            trailingComments,
-        } = __bPath.node;
+function isAllBlocks(paths) {
+    const counts = [];
+    
+    for (const path of paths) {
+        const is = isBlockStatement(path);
         
-        if (leadingComments || trailingComments)
-            return false;
-        
-        if (!parentPath.isIfStatement())
+        if (is)
+            counts.push(path.node.body.length);
+        else
+            counts.push(Infinity);
+    }
+    
+    for (const count of counts) {
+        if (count !== 1 && count !== Infinity)
             return true;
-        
-        return path !== parentPath.get('alternate');
-    },
-});
+    }
+    
+    return false;
+}
 
-module.exports.replace = () => ({
-    'if (__a) {if (__b) {__c}}': 'if (__a) if (__b) __c',
-    'if (__a) {__b}': 'if (__a) __b',
-    'if (__a) {__b} else {__c}': 'if (__a) __b; else __c',
-    'if (__a) __b; else __body': 'if (__a) {__b} else __body',
-    'if (__a) __body; else __b': ({__b}, path) => {
-        if (isBlockStatement(__b))
-            return path;
-        
-        return 'if (__a) __body; else {__b}';
-    },
-});
+module.exports.include = () => [
+    'IfStatement',
+];
+
+module.exports.filter = (path) => {
+    if (path === path.parentPath.get('alternate'))
+        return;
+    
+    const nodes = getAllNodes(path);
+    const blocks = [];
+    
+    for (const node of nodes) {
+        const is = isBlockStatement(node);
+        blocks.push(is);
+    }
+    
+    const count = blocks.filter(Boolean).length;
+    
+    if (!count)
+        return false;
+    
+    const couple = [];
+    
+    for (const node of nodes) {
+        const is = isBlockStatement(node) && node.node.body.length > 1;
+        couple.push(is);
+    }
+    
+    const coupleCount = couple.filter(Boolean).length;
+    
+    if (!coupleCount)
+        return true;
+    
+    if (coupleCount === nodes.length)
+        return false;
+    
+    return !(count !== 1 && count === nodes.length);
+};
+
+function getAllNodes(path, nodes = []) {
+    const consequent = path.get('consequent');
+    nodes.push(consequent);
+    
+    if (!path.node.alternate)
+        return nodes;
+    
+    const alternate = path.get('alternate');
+    
+    if (!alternate.isIfStatement())
+        return [
+            ...nodes,
+            alternate,
+        ];
+    
+    return getAllNodes(alternate, nodes);
+}

package/lib/convert-arrow-to-condition/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports.report = () => `Use 'condition' instead of 'arrow function'`;
+
+module.exports.replace = () => ({
+    'if (__a => __b) __c': 'if (__a >= __b) __c',
+});

package/lib/index.js

@@ -13,6 +13,7 @@ const removeUselessElse = require('./remove-useless-else');
 const simplify = require('./simplify');
 const removeSameValuesCondition = require('./remove-same-values-condition');
 const addReturn = require('./add-return');
+const convertArrowToCondition = require('./convert-arrow-to-condition');
 
 module.exports.rules = {
     'apply-comparison-order': applyComparisonOrder,
@@ -28,4 +29,5 @@ module.exports.rules = {
     simplify,
     'remove-same-values-condition': removeSameValuesCondition,
     'add-return': addReturn,
+    'convert-arrow-to-condition': convertArrowToCondition,
 };

package/lib/remove-same-values-condition/index.js

@@ -20,7 +20,7 @@ module.exports.replace = () => ({
 });
 
 const check = (template) => ({__a, __b}, prev) => {
-    while (prev = prev.getPrevSibling(), prev.node) {
+    while ((prev = prev.getPrevSibling(), prev.node)) {
         if (!compare(prev, template))
             continue;
         

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/plugin-conditions",
-  "version": "4.3.0",
+  "version": "5.0.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "🐊Putout plugin adds support of conditions transformations",
@@ -33,18 +33,18 @@
   ],
   "devDependencies": {
     "@putout/plugin-for-of": "*",
-    "@putout/test": "^9.0.0",
-    "c8": "^9.0.0",
+    "@putout/test": "^11.0.0",
+    "c8": "^10.0.0",
     "eslint": "^9.0.0",
     "eslint-plugin-n": "^17.0.0",
-    "eslint-plugin-putout": "^22.0.0",
+    "eslint-plugin-putout": "^23.0.0",
     "lerna": "^6.0.1",
     "madrun": "^10.0.0",
     "montag": "^1.2.1",
     "nodemon": "^3.0.1"
   },
   "peerDependencies": {
-    "putout": ">=33"
+    "putout": ">=36"
   },
   "license": "MIT",
   "engines": {