adding mermaid packages

node_modules/gitbook-cli/lib/commands.js

@@ -0,0 +1,65 @@
+var _ = require('lodash');
+
+// Helper function for print help
+// indented output by spaces
+function indent_output(n, name, description) {
+    if (!n) {
+        n = 0;
+    }
+    
+    console.log(
+        _.repeat('    ', n)
+        + name
+        + _.repeat(' ', 32 - n * 4 - name.length)
+        + description
+    );
+}
+
+// Print help for a list of commands
+// It prints the command and its description, then all the options
+function help(commands) {
+    _.each(commands, function(command) {
+        indent_output(1, command.name, command.description);
+        _.each(command.options || [], function(option) {
+            var after = [];
+
+            if (option.defaults !== undefined) after.push("Default is "+option.defaults);
+            if (option.values) after.push("Values are "+option.values.join(", "));
+
+            if (after.length > 0) after = "("+after.join("; ")+")";
+            else after = "";
+
+            var optname = '--';
+            if (typeof option.defaults === 'boolean') optname += '[no-]';
+            optname += option.name;
+            indent_output(2, optname, option.description + ' ' + after);
+        });
+        console.log('');
+    });
+}
+
+// Execute a command from a list
+// with a specific set of args/kwargs
+function exec(commands, command, args, kwargs) {
+    var cmd = _.find(commands, function(_cmd) {
+        return _.first(_cmd.name.split(" ")) == command;
+    });
+
+    // Command not found
+    if (!cmd) throw new Error('Command '+command+' doesn\'t exist, run "gitbook help" to list commands.');
+
+    // Apply defaults
+    _.each(cmd.options || [], function(option) {
+        kwargs[option.name] = (kwargs[option.name] === undefined)? option.defaults : kwargs[option.name];
+        if (option.values && !_.includes(option.values, kwargs[option.name])) {
+            throw new Error('Invalid value for option "'+option.name+'"');
+        }
+    });
+
+    return cmd.exec(args, kwargs);
+}
+
+module.exports = {
+    help: help,
+    exec: exec
+};

node_modules/gitbook-cli/lib/config.js

@@ -0,0 +1,41 @@
+var path = require('path');
+var fs = require('fs-extra');
+var color = require('bash-color');
+var userHome = require('user-home');
+
+var CONFIG_ROOT = process.env.GITBOOK_DIR;
+if (!CONFIG_ROOT) {
+    if (!userHome) {
+        console.log(color.red('HOME or GITBOOK_DIR needs to be defined'));
+        process.exit(1);
+    }
+
+    CONFIG_ROOT = path.resolve(userHome, '.gitbook');
+}
+var VERSIONS_ROOT = path.resolve(CONFIG_ROOT, 'versions');
+
+
+// Init and prepare configuration for gitbook-cli
+// It creates the required folder
+function init() {
+    fs.mkdirsSync(CONFIG_ROOT);
+    fs.mkdirsSync(VERSIONS_ROOT);
+}
+
+// Replace root folder to use
+function setRoot(root) {
+    CONFIG_ROOT = path.resolve(root);
+    VERSIONS_ROOT = path.resolve(CONFIG_ROOT, 'versions');
+
+    module.exports.ROOT = CONFIG_ROOT;
+    module.exports.VERSIONS_ROOT = VERSIONS_ROOT;
+}
+
+module.exports = {
+    init: init,
+    setRoot: setRoot,
+
+    GITBOOK_VERSION: '>1.x.x',
+    ROOT: CONFIG_ROOT,
+    VERSIONS_ROOT: VERSIONS_ROOT
+};

node_modules/gitbook-cli/lib/index.js

