honkit 3.6.21

package/lib/models/__tests__/glossary.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const file_1 = __importDefault(require("../file"));
+const glossary_1 = __importDefault(require("../glossary"));
+const glossaryEntry_1 = __importDefault(require("../glossaryEntry"));
+describe("Glossary", () => {
+    const glossary = glossary_1.default.createFromEntries(new file_1.default(), [
+        {
+            name: "Hello World",
+            description: "Awesome!",
+        },
+        {
+            name: "JavaScript",
+            description: "This is a cool language",
+        },
+    ]);
+    describe("createFromEntries", () => {
+        test("must add all entries", () => {
+            const entries = glossary.getEntries();
+            expect(entries.size).toBe(2);
+        });
+        test("must add entries as GlossaryEntries", () => {
+            const entries = glossary.getEntries();
+            const entry = entries.get("hello-world");
+            expect(entry instanceof glossaryEntry_1.default).toBeTruthy();
+        });
+    });
+    describe("toText", () => {
+        test("return as markdown", () => {
+            return glossary.toText(".md").then((text) => {
+                expect(text).toContain("# Glossary");
+            });
+        });
+    });
+});

package/lib/models/__tests__/glossaryEntry.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const glossaryEntry_1 = __importDefault(require("../glossaryEntry"));
+describe("GlossaryEntry", () => {
+    describe("getID", () => {
+        test("must return a normalized ID", () => {
+            const entry = new glossaryEntry_1.default({
+                name: "Hello World",
+            });
+            expect(entry.getID()).toBe("hello-world");
+        });
+    });
+});

package/lib/models/__tests__/page.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 immutable_1 = __importDefault(require("immutable"));
+const page_1 = __importDefault(require("../page"));
+describe("Page", () => {
+    describe("toText", () => {
+        test("must not prepend frontmatter if no attributes", () => {
+            const page = new page_1.default().merge({
+                content: "Hello World",
+            });
+            expect(page.toText()).toBe("Hello World");
+        });
+        test("must prepend frontmatter if attributes", () => {
+            const page = new page_1.default().merge({
+                content: "Hello World",
+                attributes: immutable_1.default.fromJS({
+                    hello: "world",
+                }),
+            });
+            expect(page.toText()).toBe("---\nhello: world\n---\n\nHello World");
+        });
+    });
+});

package/lib/models/__tests__/plugin.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 plugin_1 = __importDefault(require("../plugin"));
+describe("Plugin", () => {
+    describe("createFromString", () => {
+        test("must parse name", () => {
+            const plugin = plugin_1.default.createFromString("hello");
+            expect(plugin.getName()).toBe("hello");
+            expect(plugin.getVersion()).toBe("*");
+        });
+        test("must parse version", () => {
+            const plugin = plugin_1.default.createFromString("hello@1.0.0");
+            expect(plugin.getName()).toBe("hello");
+            expect(plugin.getVersion()).toBe("1.0.0");
+        });
+    });
+    describe("isLoaded", () => {
+        test("must return false for empty plugin", () => {
+            const plugin = plugin_1.default.createFromString("hello");
+            expect(plugin.isLoaded()).toBe(false);
+        });
+    });
+});

package/lib/models/__tests__/pluginDependency.js

