Merge pull request #8 from ramda/specialized-names

Support for specialized functions
ramda · Nov 16, 2017 · 673071b · 673071b
2 parents 8a7e469 + ffb3234
commit 673071b
Show file tree

Hide file tree

Showing 39 changed files with 630 additions and 4,057 deletions.
diff --git a/ast-helper.js b/ast-helper.js
@@ -0,0 +1,38 @@
+'use strict';
+const R = require('ramda');
+
+// :: Node -> String
+const getName = R.ifElse(
+    R.propEq('type', 'MemberExpression'),
+    R.path(['property', 'name']),
+    R.prop('name')
+);
+
+// :: String -> Node -> Boolean
+const isRamdaMethod = name => R.either(
+    R.whereEq({
+        type: 'Identifier',
+        name
+    }),
+    R.where({
+        type: R.equals('MemberExpression'),
+        object: R.whereEq({ type: 'Identifier', name: 'R' }),
+        property: R.either(
+            R.whereEq({ type: 'Identifier', name }),
+            R.whereEq({ type: 'Literal', value: name })
+        )
+    })
+);
+
+// :: { name :: String, arguments :: [Node] -> Boolean }
+// -> Object
+// -> Boolean
+const isCalling = pattern => R.where({
+    type: R.equals('CallExpression'),
+    callee: isRamdaMethod(pattern.name),
+    arguments: pattern.arguments || R.T
+});
+
+exports.isRamdaMethod = isRamdaMethod;
+exports.isCalling = isCalling;
+exports.getName = getName;
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-ramda",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "ESLint rules for use with Ramda",
   "license": "MIT",
   "keywords": [
@@ -22,6 +22,7 @@
   },
   "dependencies": {
     "create-eslint-index": "^1.0.0",
+    "ramda": "0.25.0",
     "req-all": "^1.0.0"
   },
   "devDependencies": {
@@ -40,6 +41,7 @@
   },
   "files": [
     "index.js",
+    "ast-helper.js",
     "rules/",
     "LICENSE",
     "README.md"

diff --git a/rules/any-pass-simplification.js b/rules/any-pass-simplification.js
@@ -1,24 +1,27 @@
 'use strict';
+const R = require('ramda');
+const isCalling = require('../ast-helper').isCalling;
 
 const create = context => ({
     CallExpression(node) {
-        if (node.callee.type === 'Identifier'
-            && node.callee.name === 'anyPass'
-            && node.arguments.length > 0
-            && node.arguments[0].type === 'ArrayExpression') {
-            const elements = node.arguments[0].elements;
-            const negated = elements
-                .filter(element =>
-                    element.type === 'CallExpression'
-                    && element.callee.type === 'Identifier'
-                    && element.callee.name === 'complement'
-                );
-            if (elements.length === negated.length) {
-                context.report({
-                    node,
-                    message: '`anyPass` containing only complement functions should be a complement of `allPass`'
-                });
-            }
+        const match = isCalling({
+            name: 'anyPass',
+            arguments: R.both(
+                R.propSatisfies(R.lt(0), 'length'),
+                R.where({
+                    0: R.both(
+                        R.propEq('type', 'ArrayExpression'),
+                        R.propSatisfies(R.all(isCalling({ name: 'complement' })), 'elements')
+                    )
+                })
+            )
+        });
+
+        if (match(node)) {
+            context.report({
+                node,
+                message: '`anyPass` containing only complement functions should be a complement of `allPass`'
+            });
         }
     }
 });

diff --git a/rules/both-simplification.js b/rules/both-simplification.js
@@ -1,17 +1,22 @@
 'use strict';
+const R = require('ramda');
+const isCalling = require('../ast-helper').isCalling;
 
 const create = context => ({
     CallExpression(node) {
-        if (node.callee.type === 'Identifier'
-            && node.callee.name === 'both'
-            && node.arguments.length > 1
-            && node.arguments[0].type === 'CallExpression'
-            && node.arguments[1].type === 'CallExpression'
-            && node.arguments[0].callee.type === 'Identifier'
-            && node.arguments[1].callee.type === 'Identifier'
-            && node.arguments[0].callee.name === 'complement'
-            && node.arguments[1].callee.name === 'complement'
-            && node.arguments) {
+        const match = isCalling({
+            name: 'both',
+            arguments: R.ifElse(
+                R.propSatisfies(R.lt(1), 'length'),
+                R.where({
+                    0: isCalling({ name: 'complement' }),
+                    1: isCalling({ name: 'complement' })
+                }),
+                R.F
+            )
+        });
+
+        if (match(node)) {
             context.report({
                 node,
                 message: '`both(complement(_), complement(_))` should be simplified to `complement(either(_, _))`'

diff --git a/rules/complement-simplification.js b/rules/complement-simplification.js
@@ -1,26 +1,37 @@
 'use strict';
+const R = require('ramda');
+const ast = require('../ast-helper');
+
+const isCalling = ast.isCalling;
+const isRamdaMethod = ast.isRamdaMethod;
+const getName = ast.getName;
+
+const names = {
+    or: 'and',
+    and: 'or',
+    T: 'F',
+    F: 'T'
+};
 
 const create = context => ({
     CallExpression(node) {
-        if (node.callee.type === 'Identifier'
-            && node.callee.name === 'complement'
-            && node.arguments.length > 0
-            && node.arguments[0].type === 'Identifier') {
-            const name = node.arguments[0].name;
-            const replacementTable = {
-                or: 'and',
-                and: 'or',
-                T: 'F',
-                F: 'T'
-            };
+        const match = isCalling({
+            name: 'complement',
+            arguments: R.both(
+                R.propSatisfies(R.lt(0), 'length'),
+                R.where({
+                    0: R.anyPass(R.map(isRamdaMethod, R.keys(names)))
+                })
+            )
+        });
 
-            const expected = replacementTable[name];
-            if (expected) {
-                context.report({
-                    node,
-                    message: `\`complement(${name})\` should be simplified to \`${expected}\``
-                });
-            }
+        if (match(node)) {
+            const name = getName(node.arguments[0]);
+            const expected = names[name];
+            context.report({
+                node,
+                message: `\`complement(${name})\` should be simplified to \`${expected}\``
+            });
         }
     }
 });

diff --git a/rules/cond-simplification.js b/rules/cond-simplification.js
@@ -1,12 +1,23 @@
 'use strict';
+const R = require('ramda');
+const isCalling = require('../ast-helper').isCalling;
 
 const create = context => ({
     CallExpression(node) {
-        if (node.callee.type === 'Identifier'
-            && node.callee.name === 'cond'
-            && node.arguments.length > 0
-            && node.arguments[0].type === 'ArrayExpression'
-            && node.arguments[0].elements.length <= 2) {
+        const match = isCalling({
+            name: 'cond',
+            arguments: R.both(
+                R.propSatisfies(R.lt(0), 'length'),
+                R.where({
+                    0: R.both(
+                        R.propEq('type', 'ArrayExpression'),
+                        R.pathSatisfies(R.gte(2), ['elements', 'length'])
+                    )
+                })
+            )
+        });
+
+        if (match(node)) {
             context.report({
                 node,
                 message: '`cond` with too few parameters should be `ifElse`, `either` or `both`'

diff --git a/rules/either-simplification.js b/rules/either-simplification.js
@@ -1,17 +1,22 @@
 'use strict';
+const R = require('ramda');
+const isCalling = require('../ast-helper').isCalling;
 
 const create = context => ({
     CallExpression(node) {
-        if (node.callee.type === 'Identifier'
-            && node.callee.name === 'either'
-            && node.arguments.length > 1
-            && node.arguments[0].type === 'CallExpression'
-            && node.arguments[1].type === 'CallExpression'
-            && node.arguments[0].callee.type === 'Identifier'
-            && node.arguments[1].callee.type === 'Identifier'
-            && node.arguments[0].callee.name === 'complement'
-            && node.arguments[1].callee.name === 'complement'
-            && node.arguments) {
+        const match = isCalling({
+            name: 'either',
+            arguments: R.ifElse(
+                R.propSatisfies(R.lt(1), 'length'),
+                R.where({
+                    0: isCalling({ name: 'complement' }),
+                    1: isCalling({ name: 'complement' })
+                }),
+                R.F
+            )
+        });
+
+        if (match(node)) {
             context.report({
                 node,
                 message: '`either(complement(_), complement(_))` should be simplified to `complement(both(_, _))`'

diff --git a/rules/filter-simplification.js b/rules/filter-simplification.js
@@ -1,13 +1,20 @@
 'use strict';
+const R = require('ramda');
+const isCalling = require('../ast-helper').isCalling;
 
 const create = context => ({
     CallExpression(node) {
-        if (node.callee.type === 'Identifier'
-            && node.callee.name === 'filter'
-            && node.arguments.length > 0
-            && node.arguments[0].type === 'CallExpression'
-            && node.arguments[0].callee.type === 'Identifier'
-            && node.arguments[0].callee.name === 'complement') {
+        const match = isCalling({
+            name: 'filter',
+            arguments: R.both(
+                R.propSatisfies(R.lt(0), 'length'),
+                R.propSatisfies(isCalling({
+                    name: 'complement'
+                }), 0)
+            )
+        });
+
+        if (match(node)) {
             context.report({
                 node,
                 message: '`filter(complement(_))` should be simplified to `reject(_)`'

diff --git a/rules/if-else-simplification.js b/rules/if-else-simplification.js
@@ -1,25 +1,40 @@
 'use strict';
+const R = require('ramda');
+const ast = require('../ast-helper');
+
+const isCalling = ast.isCalling;
+const isRamdaMethod = ast.isRamdaMethod;
 
 const create = context => ({
     CallExpression(node) {
-        if (node.callee.type === 'Identifier'
-            && node.callee.name === 'ifElse'
-            && node.arguments.length >= 2) {
-            const second = node.arguments[1].name;
+        const matchUnless = isCalling({
+            name: 'ifElse',
+            arguments: R.both(
+                R.propSatisfies(R.lte(2), 'length'),
+                R.propSatisfies(isRamdaMethod('identity'), 1)
+            )
+        });
+
+        const matchWhen = isCalling({
+            name: 'ifElse',
+            arguments: R.both(
+                R.propSatisfies(R.lte(3), 'length'),
+                R.propSatisfies(isRamdaMethod('identity'), 2)
+            )
+        });
 
-            if (second === 'identity') {
-                context.report({
-                    node,
-                    message: '`ifElse(_, identity, _)` should be simplified to `unless(_, _)`'
-                });
-            }
+        if (matchUnless(node)) {
+            context.report({
+                node,
+                message: '`ifElse(_, identity, _)` should be simplified to `unless(_, _)`'
+            });
+        }
 
-            if (node.arguments[2] && node.arguments[2].name === 'identity') {
-                context.report({
-                    node,
-                    message: '`ifElse(_, _, identity)` should be simplified to `when(_, _)`'
-                });
-            }
+        if (matchWhen(node)) {
+            context.report({
+                node,
+                message: '`ifElse(_, _, identity)` should be simplified to `when(_, _)`'
+            });
         }
     }
 });

diff --git a/rules/map-simplification.js b/rules/map-simplification.js
@@ -1,13 +1,20 @@
 'use strict';
+const R = require('ramda');
+const isCalling = require('../ast-helper').isCalling;
 
 const create = context => ({
     CallExpression(node) {
-        if (node.callee.type === 'Identifier'
-            && node.callee.name === 'map'
-            && node.arguments.length > 0
-            && node.arguments[0].type === 'CallExpression'
-            && node.arguments[0].callee.type === 'Identifier'
-            && node.arguments[0].callee.name === 'prop') {
+        const match = isCalling({
+            name: 'map',
+            arguments: R.both(
+                R.propSatisfies(R.lt(0), 'length'),
+                R.propSatisfies(isCalling({
+                    name: 'prop'
+                }), 0)
+            )
+        });
+
+        if (match(node)) {
             context.report({
                 node,
                 message: '`map(prop(_))` should be simplified to `pluck(_)`'