feat: Add prefer-array-from rule. Fixes #3

Author: freaktechnik

README.md

@@ -4,6 +4,21 @@
 
 Rules for Array functions and methods.
 
+## Contents
+ - [Installation](#Installation)
+ - [Rules](#Rules)
+   - [`from-map`](#from-map)
+     - [Examples](#Examples)
+   - [`no-unnecessary-this-arg`](#no-unnecessary-this-arg)
+     - [Checked Functions](#checked-functions)
+     - [Checked Methods](#checked-methods)
+     - [Examples](#Examples2)
+   - [`prefer-array-from`](#prefer-array-from)
+     - [Examples](#Examples3)
+ - [`array-func/recommended` Configuration](#array-func-recommended-configuration)
+   - [Using the Configuration](#using-the-configuration)
+ - [License](#License)
+
 ## Installation
 
 Install [ESLint](https://www.github.com/eslint/eslint) either locally or globally.
@@ -52,10 +67,10 @@ The `this` parameter is useless when providing arrow functions, since the `this`
 
 The fix is usually to omit the parameter. The Array methods can't be auto-fixed, since the detection of array methods is not confident enough to know that the method is being called on an array.
 
-#### Checked functions
+#### Checked Functions
  - `from` (fixable)
 
-#### Checked methods
+#### Checked Methods
  - `every`
  - `filter`
  - `find`
@@ -112,15 +127,40 @@ array.forEach(function(char) {
 array.filter(this.isGood, this);
 ```
 
+### `prefer-array-from`
+Use `Array.from` instead of `[...iterable]` for performance benefits.
+
+This rule is auto fixable.
+
+#### Examples
+Code that triggers this rule:
+```js
+const iterable = [..."string"];
+
+const arrayCopy = [...iterable];
+```
+
+Code that doesn't trigger this rule:
+```js
+const array = [1, 2, 3];
+
+const extendedArray =  [0, ...array];
+
+const arrayCopy = Array.from(array);
+
+const characterArray = Array.from("string");
+```
+
 ## `array-func/recommended` Configuration
 The recommended configuration will set your parser ECMA Version to 2015, since that's when the Array functions and methods were added.
 
-Rule | Error level
----- | -----------
-`from-map` | Error
-`no-unnecessary-this-arg` | Error
+Rule | Error level | Fixable
+---- | ----------- | -------
+`from-map` | Error | Yes
+`no-unnecessary-this-arg` | Error | Sometimes
+`prefer-array-from` | Error | Yes
 
-### Using the configuration
+### Using the Configuration
 To enable this configuration use the `extends` property in your `.eslintrc.json` config file (may look different for other config file styles):
 ```json
 {

index.js

@@ -7,7 +7,8 @@
 module.exports = {
     rules: {
         "from-map": require("./rules/from-map"),
-        "no-unnecessary-this-arg": require("./rules/no-unnecessary-this-arg")
+        "no-unnecessary-this-arg": require("./rules/no-unnecessary-this-arg"),
+        "prefer-array-from": require("./rules/prefer-array-from")
     },
     configs: {
         recommended: {
@@ -17,7 +18,8 @@ module.exports = {
             plugins: [ 'array-func' ],
             rules: {
                 "array-func/from-map": "error",
-                "array-func/no-unnecessary-this-arg": "error"
+                "array-func/no-unnecessary-this-arg": "error",
+                "array-func/prefer-array-from": "error"
             }
         }
     }

lib/helpers/call-expression.js

@@ -0,0 +1,18 @@
+/**
+ * @author Martin Giger
+ * @license MIT
+ */
+"use strict";
+
+const {
+    MEMBER_EXPRESSION,
+    IDENTIFIER
+} = require("../type");
+
+// Helper functions for call expression nodes.
+
+exports.isMethod = (node, name) => "callee" in node && node.callee.type === MEMBER_EXPRESSION && node.callee.property.name === name;
+
+exports.getParent = (node) => node.callee.object;
+
+exports.isOnObject = (node, name) => "object" in node.callee && node.callee.object.type === IDENTIFIER && node.callee.object.name === name;

lib/type.js

@@ -0,0 +1,10 @@
+/**
+ * @author Martin Giger
+ * @license MIT
+ */
+"use strict";
+
+exports.MEMBER_EXPRESSION = "MemberExpression";
+exports.ARROW_FUNCTION_EXPRESSION = "ArrowFunctionExpression";
+exports.IDENTIFIER = "Identifier";
+exports.SPREAD_ELEMENT = "SpreadElement";

rules/prefer-array-from.js

@@ -0,0 +1,42 @@
+/**
+ * @author Martin Giger
+ * @license MIT
+ */
+"use strict";
+
+const { SPREAD_ELEMENT } = require("../lib/type");
+
+const SINGLE_ELEMENT = 1,
+    firstElement = (arr) => {
+        const [ el ] = arr;
+        return el;
+    };
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "Prefer using Array.from over spreading an interable in an array literal.",
+            recommended: true
+        },
+        schema: [],
+        fixable: "code"
+    },
+    create(context) {
+        return {
+            "ArrayExpression:exit"(node) {
+                if(node.elements.length !== SINGLE_ELEMENT || firstElement(node.elements).type !== SPREAD_ELEMENT) {
+                    return;
+                }
+                context.report({
+                    node,
+                    loc: node.loc,
+                    message: "Use Array.from to convert from iterable to array",
+                    fix(fixer) {
+                        const sourceCode = context.getSourceCode();
+                        return fixer.replaceText(node, `Array.from(${sourceCode.getText(firstElement(node.elements).argument)})`);
+                    }
+                });
+            }
+        };
+    }
+};

test/helpers-call-expression.js

@@ -0,0 +1,76 @@
+import test from 'ava';
+import { isMethod, getParent, isOnObject } from '../lib/helpers/call-expression';
+import { MEMBER_EXPRESSION, IDENTIFIER } from '../lib/type';
+
+test('is method', (t) => {
+    const name = "test";
+    t.true(isMethod({
+        callee: {
+            type: MEMBER_EXPRESSION,
+            property: {
+                name
+            }
+        }
+    }, name));
+});
+
+test('not is method', (t) => {
+    const name = 'test';
+    t.false(isMethod({}, name));
+    t.false(isMethod({
+        callee: {
+            type: IDENTIFIER,
+            property: {
+                name
+            }
+        }
+    }, name));
+    t.false(isMethod({
+        callee: {
+            type: MEMBER_EXPRESSION,
+            property: {
+                name: 'foo'
+            }
+        }
+    }));
+});
+
+test('get parent', (t) => {
+    const parent = 'foo';
+    t.is(getParent({
+        callee: {
+            object: parent
+        }
+    }), parent);
+});
+
+test('is on object', (t) => {
+    const name = 'test';
+    t.true(isOnObject({
+        callee: {
+            object: {
+                type: IDENTIFIER,
+                name
+            }
+        }
+    }, name));
+});
+
+test('is not on object', (t) => {
+    const name = 'test';
+    t.false(isOnObject({
+        callee: {}
+    }, name));
+    t.false(isOnObject({
+        callee: {
+            type: MEMBER_EXPRESSION,
+            name
+        }
+    }, name));
+    t.false(isOnObject({
+        callee: {
+            type: IDENTIFIER,
+            name: 'foo'
+        }
+    }, name));
+});

test/rules/prefer-array-from.js

@@ -0,0 +1,50 @@
+import test from 'ava';
+import AvaRuleTester from 'eslint-ava-rule-tester';
+import rule from '../../rules/prefer-array-from';
+
+const ruleTester = new AvaRuleTester(test, {
+    parserOptions: {
+        ecmaVersion: 2015
+    }
+});
+
+const message = "Use Array.from to convert from iterable to array";
+
+ruleTester.run('from-map', rule, {
+    valid: [
+        'Array.from(new Set())',
+        'Array.from(iterable)',
+        '[1, ...iterable]',
+        '[1, 2, 3]',
+        '[iterable]'
+    ],
+    invalid: [
+        {
+            code: '[...iterable]',
+            errors: [ {
+                message,
+                column: 1,
+                line: 1
+            } ],
+            output: 'Array.from(iterable)'
+        },
+        {
+            code: '[...[1, 2]]',
+            errors: [ {
+                message,
+                column: 1,
+                line: 1
+            } ],
+            output: 'Array.from([1, 2])'
+        },
+        {
+            code: '[..."test"]',
+            errors: [ {
+                message,
+                column: 1,
+                line: 1
+            } ],
+            output: 'Array.from("test")'
+        }
+    ]
+});

test/type.js

@@ -0,0 +1,23 @@
+import test from 'ava';
+import {
+    SPREAD_ELEMENT,
+    ARROW_FUNCTION_EXPRESSION,
+    MEMBER_EXPRESSION,
+    IDENTIFIER
+} from '../lib/type';
+
+test('Spread element', (t) => {
+    t.is(SPREAD_ELEMENT, "SpreadElement");
+});
+
+test('Arrow function expression', (t) => {
+    t.is(ARROW_FUNCTION_EXPRESSION, "ArrowFunctionExpression");
+});
+
+test('Member expression', (t) => {
+    t.is(MEMBER_EXPRESSION, "MemberExpression");
+});
+
+test('Identifier', (t) => {
+    t.is(IDENTIFIER, "Identifier");
+});