honkit 3.6.21

package/lib/models/__tests__/templateEngine.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const templateEngine_1 = __importDefault(require("../templateEngine"));
+describe("TemplateBlock", () => {
+    describe("create", () => {
+        test("must initialize with a list of filters", () => {
+            const engine = templateEngine_1.default.create({
+                filters: {
+                    hello: function (name) {
+                        return `Hello ${name}!`;
+                    },
+                },
+            });
+            const env = engine.toNunjucks();
+            const res = env.renderString('{{ "Luke"|hello }}', {});
+            expect(res).toBe("Hello Luke!");
+        });
+        test("must initialize with a list of globals", () => {
+            const engine = templateEngine_1.default.create({
+                globals: {
+                    hello: function (name) {
+                        return `Hello ${name}!`;
+                    },
+                },
+            });
+            const env = engine.toNunjucks();
+            const res = env.renderString('{{ hello("Luke") }}', {});
+            expect(res).toBe("Hello Luke!");
+        });
+        test("must pass context to filters and blocks", () => {
+            const engine = templateEngine_1.default.create({
+                filters: {
+                    hello: function (name) {
+                        return `Hello ${name} ${this.lastName}!`;
+                    },
+                },
+                context: {
+                    lastName: "Skywalker",
+                },
+            });
+            const env = engine.toNunjucks();
+            const res = env.renderString('{{ "Luke"|hello }}', {});
+            expect(res).toBe("Hello Luke Skywalker!");
+        });
+    });
+});

package/lib/models/book.js

