honkit 3.6.21

package/lib/parse/__tests__/parseSummary.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const book_1 = __importDefault(require("../../models/book"));
+const mock_1 = __importDefault(require("../../fs/mock"));
+const parseSummary_1 = __importDefault(require("../parseSummary"));
+describe("parseSummary", () => {
+    test("should parse summary if exists", () => {
+        const fs = mock_1.default({
+            "SUMMARY.md": "# Summary\n\n* [Hello](hello.md)",
+        });
+        const book = book_1.default.createForFS(fs);
+        return parseSummary_1.default(book).then((resultBook) => {
+            const summary = resultBook.getSummary();
+            const file = summary.getFile();
+            expect(file.exists()).toBeTruthy();
+        });
+    });
+    test("should not fail if doesn't exist", () => {
+        const fs = mock_1.default({});
+        const book = book_1.default.createForFS(fs);
+        return parseSummary_1.default(book).then((resultBook) => {
+            const summary = resultBook.getSummary();
+            const file = summary.getFile();
+            expect(file.exists()).toBeFalsy();
+        });
+    });
+});

package/lib/parse/findParsableFile.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const promise_1 = __importDefault(require("../utils/promise"));
+const parsers_1 = __importDefault(require("../parsers"));
+/**
+ Find a file parsable (Markdown or AsciiDoc) in a book
+
+ @param {Book} book
+ @param {string} filename
+ @return {Promise<File | Undefined>}
+ */
+function findParsableFile(book, filename) {
+    const fs = book.getContentFS();
+    const ext = path_1.default.extname(filename);
+    const basename = path_1.default.basename(filename, ext);
+    const basedir = path_1.default.dirname(filename);
+    // Ordered list of extensions to test
+    const exts = parsers_1.default.extensions;
+    return promise_1.default.some(exts, (ext) => {
+        const filepath = basename + ext;
+        return fs.findFile(basedir, filepath).then((found) => {
+            if (!found || book.isContentFileIgnored(found)) {
+                return undefined;
+            }
+            return fs.statFile(found);
+        });
+    });
+}
+exports.default = findParsableFile;

package/lib/parse/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseBook_1 = __importDefault(require("./parseBook"));
+const parseSummary_1 = __importDefault(require("./parseSummary"));
+const parseGlossary_1 = __importDefault(require("./parseGlossary"));
+const parseReadme_1 = __importDefault(require("./parseReadme"));
+const parseConfig_1 = __importDefault(require("./parseConfig"));
+const parsePagesList_1 = __importDefault(require("./parsePagesList"));
+const parseIgnore_1 = __importDefault(require("./parseIgnore"));
+const listAssets_1 = __importDefault(require("./listAssets"));
+const parseLanguages_1 = __importDefault(require("./parseLanguages"));
+const parsePage_1 = __importDefault(require("./parsePage"));
+const parsePageFromString_1 = __importDefault(require("./parsePageFromString"));
+const lookupStructureFile_1 = __importDefault(require("./lookupStructureFile"));
+exports.default = {
+    parseBook: parseBook_1.default,
+    parseSummary: parseSummary_1.default,
+    parseGlossary: parseGlossary_1.default,
+    parseReadme: parseReadme_1.default,
+    parseConfig: parseConfig_1.default,
+    parsePagesList: parsePagesList_1.default,
+    parseIgnore: parseIgnore_1.default,
+    listAssets: listAssets_1.default,
+    parseLanguages: parseLanguages_1.default,
+    parsePage: parsePage_1.default,
+    parsePageFromString: parsePageFromString_1.default,
+    lookupStructureFile: lookupStructureFile_1.default,
+};

