test(keywords): キーワード自体をmarkdownから取得

 キーワードが含まれてるから

Author: azu

package.json

@@ -50,6 +50,7 @@
     "jsdom": "^6.3.0",
     "mdast": "^2.1.0",
     "mocha": "^2.2.5",
+    "nlcst-to-string": "^1.0.0",
     "node-fetch": "^1.3.2",
     "npm-run-all": "^1.2.8",
     "power-assert": "^1.0.0",
@@ -60,6 +61,8 @@
     "textlint-rule-no-start-duplicated-conjunction": "^1.0.3",
     "textlint-rule-prh": "^1.0.1",
     "textlint-rule-spellcheck-tech-word": "^4.0.1",
+    "unist-util-find-all-after": "^1.0.0",
+    "unist-util-parents": "^0.1.1",
     "unist-util-select": "^1.0.0"
   },
   "dependencies": {
@@ -68,6 +71,7 @@
     "gulp": "^3.9.0",
     "gulp-util": "^3.0.6",
     "jquery": "^2.1.4",
-    "stemming-x-keywords": "^1.0.3"
+    "stemming-x-keywords": "^1.0.3",
+    "unist-util-is": "^1.0.0"
   }
 }

test/keywords-test.js

@@ -1,27 +1,26 @@
 // LICENSE : MIT
 "use strict";
 import {getFilePathListAsync}  from "gitbook-summary-to-path";
+let getKeywords = require("stemming-x-keywords").getKeywords;
 import path from "path";
 import fs from "fs";
 import mdast from "mdast";
-var select = require('unist-util-select');
+import parents from "unist-util-parents";
+import select from "unist-util-select";
+import isUnist from "unist-util-is";
+import nlcstToString  from "nlcst-to-string";
+
+
 const rootDir = path.join(__dirname, "..");
 const keywordInfo = require("./keywords.json");
-const Org = fs.readFileSync(__dirname + "/../ORGANIZATION.md","utf-8");
-function getKeywords(matchPath) {
+const Org = fs.readFileSync(__dirname + "/../ORGANIZATION.md", "utf-8");
+function getSummary() {
+    if (getSummary.cache) {
+        return Promise.resolve(getSummary.cache);
+    }
     return getFilePathListAsync(__dirname + "/../SUMMARY.md").then(fileList => {
-        let filteredList = fileList.filter(filePath => {
-            return filePath.indexOf(matchPath) !== -1;
-        });
-        return filteredList[0];
-    }).then(filePath => {
-        let relativePath = path.relative(rootDir, filePath);
-        let content = fs.readFileSync(filePath, "utf-8");
-        return {
-            filePath,
-            content,
-            keywords: keywordInfo[relativePath]
-        };
+        getSummary.cache = fileList;
+        return fileList;
     });
 }
 
@@ -31,23 +30,61 @@ function isNotContain(content, keywords) {
         return content.indexOf(keyword) === -1;
     });
 }
+function findAllAfter(ast, node, type) {
+    let results = [];
+    let children = ast.children;
+    let index = 0, length = children.length;
+    let isFound = false;
+    while (++index < length) {
+        let child = children[index];
+        if (isUnist(node, child)) {
+            isFound = true;
+        } else if (isFound) {
+            if (isUnist(type, child)) {
+                results.push(child);
+            } else {
+                break;
+            }
+        }
+    }
+
+    return results;
+}
 // キーワードが書くコンテンツに含まれているかをテストする
 describe("keywords", function () {
-    it("Each chapter contain the keyword", function (done) {
+    it("Each chapter contain the keyword", function () {
         let ast = mdast.parse(Org);
-        let headingPrs = select(ast, "heading, heading + paragraph");
-        let promises = Object.keys(keywordInfo).map(key => {
-            return getKeywords(key).then(({filePath, content, keywords}) => {
+        let headerLinks = select(parents(ast), "heading link[href]");
+        let filePathList = headerLinks.map(link => {
+            return path.resolve(rootDir, link.href);
+        });
+        let paragraphList = headerLinks.map(link => {
+            let filePath = path.resolve(rootDir, link.href);
+            let paragraphs = findAllAfter(ast, link.parent.node, "paragraph");
+            let results = {
+                filePath: filePath,
+                content: fs.readFileSync(filePath, "utf-8"),
+                keywords: []
+            };
+            let keywords = paragraphs.map(p => {
+                let text = nlcstToString(p);
+                return getKeywords(text).then(a => {
+                    results.keywords = results.keywords.concat(a)
+                });
+            });
+            return Promise.all(keywords).then(()=> {
+                return results;
+            });
+        });
+        let promises = Promise.all(paragraphList).then(results => {
+            return results.forEach(({filePath, content, keywords}) => {
                 let unusedKeywords = isNotContain(content, keywords);
                 if (unusedKeywords.length === 0) {
-                    return Promise.resolve();
-                } else {
-                    return Promise.reject(new Error(`"${unusedKeywords.join(",")}" are not used in ${filePath}`));
+                    return;
                 }
+                throw new Error(`"${unusedKeywords.join(",")}" are not used in ${filePath}`);
             });
         });
-        Promise.all(promises).then(() => {
-            done();
-        }, done);
+        return promises;
     });
 });

test/mocha.opts

@@ -1,2 +1,3 @@
+--timeout 5000
 --recursive
 --compilers js:espower-babel/guess