@@ -0,0 +1,312 @@
+"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 immutable_1 = __importDefault(require("immutable"));
+const logger_1 = __importDefault(require("../utils/logger"));
+const fs_1 = __importDefault(require("./fs"));
+const config_1 = __importDefault(require("./config"));
+const readme_1 = __importDefault(require("./readme"));
+const summary_1 = __importDefault(require("./summary"));
+const glossary_1 = __importDefault(require("./glossary"));
+const languages_1 = __importDefault(require("./languages"));
+const ignore_1 = __importDefault(require("./ignore"));
+class Book extends immutable_1.default.Record({
+    // Logger for outptu message
+    // @ts-expect-error ts-migrate(2554) FIXME: Expected 2 arguments, but got 0.
+    logger: logger_1.default(),
+    // Filesystem binded to the book scope to read files/directories
+    fs: new fs_1.default(),
+    // Ignore files parser
+    ignore: new ignore_1.default(),
+    // Structure files
+    config: new config_1.default(),
+    readme: new readme_1.default(),
+    summary: new summary_1.default(),
+    glossary: new glossary_1.default(),
+    languages: new languages_1.default(),
+    // ID of the language for language books
+    language: String(),
+    // List of children, if multilingual (String -> Book)
+    books: immutable_1.default.OrderedMap(),
+}) {
+    getLogger() {
+        return this.get("logger");
+    }
+    getFS() {
+        return this.get("fs");
+    }
+    getIgnore() {
+        return this.get("ignore");
+    }
+    getConfig() {
+        return this.get("config");
+    }
+    getReadme() {
+        return this.get("readme");
+    }
+    getSummary() {
+        return this.get("summary");
+    }
+    getGlossary() {
+        return this.get("glossary");
+    }
+    getLanguages() {
+        return this.get("languages");
+    }
+    getBooks() {
+        return this.get("books");
+    }
+    getLanguage() {
+        return this.get("language");
+    }
+    /**
+     Return FS instance to access the content
+
+     @return {FS}
+     */
+    getContentFS() {
+        const fs = this.getFS();
+        const config = this.getConfig();
+        const rootFolder = config.getValue("root");
+        if (rootFolder) {
+            return fs_1.default.reduceScope(fs, rootFolder);
+        }
+        return fs;
+    }
+    /**
+     Return root of the book
+
+     @return {string}
+     */
+    getRoot() {
+        const fs = this.getFS();
+        return fs.getRoot();
+    }
+    /**
+     Return root for content of the book
+
+     @return {string}
+     */
+    getContentRoot() {
+        const fs = this.getContentFS();
+        return fs.getRoot();
+    }
+    /**
+     Check if a file is ignore (should not being parsed, etc)
+
+     @param {string} ref
+     @return {Page|undefined}
+     */
+    isFileIgnored(filename) {
+        const ignore = this.getIgnore();
+        const language = this.getLanguage();
+        // Ignore is always relative to the root of the main book
+        if (language) {
+            filename = path_1.default.join(language, filename);
+        }
+        return ignore.isFileIgnored(filename);
+    }
+    /**
+     Check if a content file is ignore (should not being parsed, etc)
+
+     @param {string} ref
+     @return {Page|undefined}
+     */
+    isContentFileIgnored(filename) {
+        const config = this.getConfig();
+        const rootFolder = config.getValue("root");
+        if (rootFolder) {
+            filename = path_1.default.join(rootFolder, filename);
+        }
+        return this.isFileIgnored(filename);
+    }
+    /**
+     Is this book the parent of language's books
+
+     @return {boolean}
+     */
+    isMultilingual() {
+        return this.getLanguages().getCount() > 0;
+    }
+    /**
+     Return true if book is associated to a language
+
+     @return {boolean}
+     */
+    isLanguageBook() {
+        return Boolean(this.getLanguage());
+    }
+    /**
+     Return a languages book
+
+     @param {string} language
+     @return {Book}
+     */
+    getLanguageBook(language) {
+        const books = this.getBooks();
+        return books.get(language);
+    }
+    /**
+     Add a new language book
+
+     @param {string} language
+     @param {Book} book
+     @return {Book}
+     */
+    addLanguageBook(language, book) {
+        let books = this.getBooks();
+        books = books.set(language, book);
+        return this.set("books", books);
+    }
+    /**
+     Set the summary for this book
+
+     @param {Summary}
+     @return {Book}
+     */
+    setSummary(summary) {
+        return this.set("summary", summary);
+    }
+    /**
+     Set the readme for this book
+
+     @param {Readme}
+     @return {Book}
+     */
+    setReadme(readme) {
+        return this.set("readme", readme);
+    }
+    /**
+     Set the configuration for this book
+
+     @param {Config}
+     @return {Book}
+     */
+    setConfig(config) {
+        return this.set("config", config);
+    }
+    /**
+     Set the ignore instance for this book
+
+     @param {Ignore}
+     @return {Book}
+     */
+    setIgnore(ignore) {
+        return this.set("ignore", ignore);
+    }
+    /**
+     Change log level
+
+     @param {string} level
+     @return {Book}
+     */
+    setLogLevel(level) {
+        this.getLogger().setLevel(level);
+        return this;
+    }
+    /**
+     Create a book using a filesystem
+
+     @param {FS} fs
+     @return {Book}
+     */
+    static createForFS(fs) {
+        return new Book({
+            fs: fs,
+        });
+    }
+    /**
+     Infers the default extension for files
+     @return {string}
+     */
+    getDefaultExt() {
+        // Inferring sources
+        const clues = [this.getReadme(), this.getSummary(), this.getGlossary()];
+        // List their extensions
+        const exts = clues.map((clue) => {
+            const file = clue.getFile();
+            if (file.exists()) {
+                return file.getParser().getExtensions().first();
+            }
+            else {
+                return null;
+            }
+        });
+        // Adds the general default extension
+        exts.push(".md");
+        // Choose the first non null
+        return exts.find((e) => {
+            return e !== null;
+        });
+    }
+    /**
+     Infer the default path for a Readme.
+     @param {boolean} [absolute=false] False for a path relative to
+     this book's content root
+     @return {string}
+     */
+    getDefaultReadmePath(absolute) {
+        const defaultPath = `README${this.getDefaultExt()}`;
+        if (absolute) {
+            return path_1.default.join(this.getContentRoot(), defaultPath);
+        }
+        else {
+            return defaultPath;
+        }
+    }
+    /**
+     Infer the default path for a Summary.
+     @param {boolean} [absolute=false] False for a path relative to
+     this book's content root
+     @return {string}
+     */
+    getDefaultSummaryPath(absolute) {
+        const defaultPath = `SUMMARY${this.getDefaultExt()}`;
+        if (absolute) {
+            return path_1.default.join(this.getContentRoot(), defaultPath);
+        }
+        else {
+            return defaultPath;
+        }
+    }
+    /**
+     Infer the default path for a Glossary.
+     @param {boolean} [absolute=false] False for a path relative to
+     this book's content root
+     @return {string}
+     */
+    getDefaultGlossaryPath(absolute) {
+        const defaultPath = `GLOSSARY${this.getDefaultExt()}`;
+        if (absolute) {
+            return path_1.default.join(this.getContentRoot(), defaultPath);
+        }
+        else {
+            return defaultPath;
+        }
+    }
+    /**
+     Create a language book from a parent
+
+     @param {Book} parent
+     @param {string} language
+     @return {Book}
+     */
+    static createFromParent(parent, language) {
+        const ignore = parent.getIgnore();
+        let config = parent.getConfig();
+        // Set language in configuration
+        config = config.setValue("language", language);
+        return new Book({
+            // Inherits config. logegr and list of ignored files
+            logger: parent.getLogger(),
+            config: config,
+            ignore: ignore,
+            language: language,
+            fs: fs_1.default.reduceScope(parent.getContentFS(), language),
+        });
+    }
+}
+exports.default = Book;