package/lib/parse/listAssets.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const timing_1 = __importDefault(require("../utils/timing"));
+/**
+ List all assets in a book
+ Assets are file not ignored and not a page
+
+ @param {Book} book
+ @param {List<String>} pages
+ @param
+ */
+function listAssets(book, pages) {
+    const fs = book.getContentFS();
+    const summary = book.getSummary();
+    const summaryFile = summary.getFile().getPath();
+    const glossary = book.getGlossary();
+    const glossaryFile = glossary.getFile().getPath();
+    const langs = book.getLanguages();
+    const langsFile = langs.getFile().getPath();
+    const config = book.getConfig();
+    const configFile = config.getFile().getPath();
+    function filterFile(rawFile) {
+        const file = rawFile.replace(/\\/g, "/");
+        return !(file === summaryFile ||
+            file === glossaryFile ||
+            file === langsFile ||
+            file === configFile ||
+            book.isContentFileIgnored(file) ||
+            pages.has(file));
+    }
+    return timing_1.default.measure("parse.listAssets", fs.listAllFiles(".", filterFile));
+}
+exports.default = listAssets;

package/lib/parse/lookupStructureFile.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const findParsableFile_1 = __importDefault(require("./findParsableFile"));
+/**
+ Lookup a structure file (ex: SUMMARY.md, GLOSSARY.md) in a book. Uses
+ book's config to find it.
+
+ @param {Book} book
+ @param {string} type: one of ["glossary", "readme", "summary", "langs"]
+ @return {Promise<File | Undefined>} The path of the file found, relative
+ to the book content root.
+ */
+function lookupStructureFile(book, type) {
+    const config = book.getConfig();
+    const fileToSearch = config.getValue(["structure", type]);
+    return findParsableFile_1.default(book, fileToSearch);
+}
+exports.default = lookupStructureFile;

package/lib/parse/parseBook.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promise_1 = __importDefault(require("../utils/promise"));
+const timing_1 = __importDefault(require("../utils/timing"));
+const book_1 = __importDefault(require("../models/book"));
+const parseIgnore_1 = __importDefault(require("./parseIgnore"));
+const parseConfig_1 = __importDefault(require("./parseConfig"));
+const parseGlossary_1 = __importDefault(require("./parseGlossary"));
+const parseSummary_1 = __importDefault(require("./parseSummary"));
+const parseReadme_1 = __importDefault(require("./parseReadme"));
+const parseLanguages_1 = __importDefault(require("./parseLanguages"));
+/**
+ Parse content of a book
+
+ @param {Book} book
+ @return {Promise<Book>}
+ */
+function parseBookContent(book) {
+    return promise_1.default(book).then(parseReadme_1.default).then(parseSummary_1.default).then(parseGlossary_1.default);
+}
+/**
+ Parse a multilingual book
+
+ @param {Book} book
+ @return {Promise<Book>}
+ */
+function parseMultilingualBook(book) {
+    const languages = book.getLanguages();
+    const langList = languages.getList();
+    return promise_1.default.reduce(langList, (currentBook, lang) => {
+        const langID = lang.getID();
+        const child = book_1.default.createFromParent(currentBook, langID);
+        let ignore = currentBook.getIgnore();
+        return promise_1.default(child)
+            .then(parseConfig_1.default)
+            .then(parseBookContent)
+            .then((result) => {
+            // Ignore content of this book when generating parent book
+            ignore = ignore.add(`${langID}/**`);
+            currentBook = currentBook.set("ignore", ignore);
+            return currentBook.addLanguageBook(langID, result);
+        });
+    }, book);
+}
+/**
+ Parse a whole book from a filesystem
+
+ @param {Book} book
+ @return {Promise<Book>}
+ */
+function parseBook(book) {
+    return timing_1.default.measure("parse.book", promise_1.default(book)
+        .then(parseIgnore_1.default)
+        .then(parseConfig_1.default)
+        .then(parseLanguages_1.default)
+        .then((resultBook) => {
+        if (resultBook.isMultilingual()) {
+            return parseMultilingualBook(resultBook);
+        }
+        else {
+            return parseBookContent(resultBook);
+        }
+    }));
+}
+exports.default = parseBook;