@@ -0,0 +1,121 @@
+var Q = require('q');
+var _ = require('lodash');
+var path = require('path');
+
+var config = require('./config');
+var local = require('./local');
+var registry = require('./registry');
+var tags = require('./tags');
+
+// Return book version (string) required by a book
+function bookVersion(bookRoot) {
+    var version;
+
+    try {
+        var bookJson = require(path.resolve(bookRoot, 'book'));
+        version = bookJson.gitbook;
+    } catch (e) {
+        if (e.code != 'MODULE_NOT_FOUND') throw e;
+    }
+
+    return version || '*';
+}
+
+// Ensure that a version exists
+// or install it
+function ensureVersion(bookRoot, version, opts) {
+    opts = _.defaults(opts || {}, {
+        install: true
+    });
+
+    return Q()
+
+    // If not defined, load version required from book.json
+    .then(function() {
+        if (version) return version;
+        return bookVersion(bookRoot);
+    })
+
+    // Resolve version locally
+    .then(function(_version) {
+        version = _version;
+        return local.resolve(version)
+        // Install if needed
+        .fail(function(err) {
+            if (!opts.install) throw err;
+
+            return registry.install(version)
+            .then(function() {
+                return ensureVersion(bookRoot, version, {
+                    install: false
+                });
+            });
+        });
+    });
+}
+
+// Get version in a book
+function getVersion(bookRoot, version) {
+    return ensureVersion(bookRoot, version, {
+        install: false
+    });
+}
+
+// Ensure a version exists (or install it)
+// Then load it and returns the gitbook instance
+function ensureAndLoad(bookRoot, version, opts) {
+    return ensureVersion(bookRoot, version, opts)
+    .then(function(version) {
+        return local.load(version);
+    });
+}
+
+// Update current version
+//   -> Check that a newer version exists
+//   -> Install it
+//   -> Remove previous version
+function updateVersion(tag) {
+    tag = tag || 'latest';
+
+    return getVersion(null, {
+        install: false
+    })
+    .fail(function(err) {
+        return Q(null);
+    })
+    .then(function(currentV) {
+        return registry.versions()
+        .then(function(result) {
+            var remoteVersion = result.tags[tag];
+            if (!remoteVersion) throw new Error('Tag doesn\'t exist: '+tag);
+
+            if (currentV && tags.sort(remoteVersion, currentV.version) >= 0) return null;
+
+            return registry.install(remoteVersion)
+            .then(function() {
+                if (!currentV) return;
+                return local.remove(currentV.tag);
+            })
+            .thenResolve(remoteVersion);
+        });
+    });
+}
+
+module.exports = {
+    init: config.init,
+    setRoot: config.setRoot,
+
+    load: local.load,
+    get: getVersion,
+    getBookVersion: bookVersion,
+    ensure: ensureVersion,
+    ensureAndLoad: ensureAndLoad,
+    uninstall: local.remove,
+    link: local.link,
+    versions: local.versions,
+
+    update: updateVersion,
+
+    install: registry.install,
+    available: registry.versions
+};

node_modules/gitbook-cli/lib/local.js

