eslint-plugin-chai-friendly 0.3.5 → 0.5.0

package/.editorconfig

@@ -0,0 +1,12 @@
+; EditorConfig file: https://EditorConfig.org
+; Install the "EditorConfig" plugin into your editor to use
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true

package/.eslintignore

@@ -0,0 +1 @@
+node_modules

package/.eslintrc.js

@@ -0,0 +1,6 @@
+module.exports = {
+  extends: ['eslint:recommended'],
+  env: {
+    node: true
+  }
+};

package/README.md

@@ -1,33 +1,38 @@
 # eslint-plugin-chai-friendly
 
-This plugin overrides `no-unused-expressions` to make it friendly towards chai expect statements.
+[![npm](https://img.shields.io/npm/v/eslint-plugin-chai-friendly.svg)](https://www.npmjs.com/package/eslint-plugin-chai-friendly) [![npm](https://img.shields.io/npm/dm/eslint-plugin-chai-friendly.svg)](https://www.npmjs.com/package/eslint-plugin-chai-friendly)
+
+This plugin overrides `no-unused-expressions` to make it friendly towards chai `expect` and `should` statements.
+
 ```javascript
 // this
 expect(foo).to.be.true;
+foo.should.be.true;
 
 // instead of this
 expect(foo).to.be.true; // eslint-disable-line no-unused-expressions
+foo.should.be.true; // eslint-disable-line no-unused-expressions
 ```
 
 ## Installation
 
 You'll first need to install [ESLint](http://eslint.org):
 
-```
-$ npm i eslint --save-dev
+```bash
+npm i eslint --save-dev
 ```
 
 Next, install `eslint-plugin-chai-friendly`:
 
-```
-$ npm install eslint-plugin-chai-friendly --save-dev
+```bash
+npm install eslint-plugin-chai-friendly --save-dev
 ```
 
 **Note:** If you installed ESLint globally (using the `-g` flag) then you must also install `eslint-plugin-chai-friendly` globally.
 
 ## Usage
 
-Add `chai-friendly` to the plugins section of your `.eslintrc` configuration file. You can omit the `eslint-plugin-` prefix:
+Add `chai-friendly` to the plugins section of your `.eslintrc.*` configuration file. You can omit the `eslint-plugin-` prefix:
 
 ```json
 {
@@ -49,11 +54,28 @@ Then disable original `no-unused-expressions` rule and configure chai-friendly r
 }
 ```
 
-## Supported Rules
+If you don't need to tweak the above rule settings, you can instead
+just add the following to your config file's `extends` and the above
+will be applied automatically:
+
+```json
+{
+  "extends": ["plugin:chai-friendly/recommended"]
+}
+```
+
+## Options
 
-* chai-friendly/no-unused-expressions
+This rule, in its default state, does not require any arguments. If you would like to enable one or more of the following you may pass an object with the options set as follows:
 
+- `allowShortCircuit` set to `true` will allow you to use short circuit evaluations in your expressions (Default: `false`).
+- `allowTernary` set to `true` will enable you to use ternary operators in your expressions similarly to short circuit evaluations (Default: `false`).
+- `allowTaggedTemplates` set to `true` will enable you to use tagged template literals in your expressions (Default: `false`).
 
+These options allow unused expressions only if all of the code paths either directly change the state (for example, assignment statement) or could have side effects (for example, function call).
 
+More info in the original rule's [docs](http://eslint.org/docs/rules/no-unused-expressions#options).
 
+## Supported Rules
 
+- `chai-friendly/no-unused-expressions`

package/lib/index.js

@@ -5,10 +5,16 @@
 "use strict";
 
 module.exports = {
+  configs: {
+    recommended: {
+      plugins: ['chai-friendly'],
+      rules: {
+        'chai-friendly/no-unused-expressions': 'error',
+        'no-unused-expressions': 'off'
+      }
+    }
+  },
   rules: {
     'no-unused-expressions': require('./rules/no-unused-expressions')
   }
 };
-
-
-

package/lib/rules/no-unused-expressions.js

@@ -26,6 +26,9 @@ module.exports = {
                     },
                     allowTernary: {
                         type: "boolean"
+                    },
+                    allowTaggedTemplates: {
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false
@@ -35,7 +38,9 @@ module.exports = {
     create: function (context) {
         var config = context.options[0] || {},
             allowShortCircuit = config.allowShortCircuit || false,
-            allowTernary = config.allowTernary || false;
+            allowTernary = config.allowTernary || false,
+            allowTaggedTemplates = config.allowTaggedTemplates || false;
+
 
         /**
          * @param {ASTNode} node - any node
@@ -101,6 +106,10 @@ module.exports = {
                 }
             }
 
+            if (allowTaggedTemplates && node.type === "TaggedTemplateExpression") {
+                return true;
+            }
+
             return /^(?:Assignment|Call|New|Update|Yield|Await)Expression$/.test(node.type) ||
                 (node.type === "UnaryExpression" && ["delete", "void"].indexOf(node.operator) >= 0);
         }
@@ -111,7 +120,7 @@ module.exports = {
          * @param {ASTNode} node - any node
          * @returns {boolean} whether the given node is a chai expectation
          */
-        function isChaiExpectation(node) {
+        function isChaiExpectCall(node) {
             var expression = node.expression;
             if (expression.type !== 'MemberExpression') {
                 return false;
@@ -143,15 +152,59 @@ module.exports = {
 
             // Stop search, expect(...) not found
             return null;
-        };
+        }
+
+        /**
+         * Determines whether or not a given node is a chai's should statement.
+         * e.g. foo.should.eventually.be.true;
+         * @param {ASTNode} node - any node
+         * @returns {boolean} whether the given node is a chai should statement
+         */
+        function isChaiShouldCall(node) {
+            var expression = node.expression;
+            if (expression.type !== 'MemberExpression') {
+                return false;
+            }
+
+            var hasShouldCall = Boolean(findShouldCall(expression.object));
+
+            return hasShouldCall;
+        }
+
+        /**
+         * Searches for the chai obj.should call down the AST.
+         * @param {ASTNode} node - any node
+         * @returns {ASTNode} obj.should call expression or null
+         */
+        function findShouldCall(node) {
+            // Found obj.should call, return the node
+            if (node.type === 'MemberExpression' && node.property && node.property.name === 'should') {
+                return node;
+            }
+
+            // Continue search up the AST if it's a member call
+            if (node.type === 'MemberExpression') {
+                return findShouldCall(node.object);
+            }
+            if (node.type === 'CallExpression') {
+                return findShouldCall(node.callee);
+            }
+
+            // Stop search, obj.should not found
+            return null;
+        }
 
 
         return {
             ExpressionStatement: function(node) {
-                if (!isValidExpression(node.expression) && !isDirective(node, context.getAncestors()) && !isChaiExpectation(node)) {
+                var valid = isValidExpression(node.expression)
+                    || isDirective(node, context.getAncestors())
+                    || isChaiExpectCall(node)
+                    || isChaiShouldCall(node);
+                if (!valid) {
                     context.report(node, "Expected an assignment or function call and instead saw an expression.");
                 }
             }
         };
     }
-};
+};

package/lib/rules/og-rule.js

@@ -0,0 +1,126 @@
+/**
+ * @fileoverview Flag expressions in statement position that do not side effect
+ * @author Michael Ficarra
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow unused expressions",
+            category: "Best Practices",
+            recommended: false
+        },
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    allowShortCircuit: {
+                        type: "boolean"
+                    },
+                    allowTernary: {
+                        type: "boolean"
+                    },
+                    allowTaggedTemplates: {
+                        type: "boolean"
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+
+    create(context) {
+        const config = context.options[0] || {},
+            allowShortCircuit = config.allowShortCircuit || false,
+            allowTernary = config.allowTernary || false,
+            allowTaggedTemplates = config.allowTaggedTemplates || false;
+
+        /**
+         * @param {ASTNode} node - any node
+         * @returns {boolean} whether the given node structurally represents a directive
+         */
+        function looksLikeDirective(node) {
+            return node.type === "ExpressionStatement" &&
+                node.expression.type === "Literal" && typeof node.expression.value === "string";
+        }
+
+        /**
+         * @param {Function} predicate - ([a] -> Boolean) the function used to make the determination
+         * @param {a[]} list - the input list
+         * @returns {a[]} the leading sequence of members in the given list that pass the given predicate
+         */
+        function takeWhile(predicate, list) {
+            for (let i = 0; i < list.length; ++i) {
+                if (!predicate(list[i])) {
+                    return list.slice(0, i);
+                }
+            }
+            return list.slice();
+        }
+
+        /**
+         * @param {ASTNode} node - a Program or BlockStatement node
+         * @returns {ASTNode[]} the leading sequence of directive nodes in the given node's body
+         */
+        function directives(node) {
+            return takeWhile(looksLikeDirective, node.body);
+        }
+
+        /**
+         * @param {ASTNode} node - any node
+         * @param {ASTNode[]} ancestors - the given node's ancestors
+         * @returns {boolean} whether the given node is considered a directive in its current position
+         */
+        function isDirective(node, ancestors) {
+            const parent = ancestors[ancestors.length - 1],
+                grandparent = ancestors[ancestors.length - 2];
+
+            return (parent.type === "Program" || parent.type === "BlockStatement" &&
+                    (/Function/.test(grandparent.type))) &&
+                    directives(parent).indexOf(node) >= 0;
+        }
+
+        /**
+         * Determines whether or not a given node is a valid expression. Recurses on short circuit eval and ternary nodes if enabled by flags.
+         * @param {ASTNode} node - any node
+         * @returns {boolean} whether the given node is a valid expression
+         */
+        function isValidExpression(node) {
+            if (allowTernary) {
+
+                // Recursive check for ternary and logical expressions
+                if (node.type === "ConditionalExpression") {
+                    return isValidExpression(node.consequent) && isValidExpression(node.alternate);
+                }
+            }
+
+            if (allowShortCircuit) {
+                if (node.type === "LogicalExpression") {
+                    return isValidExpression(node.right);
+                }
+            }
+
+            if (allowTaggedTemplates && node.type === "TaggedTemplateExpression") {
+                return true;
+            }
+
+            return /^(?:Assignment|Call|New|Update|Yield|Await)Expression$/.test(node.type) ||
+                (node.type === "UnaryExpression" && ["delete", "void"].indexOf(node.operator) >= 0);
+        }
+
+        return {
+            ExpressionStatement(node) {
+                if (!isValidExpression(node.expression) && !isDirective(node, context.getAncestors())) {
+                    context.report({ node, message: "Expected an assignment or function call and instead saw an expression." });
+                }
+            }
+        };
+
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-chai-friendly",
-  "version": "0.3.5",
+  "version": "0.5.0",
   "description": "This plugin makes 'no-unused-expressions' rule friendly towards chai expect statements.",
   "keywords": [
     "eslint",
@@ -18,8 +18,12 @@
     "url": "https://github.com/ihordiachenko/eslint-plugin-chai-friendly/issues"
   },
   "author": "Ihor Diachenko",
+  "contributors": [
+    "Brett Zamir"
+  ],
   "main": "lib/index.js",
   "scripts": {
+    "lint": "eslint .",
     "test": "mocha tests --recursive"
   },
   "dependencies": {},
@@ -27,8 +31,8 @@
     "eslint": ">=3.0.0"
   },
   "devDependencies": {
-    "eslint": "~3.11.0",
-    "mocha": "^3.0.2"
+    "eslint": "~6.6.0",
+    "mocha": "^6.2.2"
   },
   "engines": {
     "node": ">=0.10.0"

package/tests/lib/rules/no-unused-expressions.js

@@ -27,16 +27,16 @@ ruleTester.run("no-unused-expressions", rule, {
         "f(); g()",
         "i++",
         "a()",
-        { code: "a && a()", options: [{ allowShortCircuit: true }] },
-        { code: "a() || (b = c)", options: [{ allowShortCircuit: true }] },
-        { code: "a ? b() : c()", options: [{ allowTernary: true }] },
-        { code: "a ? b() || (c = d) : e()", options: [{ allowShortCircuit: true, allowTernary: true }] },
+        { code: "a && a()", options: [{ allowShortCircuit: true }]},
+        { code: "a() || (b = c)", options: [{ allowShortCircuit: true }]},
+        { code: "a ? b() : c()", options: [{ allowTernary: true }]},
+        { code: "a ? b() || (c = d) : e()", options: [{ allowShortCircuit: true, allowTernary: true }]},
         "delete foo.bar",
         "void new C",
         "\"use strict\";",
         "\"directive one\"; \"directive two\"; f();",
         "function foo() {\"use strict\"; return true; }",
-        { code: "var foo = () => {\"use strict\"; return true; }", parserOptions: { ecmaVersion: 6 } },
+        { code: "var foo = () => {\"use strict\"; return true; }", parserOptions: { ecmaVersion: 6 }},
         "function foo() {\"directive one\"; \"directive two\"; f(); }",
         "function foo() { var foo = \"use strict\"; return true; }",
         {
@@ -61,33 +61,77 @@ ruleTester.run("no-unused-expressions", rule, {
             options: [{ allowTernary: true }],
             parserOptions: { ecmaVersion: 8 }
         },
-        "expect(foo).to.be.ok",
-        "expect(foo).be.ok",
-        "expect(foo).to.eventually().be.ok"
+        {
+            code: "tag`tagged template literal`",
+            options: [{ allowTaggedTemplates: true }],
+            parserOptions: { ecmaVersion: 6 }
+        },
+        {
+            code: "shouldNotBeAffectedByAllowTemplateTagsOption()",
+            options: [{ allowTaggedTemplates: true }],
+            parserOptions: { ecmaVersion: 6 }
+        },
+        // Chai statements
+        "expect(foo).to.be.true;",
+        "expect(foo).to.have.a.property('bar').which.is.true",
+        "foo.should.be.true;",
+        "foo.inner.nested.should.be.true",
+        "foo.should.have.a.property('bar').which.is.true;"
     ],
     invalid: [
-        { code: "0", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "a", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "f(), 0", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "{0}", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "[]", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "a && b();", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "a() || false", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement" }] },
-        { code: "a || (b = c)", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement" }] },
-        { code: "a ? b() || (c = d) : e", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement" }] },
+        { code: "0", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "a", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "f(), 0", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "{0}", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "[]", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "a && b();", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "a() || false", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement" }]},
+        { code: "a || (b = c)", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement" }]},
+        { code: "a ? b() || (c = d) : e", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement" }]},
         { code: "a && b()", options: [{ allowTernary: true }], errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement" }]},
         { code: "a ? b() : c()", options: [{ allowShortCircuit: true }], errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement" }]},
-        { code: "a || b", options: [{ allowShortCircuit: true }], errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "a() && b", options: [{ allowShortCircuit: true }], errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "a ? b : 0", options: [{ allowTernary: true }], errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "a ? b : c()", options: [{ allowTernary: true }], errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "foo.bar;", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "!a", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "+a", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "\"directive one\"; f(); \"directive two\";", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "function foo() {\"directive one\"; f(); \"directive two\"; }", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "if (0) { \"not a directive\"; f(); }", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "function foo() { var foo = true; \"use strict\"; }", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] },
-        { code: "var foo = () => { var foo = true; \"use strict\"; }", parserOptions: { ecmaVersion: 6 }, errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}] }
+        { code: "a || b", options: [{ allowShortCircuit: true }], errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "a() && b", options: [{ allowShortCircuit: true }], errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "a ? b : 0", options: [{ allowTernary: true }], errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "a ? b : c()", options: [{ allowTernary: true }], errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "foo.bar;", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "!a", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "+a", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "\"directive one\"; f(); \"directive two\";", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "function foo() {\"directive one\"; f(); \"directive two\"; }", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "if (0) { \"not a directive\"; f(); }", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "function foo() { var foo = true; \"use strict\"; }", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        { code: "var foo = () => { var foo = true; \"use strict\"; }", parserOptions: { ecmaVersion: 6}, errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement"}]},
+        {
+            code: "`untagged template literal`",
+            options: [{ allowTaggedTemplates: true }],
+            parserOptions: { ecmaVersion: 6},
+            errors: ["Expected an assignment or function call and instead saw an expression."]
+        },
+        {
+            code: "`untagged template literal`",
+            options: [{ allowTaggedTemplates: false }],
+            parserOptions: { ecmaVersion: 6},
+            errors: ["Expected an assignment or function call and instead saw an expression."]
+        },
+        {
+            code: "tag`tagged template literal`",
+            options: [{ allowTaggedTemplates: false }],
+            parserOptions: { ecmaVersion: 6},
+            errors: ["Expected an assignment or function call and instead saw an expression."]
+        },
+        {
+            code: "`untagged template literal`",
+            parserOptions: { ecmaVersion: 6 },
+            errors: ["Expected an assignment or function call and instead saw an expression."]
+        },
+        {
+            code: "tag`tagged template literal`",
+            parserOptions: { ecmaVersion: 6 },
+            errors: ["Expected an assignment or function call and instead saw an expression."]
+        },
+        // Chai statements
+        { code: "foo.expect('bar').not.to.pass;", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement" }]},
+        { code: "should.not.pass;", errors: [{ message: "Expected an assignment or function call and instead saw an expression.", type: "ExpressionStatement" }] },
     ]
-});
+});

package/.npmignore

@@ -1 +0,0 @@
-./tests