package/lib/parse/parseConfig.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promise_1 = __importDefault(require("../utils/promise"));
+const validateConfig_1 = __importDefault(require("./validateConfig"));
+const configFiles_1 = __importDefault(require("../constants/configFiles"));
+/**
+ Parse configuration from "book.json" or "book.js"
+
+ @param {Book} book
+ @return {Promise<Book>}
+ */
+function parseConfig(book) {
+    const fs = book.getFS();
+    let config = book.getConfig();
+    return promise_1.default.some(configFiles_1.default, (filename) => {
+        // Is this file ignored?
+        if (book.isFileIgnored(filename)) {
+            return;
+        }
+        // Try loading it
+        return fs
+            .loadAsObject(filename)
+            .then((cfg) => {
+            return fs.statFile(filename).then((file) => {
+                return {
+                    file: file,
+                    values: cfg,
+                };
+            });
+        })
+            .fail((err) => {
+            if (err.code != "MODULE_NOT_FOUND")
+                throw err;
+            else
+                return promise_1.default(false);
+        });
+    }).then((result) => {
+        let values = result ? result.values : {};
+        values = validateConfig_1.default(values);
+        // Set the file
+        if (result.file) {
+            config = config.setFile(result.file);
+        }
+        // Merge with old values
+        config = config.mergeValues(values);
+        return book.setConfig(config);
+    });
+}
+exports.default = parseConfig;

package/lib/parse/parseGlossary.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseStructureFile_1 = __importDefault(require("./parseStructureFile"));
+const glossary_1 = __importDefault(require("../models/glossary"));
+/**
+ Parse glossary
+
+ @param {Book} book
+ @return {Promise<Book>}
+ */
+function parseGlossary(book) {
+    const logger = book.getLogger();
+    return parseStructureFile_1.default(book, "glossary").spread((file, entries) => {
+        if (!file) {
+            return book;
+        }
+        logger.debug.ln("glossary index file found at", file.getPath());
+        const glossary = glossary_1.default.createFromEntries(file, entries);
+        return book.set("glossary", glossary);
+    });
+}
+exports.default = parseGlossary;

package/lib/parse/parseIgnore.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promise_1 = __importDefault(require("../utils/promise"));
+const ignoreFiles_1 = __importDefault(require("../constants/ignoreFiles"));
+const DEFAULT_IGNORES = [
+    // Skip Git stuff
+    ".git/",
+    // Skip OS X meta data
+    ".DS_Store",
+    // Skip stuff installed by plugins
+    "node_modules",
+    // Skip book outputs
+    "_book",
+    // Ignore files in the templates folder
+    "_layouts",
+];
+/**
+ Parse ignore files
+
+ @param {Book}
+ @return {Book}
+ */
+function parseIgnore(book) {
+    if (book.isLanguageBook()) {
+        return promise_1.default.reject(new Error("Ignore files could be parsed for language books"));
+    }
+    const fs = book.getFS();
+    let ignore = book.getIgnore();
+    ignore = ignore.add(DEFAULT_IGNORES);
+    return promise_1.default.serie(ignoreFiles_1.default, (filename) => {
+        return fs.readAsString(filename).then((content) => {
+            ignore = ignore.add(content.toString().split(/\r?\n/));
+        }, (err) => {
+            return promise_1.default();
+        });
+    }).then(() => {
+        return book.setIgnore(ignore);
+    });
+}
+exports.default = parseIgnore;