@@ -0,0 +1,129 @@
+var Q = require('q');
+var fs = require('fs-extra');
+var path = require('path');
+var _ = require('lodash');
+var npmi = require('npmi');
+var npm = require('npm');
+var tmp = require('tmp');
+var color = require('bash-color');
+var parsedArgv = require('optimist').argv;
+
+var config = require('./config');
+var tags = require('./tags');
+
+// Return a list of all available versions on this system
+function listVersions() {
+    var folders = fs.readdirSync(config.VERSIONS_ROOT);
+    var latest = null;
+
+    return _.chain(folders)
+        .map(function(tag) {
+            // Verison matches requirements?
+            if (!tags.isValid(tag)) return null;
+
+            // Read package.json to determine version
+            var versionFolder = path.resolve(config.VERSIONS_ROOT, tag);
+            var stat = fs.lstatSync(versionFolder);
+            var pkg;
+
+            try {
+                pkg = require(path.resolve(versionFolder, 'package.json'));
+            } catch(e) {
+                return null;
+            }
+
+            // Is it gitbook?
+            if (pkg.name != 'gitbook') return null;
+
+            return {
+                // The name associated in the folder
+                name: tag,
+
+                // The real absolute version
+                version: pkg.version,
+
+                // Location of this version
+                path: versionFolder,
+
+                // Location if it's a symlink
+                link: stat.isSymbolicLink()? fs.readlinkSync(versionFolder) : null,
+
+                // Type of release, latest, beta, etc ?
+                tag: tags.getTag(pkg.version)
+            };
+        })
+        .compact()
+
+        // Sort by the version
+        .sort(function(a, b) {
+            return tags.sort(a.version, b.version);
+        })
+        .value();
+}
+
+// Return path to a specific version
+function versionRoot(version) {
+    return path.resolve(config.VERSIONS_ROOT, version);
+}
+
+// Resolve a version using a condition
+function resolveVersion(condition) {
+    var versions = listVersions();
+    var version = _.chain(versions)
+        .find(function(v) {
+            return tags.satisfies(v.name, condition);
+        })
+        .value();
+
+    if (!version) return Q.reject(new Error('No version match: '+condition));
+    return Q(version);
+}
+
+// Remove an installed version of gitbook
+function removeVersion(version) {
+    if (!version) return Q.reject(new Error('No version specified'));
+    var outputFolder = versionRoot(version);
+
+    return Q.nfcall(fs.lstat.bind(fs), outputFolder)
+    .then(function(stat) {
+        if (stat.isSymbolicLink()) {
+            return Q.nfcall(fs.unlink.bind(fs), outputFolder);
+        }
+        return Q.nfcall(fs.remove.bind(fs), outputFolder);
+    });
+}
+
+// Load a gitbook version
+function loadVersion(version) {
+    return Q(_.isString(version)? resolveVersion(version) : version)
+    .then(function(resolved) {
+        var gitbook;
+
+        try {
+            gitbook = require(resolved.path);
+        } catch (err) {
+            console.log(color.red('Error loading version '+resolved.tag+': '+(err.stack || err.message || err)));
+            return null;
+        }
+
+        if (!gitbook) throw new Error('GitBook Version '+resolved.tag+' is corrupted');
+        return gitbook;
+    });
+}
+
+// Link a folder to a tag
+function linkVersion(name, folder) {
+    if (!name) return Q.reject(new Error('Require a name to represent this GitBook version'));
+    if (!folder) return Q.reject(new Error('Require a folder'));
+    var outputFolder = versionRoot(name);
+
+    return Q.nfcall(fs.symlink.bind(fs), folder, outputFolder);
+}
+
+module.exports = {
+    load: loadVersion,
+    resolve: resolveVersion,
+    versions: listVersions,
+    remove: removeVersion,
+    link: linkVersion
+};

node_modules/gitbook-cli/lib/registry.js

