Merge pull request #1 from azu/fix-to-string

Change target to Paragraph

Author: azu

package.json

@@ -36,15 +36,16 @@
     "babel-plugin-transform-es2015-modules-commonjs": "^6.1.20",
     "babel-preset-es2015": "^6.1.18",
     "espower-babel": "^4.0.0",
-    "mocha": "^2.3.3",
+    "mocha": "^2.3.4",
     "power-assert": "^1.1.0",
     "sentence-splitter": "^1.0.2",
-    "textlint": "^5.0.0",
+    "textlint": "^5.0.2",
     "textlint-tester": "^0.4.0"
   },
   "dependencies": {
     "kuromojin": "^1.0.2",
     "sentence-splitter": "^1.0.1",
-    "textlint-rule-helper": "^1.1.4"
+    "textlint-rule-helper": "^1.1.4",
+    "textlint-util-to-string": "^1.1.0"
   }
 }

src/no-doubled-joshi.js

@@ -3,6 +3,7 @@
 import {RuleHelper} from "textlint-rule-helper";
 import {getTokenizer} from "kuromojin";
 import splitSentences, {Syntax as SentenceSyntax} from "sentence-splitter";
+import StringSource from "textlint-util-to-string";
 /**
  * create a object that
  * map ={
@@ -34,31 +35,49 @@ function matchExceptionRule(tokens) {
     }
     return false;
 }
+/*
+    default options
+ */
 const defaultOptions = {
     min_interval: 1,
     strict: false
 };
+
+
+/*
+    1. Paragraph Node -> text
+    2. text -> sentences
+    3. tokenize sentence
+    4. report error if found word that match the rule.
+
+    TODO: need abstraction
+ */
 export default function (context, options = {}) {
     const helper = new RuleHelper(context);
     // 最低間隔値
-    let minInterval = options.min_interval || defaultOptions.min_interval;
-    let isStrict = options.strict || defaultOptions.strict;
-    let {Syntax, report, getSource, RuleError} = context;
+    const minInterval = options.min_interval || defaultOptions.min_interval;
+    const isStrict = options.strict || defaultOptions.strict;
+    const {Syntax, report, getSource, RuleError} = context;
     return {
-        [Syntax.Str](node){
+        [Syntax.Paragraph](node){
             if (helper.isChildNode(node, [Syntax.Link, Syntax.Image, Syntax.BlockQuote, Syntax.Emphasis])) {
                 return;
             }
-            let text = getSource(node);
-            let sentences = splitSentences(text).filter(node => {
+            const source = new StringSource(node);
+            const text = source.toString();
+            const isSentenceNode = node => {
                 return node.type === SentenceSyntax.Sentence;
-            });
+            };
+            let sentences = splitSentences(text, {
+                charRegExp: /[。\?\!？！]/
+            }).filter(isSentenceNode);
             return getTokenizer().then(tokenizer => {
                 const checkSentence = (sentence) => {
                     let tokens = tokenizer.tokenizeForSentence(sentence.raw);
-                    let joshiTokens = tokens.filter(token => {
+                    const isJoshiToken = token => {
                         return token.pos === "助詞";
-                    });
+                    };
+                    let joshiTokens = tokens.filter(isJoshiToken);
                     let joshiTokenSurfaceKeyMap = createSurfaceKeyMap(joshiTokens);
                     /*
                     # Data Structure
@@ -73,26 +92,33 @@ export default function (context, options = {}) {
                         let tokens = joshiTokenSurfaceKeyMap[key];
                         // strict mode ではない時例外を除去する
                         if (!isStrict) {
-                            if(matchExceptionRule(tokens)) {
+                            if (matchExceptionRule(tokens)) {
                                 return;
                             }
                         }
                         if (tokens.length <= 1) {
                             return;// no duplicated token
                         }
                         // if found differenceIndex less than
+                        // tokes are sorted ascending order
                         tokens.reduce((prev, current) => {
                             let startPosition = joshiTokens.indexOf(prev);
                             let otherPosition = joshiTokens.indexOf(current);
                             // if difference
                             let differenceIndex = otherPosition - startPosition;
                             if (differenceIndex <= minInterval) {
-                                report(node, new RuleError(`一文に二回以上利用されている助詞 "${key}" がみつかりました。`, {
-                                    line: sentence.loc.start.line - 1,
+                                let originalPosition = source.originalPositionFor({
+                                    line: sentence.loc.start.line,
+                                    column: sentence.loc.start.column + (current.word_position - 1)
+                                });
+                                // padding position
+                                var padding = {
+                                    line: originalPosition.line - 1,
                                     // matchLastToken.word_position start with 1
                                     // this is padding column start with 0 (== -1)
-                                    column: sentence.loc.start.column + (current.word_position - 1)
-                                }));
+                                    column: originalPosition.column
+                                };
+                                report(node, new RuleError(`一文に二回以上利用されている助詞 "${key}" がみつかりました。`, padding));
                             }
                             return current;
                         });

test/fixtures/test.md

@@ -0,0 +1,4 @@
+# テスト文
+
+`app.use(middleware)` という形で、_middleware_と呼ばれる関数には`request`や`response`といったオブジェクトが渡されます。
+この`request`や`response`を_middleware_で処理することでログを取ったり、任意のレスポンスを返しことができるようになっています。

test/test.js

@@ -0,0 +1,24 @@
+// LICENSE : MIT
+"use strict";
+import {TextLintCore} from "textlint";
+import rule from "../src/no-doubled-joshi";
+import assert from "power-assert";
+describe("example-test", function () {
+    it("should handle", function () {
+        let textlint = new TextLintCore();
+        textlint.setupRules({
+            "no-doubled-joshi": rule
+        });
+        return textlint.lintFile(__dirname + "/fixtures/test.md").then(result => {
+            assert.equal(result.messages.length, 1);
+            let message = result.messages[0];
+            assert.deepEqual(message, {
+                ruleId: 'no-doubled-joshi',
+                message: '一文に二回以上利用されている助詞 "で" がみつかりました。',
+                line: 4,
+                column: 43,
+                severity: 2
+            });
+        });
+    });
+});