@@ -0,0 +1,71 @@
+"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 pluginDependency_1 = __importDefault(require("../pluginDependency"));
+describe("PluginDependency", () => {
+    describe("createFromString", () => {
+        test("must parse name", () => {
+            const plugin = pluginDependency_1.default.createFromString("hello");
+            expect(plugin.getName()).toBe("hello");
+            expect(plugin.getVersion()).toBe("*");
+        });
+        test("must parse state", () => {
+            const plugin = pluginDependency_1.default.createFromString("-hello");
+            expect(plugin.getName()).toBe("hello");
+            expect(plugin.isEnabled()).toBe(false);
+        });
+        describe("Version", () => {
+            test("must parse version", () => {
+                const plugin = pluginDependency_1.default.createFromString("hello@1.0.0");
+                expect(plugin.getName()).toBe("hello");
+                expect(plugin.getVersion()).toBe("1.0.0");
+            });
+            test("must parse semver", () => {
+                const plugin = pluginDependency_1.default.createFromString("hello@>=4.0.0");
+                expect(plugin.getName()).toBe("hello");
+                expect(plugin.getVersion()).toBe(">=4.0.0");
+            });
+        });
+        describe("GIT Version", () => {
+            test("must handle HTTPS urls", () => {
+                const plugin = pluginDependency_1.default.createFromString("hello@git+https://github.com/GitbookIO/plugin-ga.git");
+                expect(plugin.getName()).toBe("hello");
+                expect(plugin.getVersion()).toBe("git+https://github.com/GitbookIO/plugin-ga.git");
+            });
+            test("must handle SSH urls", () => {
+                const plugin = pluginDependency_1.default.createFromString("hello@git+ssh://samy@github.com/GitbookIO/plugin-ga.git");
+                expect(plugin.getName()).toBe("hello");
+                expect(plugin.getVersion()).toBe("git+ssh://samy@github.com/GitbookIO/plugin-ga.git");
+            });
+        });
+        describe("listToArray", () => {
+            test("must create an array from a list of plugin dependencies", () => {
+                const list = pluginDependency_1.default.listToArray(immutable_1.default.List([
+                    pluginDependency_1.default.createFromString("hello@1.0.0"),
+                    pluginDependency_1.default.createFromString("noversion"),
+                    pluginDependency_1.default.createFromString("-disabled"),
+                ]));
+                expect(list).toEqual(["hello@1.0.0", "noversion", "-disabled"]);
+            });
+        });
+        describe("listFromArray", () => {
+            test("must create an array from a list of plugin dependencies", () => {
+                const arr = immutable_1.default.fromJS([
+                    "hello@1.0.0",
+                    {
+                        name: "plugin-ga",
+                        version: "git+ssh://samy@github.com/GitbookIO/plugin-ga.git",
+                    },
+                ]);
+                const list = pluginDependency_1.default.listFromArray(arr);
+                expect(list.first().getName()).toBe("hello");
+                expect(list.first().getVersion()).toBe("1.0.0");
+                expect(list.last().getName()).toBe("plugin-ga");
+                expect(list.last().getVersion()).toBe("git+ssh://samy@github.com/GitbookIO/plugin-ga.git");
+            });
+        });
+    });
+});