@@ -0,0 +1,110 @@
+var Q = require('q');
+var fs = require('fs-extra');
+var npmi = require('npmi');
+var npm = require('npm');
+var tmp = require('tmp');
+var _ = require('lodash');
+var path = require('path');
+
+var tags = require('./tags');
+var config = require('./config');
+
+// Initialize NPM before usage
+var initNPM = _.memoize(function() {
+    return Q.nfcall(npm.load, {
+        silent: true,
+        loglevel: 'silent'
+    });
+});
+
+// Return a list of versions available in the registry (npm)
+function availableVersions() {
+    return initNPM()
+    .then(function() {
+        return Q.nfcall(npm.commands.view, ['gitbook', 'versions', 'dist-tags'], true);
+    })
+    .then(function(result) {
+        result = _.chain(result).values().first().value();
+        result = {
+            versions: _.chain(result.versions)
+                .filter(function(v) {
+                    return tags.isValid(v);
+                })
+                .sort(tags.sort)
+                .value(),
+            tags: _.chain(result['dist-tags'])
+                .omit(function(tagVersion, tagName) {
+                    return !tags.isValid(tagVersion);
+                })
+                .value()
+        };
+
+        if (result.versions.length == 0) throw new Error('No valid version on the NPM registry');
+        return result;
+    });
+}
+
+// Resolve a version name or tag to an installable absolute version
+function resolveVersion(version) {
+    var _version = version;
+
+    return availableVersions()
+    .then(function(available) {
+        // Resolve if tag
+        if (available.tags[version]) version = available.tags[version];
+
+        version = _.find(available.versions, function(v) {
+            return tags.satisfies(v, version, {
+                // Tag is resolved from npm dist-tags
+                acceptTagCondition: false
+            });
+        });
+
+        // Check version
+        if (!version) throw new Error('Invalid version or tag "'+_version+'", see available using "gitbook ls-remote"');
+        return version;
+    });
+}
+
+// Install a specific version of gitbook
+function installVersion(version, forceInstall) {
+    return resolveVersion(version)
+    .then(function(_version) {
+        version = _version;
+        return Q.nfcall(tmp.dir.bind(tmp));
+    })
+    .spread(function(tmpDir) {
+        var options = {
+            name: 'gitbook',
+            version: version,
+            path: tmpDir,
+            forceInstall: !!forceInstall,
+            npmLoad: {
+                loglevel: 'silent',
+                loaded: false,
+                prefix: tmpDir
+            }
+        };
+        console.log('Installing GitBook', version);
+        return Q.nfcall(npmi.bind(npmi), options).thenResolve(tmpDir);
+    })
+    .then(function(tmpDir) {
+        var gitbookRoot = path.resolve(tmpDir, 'node_modules/gitbook');
+        var packageJson = fs.readJsonSync(path.resolve(gitbookRoot, 'package.json'));
+        var version = packageJson.version;
+
+        var outputFolder = path.resolve(config.VERSIONS_ROOT, version);
+
+        if (!tags.isValid(version)) throw 'Invalid GitBook version, should satisfies '+config.GITBOOK_VERSION;
+
+        // Copy to the install folder
+        return Q.nfcall(fs.copy.bind(fs), gitbookRoot, outputFolder)
+        .thenResolve(version);
+    });
+}
+
+module.exports = {
+    versions: availableVersions,
+    resolve: resolveVersion,
+    install: installVersion
+};

node_modules/gitbook-cli/lib/tags.js

@@ -0,0 +1,81 @@
+var _ = require('lodash');
+var semver = require('semver');
+var config = require('./config');
+
+var ALLOWED_TAGS = ['latest', 'pre', 'beta', 'alpha'];
+
+// Returns true if a version is a tag
+function isTag(version) {
+    return _.includes(ALLOWED_TAGS, version);
+}
+
+// Return true if a version matches gitbook-cli's requirements
+function isValid(version) {
+    if (isTag(version)) return true;
+
+    var versionWithoutPre = version.replace(/\-(\S+)/g, '');
+
+    try {
+        return semver.satisfies(versionWithoutPre, config.GITBOOK_VERSION);
+    } catch(e) {
+        return false;
+    }
+}
+
+// Extract prerelease tag from a version
+function getTag(version) {
+    if (isTag(version)) return version;
+
+    var v = semver.parse(version);
+    return v.prerelease[0] || 'latest';
+}
+
+// Sort versions (tale prerelease tags in consideration)
+function sortTags(a, b) {
+    if (isTag(a) && isTag(b)) {
+        var indexA = ALLOWED_TAGS.indexOf(a);
+        var indexB = ALLOWED_TAGS.indexOf(b);
+
+        if (indexA > indexB) return -1;
+        if (indexB > indexA) return 1;
+
+        return 0;
+    }
+    if (isTag(a)) return -1;
+    if (isTag(b)) return 1;
+
+    if (semver.gt(a, b)) {
+        return -1;
+    }
+    if (semver.lt(a, b)) {
+        return 1;
+    }
+    return 0;
+}
+
+// Returns true if a version satisfies a condition
+function satisfies(version, condition, opts) {
+    opts = _.defaults(opts || {}, {
+        acceptTagCondition: true
+    });
+
+    if (isTag(version)) {
+        return (condition == '*' || version == condition);
+    }
+
+    // Condition is a tag ('beta', 'latest')
+    if (opts.acceptTagCondition) {
+        var tag = getTag(version);
+        if (tag == condition) return true;
+    }
+
+    return semver.satisfies(version, condition);
+}
+
+module.exports = {
+    isTag: isTag,
+    isValid: isValid,
+    sort: sortTags,
+    satisfies: satisfies,
+    getTag: getTag
+};