@putout/plugin-conditions 2.2.0 → 3.0.0

package/README.md

@@ -23,7 +23,9 @@ npm i @putout/plugin-conditions -D
         "conditions/evaluate": "on",
         "conditions/remove-boolean": "on",
         "conditions/remove-constant": "on",
-        "conditions/remove-zero": "on"
+        "conditions/remove-zero": "on",
+        "conditions/remove-useless-else": "on",
+        "conditions/merge-if-statements": "on"
     }
 }
 ```
@@ -195,7 +197,7 @@ if (b) {}
 
 ## simplify
 
-## ❌ Example of incorrect code
+### ❌ Example of incorrect code
 
 ```js
 if (zone?.tooltipCallback) {
@@ -208,7 +210,7 @@ else
     alert('hello');
 ```
 
-## ✅ Example of correct code
+### ✅ Example of correct code
 
 ```js
 zone?.tooltipCallback(e);
@@ -216,6 +218,67 @@ zone?.tooltipCallback(e);
 alert('hello');
 ```
 
+## merge-if-statements
+
+> The `if` statement executes a statement `if` a specified condition is truthy.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if...else)
+
+### ❌ Example of incorrect code
+
+```js
+if (a > b) {
+    if (b < c) {
+        console.log('hello');
+    }
+}
+```
+
+### ✅ Example of correct code
+
+```js
+if (a > b && b < c) {
+    console.log('hello');
+}
+```
+
+## remove-useless-else
+
+> You can skip the `else` block if your `if` block always executes a `return` statement, it makes code a lot easier to read.
+>
+> (c) [no else return](https://www.samanthaming.com/tidbits/23-no-else-return/)
+
+Remove useless `else` before:
+
+- `return`;
+- `continue`;
+- `break`;
+
+### ❌ Example of incorrect code
+
+```js
+if (x)
+    return;
+else
+    console.log();
+```
+
+### ✅ Example of correct code
+
+```js
+if (x)
+    return;
+
+console.log();
+```
+
+### Comparison
+
+Linter | Rule | Fix
+--------|-------|------------|
+🐊 **Putout** | [`conditions/remove-useless-else`](https://github.com/coderaiser/putout/tree/master/packages/plugin-remove-debugger#readme) | ✅
+⏣ **ESLint** | [`no-else-return`](https://eslint.org/docs/rules/no-else-return) | ✅
+
 ## License
 
 MIT

package/lib/apply-if/index.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const {replaceWith} = require('putout').operator;
+const {operator} = require('putout');
+const {remove, replaceWith} = operator;
 
 module.exports.report = () => 'Avoid empty statement in if condition';
 
@@ -24,5 +25,5 @@ module.exports.fix = (path) => {
     const consequentPath = path.get('consequent');
     
     replaceWith(consequentPath, nextPath);
-    nextPath.remove();
+    remove(nextPath);
 };

package/lib/index.js

@@ -1,16 +1,25 @@
 'use strict';
 
-const getRule = (a) => ({
-    [a]: require(`./${a}`),
-});
+const applyComparisonOrder = require('./apply-comparison-order');
+const applyIf = require('./apply-if');
+const evaluate = require('./evaluate');
+const convertComparisonToBoolean = require('./convert-comparison-to-boolean');
+const convertEqualToStrictEqual = require('./convert-equal-to-strict-equal');
+const mergeIfStatements = require('./merge-if-statements');
+const removeBoolean = require('./remove-boolean');
+const removeZero = require('./remove-zero');
+const removeUselessElse = require('./remove-useless-else');
+const simplify = require('./simplify');
 
 module.exports.rules = {
-    ...getRule('apply-comparison-order'),
-    ...getRule('apply-if'),
-    ...getRule('evaluate'),
-    ...getRule('convert-comparison-to-boolean'),
-    ...getRule('convert-equal-to-strict-equal'),
-    ...getRule('remove-boolean'),
-    ...getRule('remove-zero'),
-    ...getRule('simplify'),
+    'apply-comparison-order': applyComparisonOrder,
+    'apply-if': applyIf,
+    evaluate,
+    'convert-comparison-to-boolean': convertComparisonToBoolean,
+    'convert-equal-to-strict-equal': convertEqualToStrictEqual,
+    'merge-if-statements': mergeIfStatements,
+    'remove-boolean': removeBoolean,
+    'remove-zero': removeZero,
+    'remove-useless-else': removeUselessElse,
+    simplify,
 };

package/lib/merge-if-statements/index.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const {types, operator} = require('putout');
+
+const {replaceWith} = operator;
+const {LogicalExpression} = types;
+
+module.exports.report = () => `Merge 'if' statements`;
+
+module.exports.fix = ({path, consequentPath}) => {
+    const testPath = path.get('test');
+    const left = testPath.node;
+    const right = consequentPath.node.test;
+    
+    replaceWith(testPath, LogicalExpression('&&', left, right));
+    
+    replaceWith(path.get('consequent'), consequentPath.get('consequent'));
+};
+
+const getConsequent = (path) => {
+    const consequentPath = path.get('consequent');
+    
+    if (consequentPath.isIfStatement())
+        return consequentPath;
+    
+    const {node} = consequentPath;
+    
+    if (!consequentPath.isBlock() || node.body.length > 1)
+        return;
+    
+    const resultPath = consequentPath.get('body.0');
+    const {body} = consequentPath.node;
+    
+    if (body.length && resultPath.isIfStatement())
+        return resultPath;
+    
+    return null;
+};
+
+module.exports.traverse = ({push}) => ({
+    'if (__) __': onIfStatement({
+        push,
+    }),
+});
+
+const onIfStatement = ({push}) => (path) => {
+    const consequentPath = getConsequent(path);
+    
+    if (!consequentPath)
+        return;
+    
+    if (consequentPath.node.alternate)
+        return;
+    
+    push({
+        path,
+        consequentPath,
+    });
+};

package/lib/remove-useless-else/index.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const {
+    isReturnStatement,
+    isBlockStatement,
+    isContinueStatement,
+    isBreakStatement,
+} = require('putout').types;
+
+module.exports.report = () => `Avoid useless 'else'`;
+
+module.exports.match = () => ({
+    'if (__a) __b; else __c': ({__b}) => {
+        if (!isBlockStatement(__b))
+            return isReturnLike(__b);
+        
+        const latest = __b.body.at(-1);
+        
+        return isReturnLike(latest);
+    },
+});
+
+module.exports.replace = () => ({
+    'if (__a) __b; else __c': `{
+        if (__a) __b;
+        __c;
+    }`,
+});
+
+function isReturnLike(node) {
+    if (isReturnStatement(node))
+        return true;
+    
+    if (isContinueStatement(node))
+        return true;
+    
+    return isBreakStatement(node);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/plugin-conditions",
-  "version": "2.2.0",
+  "version": "3.0.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "🐊Putout plugin adds support of conditions transformations",
@@ -37,14 +37,14 @@
     "c8": "^8.0.0",
     "eslint": "^8.0.1",
     "eslint-plugin-n": "^16.0.0",
-    "eslint-plugin-putout": "^18.0.0",
+    "eslint-plugin-putout": "^19.0.0",
     "lerna": "^6.0.1",
     "madrun": "^9.0.0",
     "montag": "^1.2.1",
     "nodemon": "^3.0.1"
   },
   "peerDependencies": {
-    "putout": ">=30"
+    "putout": ">=32"
   },
   "license": "MIT",
   "engines": {