package/lib/models/config.js

@@ -0,0 +1,152 @@
+"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 file_1 = __importDefault(require("./file"));
+const pluginDependency_1 = __importDefault(require("./pluginDependency"));
+const configDefault_1 = __importDefault(require("../constants/configDefault"));
+const reducedObject_1 = __importDefault(require("../utils/reducedObject"));
+class Config extends immutable_1.default.Record({
+    file: new file_1.default(),
+    values: configDefault_1.default,
+}, "Config") {
+    getFile() {
+        return this.get("file");
+    }
+    getValues() {
+        return this.get("values");
+    }
+    /**
+     * Return minimum version of configuration,
+     * Basically it returns the current config minus the default one
+     * @return {Map}
+     */
+    toReducedVersion() {
+        return reducedObject_1.default(configDefault_1.default, this.getValues());
+    }
+    /**
+     * Render config as text
+     * @return {Promise<String>}
+     */
+    toText() {
+        return JSON.stringify(this.toReducedVersion().toJS(), null, 4);
+    }
+    /**
+     * Change the file for the configuration
+     * @param {File} file
+     * @return {Config}
+     */
+    setFile(file) {
+        return this.set("file", file);
+    }
+    /**
+     * Return a configuration value by its key path
+     */
+    getValue(keyPath, def) {
+        const values = this.getValues();
+        keyPath = Config.keyToKeyPath(keyPath);
+        if (!values.hasIn(keyPath)) {
+            return immutable_1.default.fromJS(def);
+        }
+        return values.getIn(keyPath);
+    }
+    /**
+     * Update a configuration value
+     * @return {Config}
+     */
+    setValue(keyPath, value) {
+        keyPath = Config.keyToKeyPath(keyPath);
+        value = immutable_1.default.fromJS(value);
+        let values = this.getValues();
+        values = values.setIn(keyPath, value);
+        return this.set("values", values);
+    }
+    /**
+     * Return a list of plugin dependencies
+     * @return {List<PluginDependency>}
+     */
+    getPluginDependencies() {
+        const plugins = this.getValue("plugins");
+        if (typeof plugins === "string") {
+            return pluginDependency_1.default.listFromString(plugins);
+        }
+        else {
+            return pluginDependency_1.default.listFromArray(plugins);
+        }
+    }
+    /**
+     * Return a plugin dependency by its name
+     * @param {string} name
+     * @return {PluginDependency}
+     */
+    getPluginDependency(name) {
+        const plugins = this.getPluginDependencies();
+        return plugins.find((dep) => {
+            return dep.getName() === name;
+        });
+    }
+    /**
+     * Update the list of plugins dependencies
+     * @param {List<PluginDependency>}
+     * @return {Config}
+     */
+    setPluginDependencies(deps) {
+        const plugins = pluginDependency_1.default.listToArray(deps);
+        return this.setValue("plugins", plugins);
+    }
+    /**
+     * Update values for an existing configuration
+     * @param {Object} values
+     * @returns {Config}
+     */
+    updateValues(values) {
+        values = immutable_1.default.fromJS(values);
+        return this.set("values", values);
+    }
+    /**
+     * Update values for an existing configuration
+     * @param {Config} config
+     * @param {Object} values
+     * @returns {Config}
+     */
+    mergeValues(values) {
+        let currentValues = this.getValues();
+        values = immutable_1.default.fromJS(values);
+        currentValues = currentValues.mergeDeep(values);
+        return this.set("values", currentValues);
+    }
+    /**
+     * Create a new config for a file
+     * @param {File} file
+     * @param {Object} values
+     * @returns {Config}
+     */
+    static create(file, values) {
+        return new Config({
+            file: file,
+            values: immutable_1.default.fromJS(values),
+        });
+    }
+    /**
+     * Create a new config
+     * @param {Object} values
+     * @returns {Config}
+     */
+    static createWithValues(values) {
+        return new Config({
+            values: immutable_1.default.fromJS(values),
+        });
+    }
+    /**
+     * Convert a keyPath to an array of keys
+     */
+    static keyToKeyPath(keyPath) {
+        if (typeof keyPath === "string") {
+            return keyPath.split(".");
+        }
+        return keyPath;
+    }
+}
+exports.default = Config;