New: disable-enable-pair rule

Author: mysticatea

docs/rules/disable-enable-pair.md

@@ -0,0 +1,43 @@
+# requires a `eslint-enable` comment for every `eslint-disable` comment (eslint-comments/disable-enable-pair)
+
+`eslint-disable` directive-comments disable ESLint rules in all lines preceded by the comment.
+If you forget `eslint-enable` directive-comment, you may overlook ESLint warnings unintentionally.
+
+This rule warns `eslint-disable` directive-comments if the `eslint-enable` directive-comment for that does not exist.
+
+## Rule Details
+
+Examples of :-1: **incorrect** code for this rule:
+
+```js
+/*eslint eslint-comments/disable-enable-pair: error */
+
+/*eslint-disable no-undef, no-unused-vars */
+var foo = bar()
+```
+
+```js
+/*eslint eslint-comments/disable-enable-pair: error */
+
+/*eslint-disable no-undef, no-unused-vars */ "※ Requires 'eslint-enable' directive for 'no-undef'."
+var foo = bar()
+/*eslint-enable no-unused-vars */
+```
+
+Examples of :+1: **correct** code for this rule:
+
+```js
+/*eslint eslint-comments/disable-enable-pair: error */
+
+/*eslint-disable no-undef, no-unused-vars */
+var foo = bar()
+/*eslint-enable no-undef, no-unused-vars */
+```
+
+```js
+/*eslint eslint-comments/disable-enable-pair: error */
+
+/*eslint-disable no-undef, no-unused-vars */
+var foo = bar()
+/*eslint-enable*/
+```

lib/disabled-area.js