package/lib/parse/parseLanguages.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseStructureFile_1 = __importDefault(require("./parseStructureFile"));
+const languages_1 = __importDefault(require("../models/languages"));
+/**
+ Parse languages list from book
+
+ @param {Book} book
+ @return {Promise<Book>}
+ */
+function parseLanguages(book) {
+    const logger = book.getLogger();
+    return parseStructureFile_1.default(book, "langs").spread((file, result) => {
+        if (!file) {
+            return book;
+        }
+        const languages = languages_1.default.createFromList(file, result);
+        logger.debug.ln("languages index file found at", file.getPath());
+        logger.info.ln("parsing multilingual book, with", languages.getList().size, "languages");
+        return book.set("languages", languages);
+    });
+}
+exports.default = parseLanguages;

package/lib/parse/parsePage.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parsePageFromString_1 = __importDefault(require("./parsePageFromString"));
+/**
+ * Parse a page, read its content and parse the YAMl header
+ *
+ * @param {Book} book
+ * @param {Page} page
+ * @return {Promise<Page>}
+ */
+function parsePage(book, page) {
+    const fs = book.getContentFS();
+    const file = page.getFile();
+    return fs.readAsString(file.getPath()).then((content) => {
+        return parsePageFromString_1.default(page, content);
+    });
+}
+exports.default = parsePage;

package/lib/parse/parsePageFromString.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const immutable_1 = __importDefault(require("immutable"));
+const front_matter_1 = __importDefault(require("front-matter"));
+const direction_1 = __importDefault(require("direction"));
+/**
+ * Parse a page, its content and the YAMl header
+ *
+ * @param {Page} page
+ * @param {string} content
+ * @return {Page}
+ */
+function parsePageFromString(page, content) {
+    // Parse page YAML
+    const parsed = front_matter_1.default(content);
+    return page.merge({
+        content: parsed.body,
+        attributes: immutable_1.default.fromJS(parsed.attributes),
+        dir: direction_1.default(parsed.body),
+    });
+}
+exports.default = parsePageFromString;

package/lib/parse/parsePagesList.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const immutable_1 = __importDefault(require("immutable"));
+const timing_1 = __importDefault(require("../utils/timing"));
+const page_1 = __importDefault(require("../models/page"));
+const walkSummary_1 = __importDefault(require("./walkSummary"));
+const parsePage_1 = __importDefault(require("./parsePage"));
+/**
+ Parse a page from a path
+
+ @param {Book} book
+ @param {string} filePath
+ @return {Page?}
+ */
+function parseFilePage(book, filePath) {
+    const fs = book.getContentFS();
+    return fs
+        .statFile(filePath)
+        .then((file) => {
+        const page = page_1.default.createForFile(file);
+        return parsePage_1.default(book, page);
+    }, (err) => {
+        // file doesn't exist
+        return null;
+    })
+        .fail((err) => {
+        const logger = book.getLogger();
+        logger.error.ln(`error while parsing page "${filePath}":`);
+        throw err;
+    });
+}
+/**
+ Parse all pages from a book as an OrderedMap
+
+ @param {Book} book
+ @return {Promise<OrderedMap<Page>>}
+ */
+function parsePagesList(book) {
+    const summary = book.getSummary();
+    const glossary = book.getGlossary();
+    let map = immutable_1.default.OrderedMap();
+    // Parse pages from summary
+    return (timing_1.default
+        .measure("parse.listPages", walkSummary_1.default(summary, (article) => {
+        if (!article.isPage())
+            return;
+        const filepath = article.getPath();
+        // Is the page ignored?
+        if (book.isContentFileIgnored(filepath))
+            return;
+        return parseFilePage(book, filepath).then((page) => {
+            // file doesn't exist
+            if (!page) {
+                return;
+            }
+            map = map.set(filepath, page);
+        });
+    }))
+        // Parse glossary
+        .then(() => {
+        const file = glossary.getFile();
+        if (!file.exists()) {
+            return;
+        }
+        return parseFilePage(book, file.getPath()).then((page) => {
+            // file doesn't exist
+            if (!page) {
+                return;
+            }
+            map = map.set(file.getPath(), page);
+        });
+    })
+        .then(() => {
+        return map;
+    }));
+}
+exports.default = parsePagesList;