package/lib/models/__tests__/summary.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const summary_1 = __importDefault(require("../summary"));
+const file_1 = __importDefault(require("../file"));
+describe("Summary", () => {
+    const summary = summary_1.default.createFromParts(new file_1.default(), [
+        {
+            articles: [
+                // 1.1
+                {
+                    title: "My First Article",
+                    ref: "README.md",
+                },
+                // 1.2
+                {
+                    title: "My Second Article",
+                    ref: "article.md",
+                },
+                // 1.3
+                {
+                    title: "My Third Article with anchor",
+                    ref: "article-anchor.md",
+                    articles: [
+                        {
+                            title: "Article with anchor",
+                            ref: "article-anchor.md#anchor",
+                        },
+                    ],
+                },
+                // 1.4
+                {
+                    title: "Article without ref",
+                },
+                // 1.5
+                {
+                    title: "Article with absolute ref",
+                    ref: "https://google.fr",
+                },
+            ],
+        },
+        {
+            title: "Test",
+        },
+    ]);
+    describe("createFromEntries", () => {
+        test("must add all parts", () => {
+            const parts = summary.getParts();
+            expect(parts.size).toBe(2);
+        });
+    });
+    describe("getNextArticle", () => {
+        it("return next article", () => {
+            const nextArticle = summary.getNextArticle("1.1");
+            expect(nextArticle.getLevel()).toBe("1.2");
+        });
+        it("ignore anchor article", () => {
+            const nextArticle = summary.getNextArticle("1.3"); // next is anchor
+            expect(nextArticle.getLevel()).toBe("1.4");
+        });
+    });
+    describe("getPrevArticle", () => {
+        it("return prev article", () => {
+            const prevArticle = summary.getPrevArticle("1.2");
+            expect(prevArticle.getLevel()).toBe("1.1");
+        });
+        it("ignore anchor article", () => {
+            const prevArticle = summary.getPrevArticle("1.4");
+            expect(prevArticle.getLevel()).toBe("1.3");
+        });
+    });
+    describe("getByLevel", () => {
+        test("can return a Part", () => {
+            const part = summary.getByLevel("1");
+            expect(part).toBeDefined();
+            expect(part.getArticles().size).toBe(5);
+        });
+        test("can return a Part (2)", () => {
+            const part = summary.getByLevel("2");
+            expect(part).toBeDefined();
+            expect(part.getTitle()).toBe("Test");
+            expect(part.getArticles().size).toBe(0);
+        });
+        test("can return an Article", () => {
+            const article = summary.getByLevel("1.1");
+            expect(article).toBeDefined();
+            expect(article.getTitle()).toBe("My First Article");
+        });
+    });
+    describe("getByPath", () => {
+        test("return correct article", () => {
+            const article = summary.getByPath("README.md");
+            expect(article).toBeDefined();
+            expect(article.getTitle()).toBe("My First Article");
+        });
+        test("return correct article", () => {
+            const article = summary.getByPath("article.md");
+            expect(article).toBeDefined();
+            expect(article.getTitle()).toBe("My Second Article");
+        });
+        test("return undefined if not found", () => {
+            const article = summary.getByPath("NOT_EXISTING.md");
+            expect(article).toBeFalsy();
+        });
+    });
+    describe("toText", () => {
+        test("return as markdown", () => {
+            return summary.toText(".md").then((text) => {
+                expect(text).toContain("# Summary");
+            });
+        });
+    });
+});

package/lib/models/__tests__/summaryArticle.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const summaryArticle_1 = __importDefault(require("../summaryArticle"));
+const file_1 = __importDefault(require("../file"));
+describe("SummaryArticle", () => {
+    describe("createChildLevel", () => {
+        test("must create the right level", () => {
+            const article = summaryArticle_1.default.create({}, "1.1");
+            expect(article.createChildLevel()).toBe("1.1.1");
+        });
+        test("must create the right level when has articles", () => {
+            const article = summaryArticle_1.default.create({
+                articles: [
+                    {
+                        title: "Test",
+                    },
+                ],
+            }, "1.1");
+            expect(article.createChildLevel()).toBe("1.1.2");
+        });
+    });
+    describe("isFile", () => {
+        test("must return true when exactly the file", () => {
+            const article = summaryArticle_1.default.create({
+                ref: "hello.md",
+            }, "1.1");
+            const file = file_1.default.createWithFilepath("hello.md");
+            expect(article.isFile(file)).toBe(true);
+        });
+        test("must return true when path is not normalized", () => {
+            const article = summaryArticle_1.default.create({
+                ref: "/hello.md",
+            }, "1.1");
+            const file = file_1.default.createWithFilepath("hello.md");
+            expect(article.isFile(file)).toBe(true);
+        });
+        test("must return false when has anchor", () => {
+            const article = summaryArticle_1.default.create({
+                ref: "hello.md#world",
+            }, "1.1");
+            const file = file_1.default.createWithFilepath("hello.md");
+            expect(article.isFile(file)).toBe(false);
+        });
+    });
+    describe("hasAnchor", function () {
+        it("must return false when ref does not have anchor", function () {
+            var article = summaryArticle_1.default.create({
+                ref: "hello.md",
+            }, "1.1");
+            expect(article.hasAnchor()).toBe(false);
+        });
+        it("must return true when has anchor", function () {
+            var article = summaryArticle_1.default.create({
+                ref: "hello.md#world",
+            }, "1.1");
+            expect(article.hasAnchor()).toBe(true);
+        });
+    });
+});