@@ -0,0 +1,257 @@
+/**
+ * @author Toru Nagashima
+ * @copyright 2016 Toru Nagashima. All rights reserved.
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const COMMENT_DIRECTIVE = /^\s*(eslint-(?:en|dis)able(?:(?:-next)?-line)?)\s*(?:(\S[\s\S]+\S)\s*)?$/
+const DELIMITER = /[\s,]+/g
+const pool = new WeakMap()
+
+/**
+ * Checks `a` is less than `b` or `a` equals `b`.
+ *
+ * @param {{line: number, column: number}} a - A location to compare.
+ * @param {{line: number, column: number}} b - Another location to compare.
+ * @returns {boolean} `true` if `a` is less than `b` or `a` equals `b`.
+ * @private
+ */
+function lte(a, b) {
+    return a.line < b.line || (a.line === b.line && a.column <= b.column)
+}
+
+//------------------------------------------------------------------------------
+// Exports
+//------------------------------------------------------------------------------
+
+module.exports = class DisabledArea {
+    /**
+     * Get singleton instance for the given source code.
+     *
+     * @param {eslint.SourceCode} sourceCode - The source code to get.
+     * @returns {DisabledArea} The singleton object for the source code.
+     */
+    static get(sourceCode) {
+        let retv = pool.get(sourceCode.ast)
+
+        if (retv == null) {
+            retv = new DisabledArea()
+            retv._scan(sourceCode)
+            pool.set(sourceCode.ast, retv)
+        }
+
+        return retv
+    }
+
+    /**
+     * Constructor.
+     */
+    constructor() {
+        this.areas = []
+        this.duplicateDisableDirectives = []
+        this.uselessEnableDirectives = []
+    }
+
+    /**
+     * Make disabled area.
+     *
+     * @param {Token} comment - The comment token to disable.
+     * @param {object} location - The start location to disable.
+     * @param {string[]|null} ruleIds - The ruleId names to disable.
+     * @param {string} kind - The kind of disable-comments to show in reports.
+     * @returns {void}
+     * @private
+     */
+    _disable(comment, location, ruleIds, kind) {
+        if (ruleIds) {
+            for (const ruleId of ruleIds) {
+                if (this._isDisabled(ruleId, location)) {
+                    this.duplicateDisableDirectives.push({
+                        comment,
+                        ruleId,
+                        kind,
+                    })
+                }
+
+                this.areas.push({
+                    comment,
+                    ruleId,
+                    kind,
+                    start: location,
+                    end: null,
+                    reported: false,
+                })
+            }
+        }
+        else {
+            if (this._isDisabled(null, location)) {
+                this.duplicateDisableDirectives.push({
+                    comment,
+                    ruleId: null,
+                    kind,
+                })
+            }
+
+            this.areas.push({
+                comment,
+                ruleId: null,
+                kind,
+                start: location,
+                end: null,
+                reported: false,
+            })
+        }
+    }
+
+    /**
+     * Close disabled area.
+     *
+     * @param {Token} comment - The comment token to enable.
+     * @param {object} location - The start location to enable.
+     * @param {string[]|null} ruleIds - The ruleId names to enable.
+     * @returns {void}
+     * @private
+     */
+    _enable(comment, location, ruleIds) {
+        if (ruleIds) {
+            for (const ruleId of ruleIds) {
+                let used = false
+
+                for (let i = this.areas.length - 1; i >= 0; --i) {
+                    const area = this.areas[i]
+
+                    if (area.end === null && area.ruleId === ruleId) {
+                        area.end = location
+                        used = true
+                        break
+                    }
+                }
+
+                if (!used) {
+                    this.uselessEnableDirectives.push({comment, ruleId})
+                }
+            }
+        }
+        else {
+            let start = null
+
+            for (let i = this.areas.length - 1; i >= 0; --i) {
+                const area = this.areas[i]
+
+                if (start !== null && area.start !== start) {
+                    break
+                }
+                if (area.end === null) {
+                    area.end = location
+                    start = area.start
+                }
+            }
+
+            if (start === null) {
+                this.uselessEnableDirectives.push({comment, ruleId: null})
+            }
+        }
+    }
+
+    /**
+     * Gets the area of the given ruleId and location.
+     *
+     * @param {string|null} ruleId - The ruleId name to get.
+     * @param {object} location - The location to get.
+     * @returns {Generator<object>} The area of the given ruleId and location.
+     * @private
+     */
+    * _getAreas(ruleId, location) {
+        for (let i = this.areas.length - 1; i >= 0; --i) {
+            const area = this.areas[i]
+
+            if (lte(location, area.start)) {
+                break
+            }
+            if ((area.ruleId === null || area.ruleId === ruleId) &&
+                lte(area.start, location) &&
+                (area.end === null || lte(location, area.end))
+            ) {
+                yield area
+            }
+        }
+    }
+
+    /**
+     * Checks whether the given ruleId and location pair is disabled.
+     *
+     * @param {string|null} ruleId - The ruleId name to check.
+     * @param {object} location - The location to check.
+     * @returns {boolean} `true` if it's disabled.
+     * @private
+     */
+    _isDisabled(ruleId, location) {
+        return !this._getAreas(ruleId, location).next().done
+    }
+
+    /**
+     * Scan the souce code and setup disabled area list.
+     *
+     * @param {eslint.SourceCode} sourceCode - The source code to scan.
+     * @returns {void}
+     * @private
+     */
+    _scan(sourceCode) {
+        for (const comment of sourceCode.getAllComments()) {
+            const m = COMMENT_DIRECTIVE.exec(comment.value)
+            if (m == null) {
+                continue
+            }
+            const kind = m[1]
+            const ruleIds = m[2] ? m[2].split(DELIMITER) : null
+
+            if (comment.type === "Block" && kind === "eslint-disable") {
+                this._disable(comment, comment.loc.start, ruleIds, kind)
+            }
+            else if (comment.type === "Block" && kind === "eslint-enable") {
+                this._enable(comment, comment.loc.start, ruleIds)
+            }
+            else if (
+                comment.type === "Line" &&
+                kind === "eslint-disable-line"
+            ) {
+                const line = comment.loc.start.line
+                const start = {line, column: 0}
+                const end = {line: line + 1, column: -1}
+
+                this._disable(comment, start, ruleIds, kind)
+                this._enable(comment, end, ruleIds)
+            }
+            else if (
+                comment.type === "Line" &&
+                kind === "eslint-disable-next-line"
+            ) {
+                const line = comment.loc.start.line
+                const start = {line: line + 1, column: 0}
+                const end = {line: line + 2, column: -1}
+
+                this._disable(comment, start, ruleIds, kind)
+                this._enable(comment, end, ruleIds)
+            }
+        }
+    }
+
+    /**
+     * Mark the area of the given ruleId and location as reported.
+     *
+     * @param {string} ruleId - The ruleId name to mark.
+     * @param {object} location - The location to mark.
+     * @returns {void}
+     */
+    report(ruleId, location) {
+        for (const area of this._getAreas(ruleId, location)) {
+            area.reported = true
+            return
+        }
+    }
+}

lib/rules/disable-enable-pair.js

@@ -0,0 +1,52 @@
+/**
+ * @author Toru Nagashima
+ * @copyright 2016 Toru Nagashima. All rights reserved.
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const DisabledArea = require("../disabled-area")
+const utils = require("../utils")
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "requires a `eslint-enable` comment for every `eslint-disable` comment",
+            category: "Best Practices",
+            recommended: false,
+        },
+        fixable: false,
+        schema: [],
+    },
+
+    create(context) {
+        const sourceCode = context.getSourceCode()
+        const disabledArea = DisabledArea.get(sourceCode)
+
+        return {
+            Program() {
+                for (const area of disabledArea.areas) {
+                    if (area.end != null) {
+                        continue
+                    }
+
+                    context.report({
+                        loc: utils.toRuleIdLocation(area.comment, area.ruleId),
+                        message: (area.ruleId) ?
+                            "Requires 'eslint-enable' directive for '{{ruleId}}'." :
+                            "Requires 'eslint-enable' directive.",
+                        data: area,
+                    })
+                }
+            },
+        }
+    },
+}