feat(src): add IgnoreNodeManager

Author: azu

package.json

@@ -13,7 +13,7 @@
     "src"
   ],
   "scripts": {
-    "build": "babel src --out-dir lib --source-maps inline",
+    "build": "NODE_ENV=production babel src --out-dir lib --source-maps inline",
     "watch": "babel src --out-dir lib --watch --source-maps inline",
     "docs": "jsdoc2md -t template/README.template.md lib/textlint-rule-helper.js > README.md",
     "test": "npm run build && mocha test/*.js"
@@ -36,5 +36,8 @@
     "source-map-support": "^0.2.8",
     "textlint": "^5.0.2",
     "txt-ast-traverse": "^1.2.0"
+  },
+  "dependencies": {
+    "unist-util-visit": "^1.1.0"
   }
 }

src/IgnoreNodeManger.js

@@ -0,0 +1,82 @@
+// LICENSE : MIT
+"use strict";
+const visit = require('unist-util-visit');
+/**
+ * Ignore node manager that manager ignored ranges.
+ *
+ */
+export default class IgnoreManger {
+    constructor() {
+        /**
+         * @type {[number,number][]}
+         * @private
+         */
+        this._ignoredRangeList = []
+    }
+
+    /**
+     * |.......|
+     * ^       ^
+     * Ignored Range
+     *
+     *    |........|
+     *    ^
+     *  index
+     * @param {number} index
+     * @returns {boolean}
+     */
+    isIgnoredIndex(index) {
+        return this._ignoredRangeList.some(range => {
+            const [start, end] = range;
+            return start <= index && index <= end;
+        })
+    }
+
+    /**
+     * @param {[number, number]} aRange
+     * @returns {boolean}
+     */
+    isIgnoredRange(aRange) {
+        const index = aRange[0];
+        return this.isIgnoredIndex(index);
+    }
+
+    /**
+     * @param {Object} node
+     * @returns {boolean}
+     */
+    isIgnored(node) {
+        const index = node.index;
+        return this.isIgnoredIndex(index);
+    }
+
+    /**
+     * add node to ignore range list
+     * @param {Object} node
+     */
+    ignore(node) {
+        this.ignoreRange(node.range);
+    }
+
+    /**
+     * add range to ignore range list
+     * @param {[number, number]} range
+     */
+    ignoreRange(range) {
+        this._ignoredRangeList.push(range);
+    }
+
+    /**
+     * ignore children node of `node`,
+     * if the children node has the type that is included in `ignoredNodeTypes`.
+     * @param {Node} targetNode
+     * @param {string[]} ignoredNodeTypes
+     */
+    ignoreChildrenByTypes(targetNode, ignoredNodeTypes) {
+        visit(targetNode, visitedNode => {
+            if (ignoredNodeTypes.indexOf(visitedNode.type) !== -1) {
+                this.ignore(visitedNode);
+            }
+        });
+    }
+}

src/index.js

@@ -0,0 +1,8 @@
+// LICENSE : MIT
+"use strict";
+import RuleHelper from "./textlint-rule-helper";
+import IgnoreManager from "./IgnoreNodeManger"
+module.exports = {
+    IgnoreManager,
+    RuleHelper
+};

src/textlint-rule-helper.js

@@ -4,7 +4,7 @@
  * RuleHelper is helper class for textlint.
  * @class RuleHelper
  */
-export class RuleHelper {
+export default class RuleHelper {
     /**
      * Initialize RuleHelper with RuleContext object.
      * @param {RuleContext} ruleContext the ruleContext is context object of the rule.

test/IgnoreNodeManger-test.js

@@ -0,0 +1,37 @@
+// LICENSE : MIT
+"use strict";
+import assert from 'power-assert'
+import IgnoreNodeManger from "../src/IgnoreNodeManger";
+import {textlint} from "textlint"
+describe("IgnoreNodeManger", function () {
+    afterEach(function () {
+        textlint.resetRules();
+    });
+    describe("#ignoreChildrenByTypes()", ()=> {
+        context("when the parent node is Paragraph, the child node is Str", ()=> {
+            it("should ignore range by index", () => {
+                var text = "text`code`text";
+                var isIgnored = false;
+                const ignoreManager = new IgnoreNodeManger();
+                textlint.setupRules({
+                    "rule-key": function (context) {
+                        const {Syntax, RuleError, report, getSource} = context;
+                        return {
+                            [Syntax.Paragraph](node) {
+                                ignoreManager.ignoreChildrenByTypes(node, [context.Syntax.Code]);
+                                const text = getSource(node);
+                                const codeIndex = text.search("code");
+                                isIgnored = ignoreManager.isIgnoredIndex(codeIndex);
+                            }
+                        }
+                    }
+                });
+                return textlint.lintMarkdown(text).then(()=> {
+                    assert.ok(isIgnored);
+                    assert.deepEqual(ignoreManager._ignoredRangeList, [[4, 10]]);
+
+                });
+            });
+        });
+    });
+});

test/textlint-rule-helper-test.js

@@ -1,9 +1,7 @@
 // LICENSE : MIT
 "use strict";
-import {parse,Syntax} from "markdown-to-ast"
-import {traverse} from "txt-ast-traverse"
 import assert from 'power-assert'
-import {RuleHelper} from "../src/textlint-rule-helper";
+import RuleHelper from "../src/textlint-rule-helper";
 import {textlint} from "textlint"
 describe("textlint-rule-helper-test", function () {
     afterEach(function () {