package/lib/models/__tests__/summaryPart.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const summaryPart_1 = __importDefault(require("../summaryPart"));
+describe("SummaryPart", () => {
+    describe("createChildLevel", () => {
+        test("must create the right level", () => {
+            const article = summaryPart_1.default.create({}, "1");
+            expect(article.createChildLevel()).toBe("1.1");
+        });
+        test("must create the right level when has articles", () => {
+            const article = summaryPart_1.default.create({
+                articles: [
+                    {
+                        title: "Test",
+                    },
+                ],
+            }, "1");
+            expect(article.createChildLevel()).toBe("1.2");
+        });
+    });
+});

package/lib/models/__tests__/templateBlock.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nunjucks_1 = __importDefault(require("nunjucks"));
+const immutable_1 = __importDefault(require("immutable"));
+const promise_1 = __importDefault(require("../../utils/promise"));
+const templateBlock_1 = __importDefault(require("../templateBlock"));
+describe("TemplateBlock", () => {
+    describe("create", () => {
+        test("must initialize a simple TemplateBlock from a function", () => {
+            const templateBlock = templateBlock_1.default.create("sayhello", (block) => {
+                return {
+                    body: "<p>Hello, World!</p>",
+                    parse: true,
+                };
+            });
+            // Check basic templateBlock properties
+            expect(templateBlock.getName()).toBe("sayhello");
+            expect(templateBlock.getEndTag()).toBe("endsayhello");
+            expect(templateBlock.getBlocks().size).toBe(0);
+            expect(templateBlock.getExtensionName()).toBe("BlocksayhelloExtension");
+            // Check result of applying block
+            return promise_1.default()
+                .then(() => {
+                return templateBlock.applyBlock();
+            })
+                .then((result) => {
+                expect(result.name).toBe("sayhello");
+                expect(result.body).toBe("<p>Hello, World!</p>");
+            });
+        });
+    });
+    describe("getShortcuts", () => {
+        test("must return undefined if no shortcuts", () => {
+            const templateBlock = templateBlock_1.default.create("sayhello", (block) => {
+                return {
+                    body: "<p>Hello, World!</p>",
+                    parse: true,
+                };
+            });
+            expect(templateBlock.getShortcuts()).toBeFalsy();
+        });
+        test("must return complete shortcut", () => {
+            const templateBlock = templateBlock_1.default.create("sayhello", {
+                process: function (block) {
+                    return "<p>Hello, World!</p>";
+                },
+                shortcuts: {
+                    parsers: ["markdown"],
+                    start: "$",
+                    end: "-",
+                },
+            });
+            const shortcut = templateBlock.getShortcuts();
+            expect(shortcut).toBeDefined();
+            expect(shortcut.getStart()).toEqual("$");
+            expect(shortcut.getEnd()).toEqual("-");
+            expect(shortcut.getStartTag()).toEqual("sayhello");
+            expect(shortcut.getEndTag()).toEqual("endsayhello");
+        });
+    });
+    describe("toNunjucksExt()", () => {
+        test("should replace by block anchor", () => {
+            const templateBlock = templateBlock_1.default.create("sayhello", (block) => {
+                return "Hello";
+            });
+            let blocks = {};
+            // Create a fresh Nunjucks environment
+            const env = new nunjucks_1.default.Environment(null, { autoescape: false });
+            // Add template block to environement
+            const Ext = templateBlock.toNunjucksExt({}, blocks);
+            env.addExtension(templateBlock.getExtensionName(), new Ext());
+            // Render a template using the block
+            const src = "{% sayhello %}{% endsayhello %}";
+            return promise_1.default.nfcall(env.renderString.bind(env), src).then((res) => {
+                blocks = immutable_1.default.fromJS(blocks);
+                expect(blocks.size).toBe(1);
+                const blockId = blocks.keySeq().get(0);
+                const block = blocks.get(blockId);
+                expect(res).toBe(`{{-%${blockId}%-}}`);
+                expect(block.get("body")).toBe("Hello");
+                expect(block.get("name")).toBe("sayhello");
+            });
+        });
+        test("must create a valid nunjucks extension", () => {
+            const templateBlock = templateBlock_1.default.create("sayhello", (block) => {
+                return {
+                    body: "<p>Hello, World!</p>",
+                    parse: true,
+                };
+            });
+            // Create a fresh Nunjucks environment
+            const env = new nunjucks_1.default.Environment(null, { autoescape: false });
+            // Add template block to environement
+            const Ext = templateBlock.toNunjucksExt();
+            env.addExtension(templateBlock.getExtensionName(), new Ext());
+            // Render a template using the block
+            const src = "{% sayhello %}{% endsayhello %}";
+            return promise_1.default.nfcall(env.renderString.bind(env), src).then((res) => {
+                expect(res).toBe("<p>Hello, World!</p>");
+            });
+        });
+        test("must apply block arguments correctly", () => {
+            const templateBlock = templateBlock_1.default.create("sayhello", (block) => {
+                return {
+                    body: `<${block.kwargs.tag}>Hello, ${block.kwargs.name}!</${block.kwargs.tag}>`,
+                    parse: true,
+                };
+            });
+            // Create a fresh Nunjucks environment
+            const env = new nunjucks_1.default.Environment(null, { autoescape: false });
+            // Add template block to environement
+            const Ext = templateBlock.toNunjucksExt();
+            env.addExtension(templateBlock.getExtensionName(), new Ext());
+            // Render a template using the block
+            const src = '{% sayhello name="Samy", tag="p" %}{% endsayhello %}';
+            return promise_1.default.nfcall(env.renderString.bind(env), src).then((res) => {
+                expect(res).toBe("<p>Hello, Samy!</p>");
+            });
+        });
+        test("must accept an async function", () => {
+            const templateBlock = templateBlock_1.default.create("sayhello", (block) => {
+                return promise_1.default().then(() => {
+                    return {
+                        body: `Hello ${block.body}`,
+                        parse: true,
+                    };
+                });
+            });
+            // Create a fresh Nunjucks environment
+            const env = new nunjucks_1.default.Environment(null, { autoescape: false });
+            // Add template block to environement
+            const Ext = templateBlock.toNunjucksExt();
+            env.addExtension(templateBlock.getExtensionName(), new Ext());
+            // Render a template using the block
+            const src = "{% sayhello %}Samy{% endsayhello %}";
+            return promise_1.default.nfcall(env.renderString.bind(env), src).then((res) => {
+                expect(res).toBe("Hello Samy");
+            });
+        });
+        test("must handle nested blocks", () => {
+            const templateBlock = new templateBlock_1.default({
+                name: "yoda",
+                blocks: immutable_1.default.List(["start", "end"]),
+                process: function (block) {
+                    const nested = {};
+                    block.blocks.forEach((blk) => {
+                        nested[blk.name] = blk.body.trim();
+                    });
+                    return {
+                        body: `<p class="yoda">${nested.end} ${nested.start}</p>`,
+                        parse: true,
+                    };
+                },
+            });
+            // Create a fresh Nunjucks environment
+            const env = new nunjucks_1.default.Environment(null, { autoescape: false });
+            // Add template block to environement
+            // @ts-expect-error ts-migrate(2339) FIXME: Property 'toNunjucksExt' does not exist on type 'M... Remove this comment to see the full error message
+            const Ext = templateBlock.toNunjucksExt();
+            // @ts-expect-error ts-migrate(2339) FIXME: Property 'getExtensionName' does not exist on type... Remove this comment to see the full error message
+            env.addExtension(templateBlock.getExtensionName(), new Ext());
+            // Render a template using the block
+            const src = "{% yoda %}{% start %}this sentence should be{% end %}inverted{% endyoda %}";
+            return promise_1.default.nfcall(env.renderString.bind(env), src).then((res) => {
+                expect(res).toBe('<p class="yoda">inverted this sentence should be</p>');
+            });
+        });
+    });
+});