tortilla/dist/paths.js

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
Object.defineProperty(exports, "__esModule", { value: true });
var Path = require("path");
var utils_1 = require("./utils");
/**
 It is important to use absolute paths and not relative paths since some helpers
 are distributed over several processes whose execution path is not always the same,
 therefore this module was created.
 */
var cache = {};
var resolve = Path.resolve.bind(Path);
var ascii = resolveTree(resolve(__dirname, 'ascii'), {
    views: resolve(__dirname, 'ascii/views'),
});
var renderer = resolveTree(resolve(__dirname, 'renderer'), {
    helpers: resolve(__dirname, 'renderer/helpers'),
    templates: resolve(__dirname, 'renderer/templates'),
});
var translator = resolveTree(resolve(__dirname, 'translator'), {
    translation: resolve(__dirname, 'translator/translation'),
    locales: resolve(__dirname, 'translator/locales'),
});
var tortilla = resolveTree(resolve(__dirname, '..'), {
    dump: resolve(__dirname, 'dump.js'),
    editor: resolve(__dirname, 'editor.js'),
    essentials: resolve(__dirname, 'essentials.js'),
    git: resolve(__dirname, 'git.js'),
    initializer: resolve(__dirname, 'initializer.js'),
    localCache: resolve(__dirname, 'local-cache.js'),
    localStorage: resolve(__dirname, 'local-storage.js'),
    manual: resolve(__dirname, 'manual.js'),
    package: resolve(__dirname, 'package.js'),
    paths: resolve(__dirname, 'paths.js'),
    rebase: resolve(__dirname, 'rebase.js'),
    release: resolve(__dirname, 'release.js'),
    step: resolve(__dirname, 'step.js'),
    submodule: resolve(__dirname, 'submodule.js'),
    utils: resolve(__dirname, 'utils.js'),
    skeleton: resolve(__dirname, 'skeleton.tar'),
    hooks: resolve(__dirname, 'hooks'),
    ascii: ascii,
    renderer: renderer,
    translator: translator,
});
var cli = resolveTree(resolve(__dirname, '../cli'), {
    tortilla: resolve(__dirname, 'cli/tortilla.js'),
    tortillaManual: resolve(__dirname, 'cli/tortilla-manual.js'),
    tortillaRelease: resolve(__dirname, 'cli/tortilla-release.js'),
    tortillaStep: resolve(__dirname, 'cli/tortilla-step.js'),
    tortillaStrict: resolve(__dirname, 'cli/tortilla-strict.js'),
    tortillaSubmodule: resolve(__dirname, 'cli/tortilla-submodule.js'),
});
// Makes the root path available in the branches object using a 'resolve()' method
// e.g. ('foo', { bar: 'bar' }) -> { resolve() -> 'foo', bar: 'bar' }
function resolveTree(root, branches) {
    branches = branches || {};
    return Object.keys(branches).reduce(function (tree, name) {
        tree[name] = branches[name];
        return tree;
    }, {
        resolve: Path.resolve.bind(Path, root),
    });
}
// Resolves a bunch of paths to a given tortilla project path
function resolveProject(cwd) {
    if (!cwd) {
        throw TypeError('A project path must be provided');
    }
    if (!process.env.TORTILLA_CACHE_DISABLED && cache[cwd]) {
        return cache[cwd];
    }
    var gitHeads = resolveTree(resolve(cwd, '.git/HEAD'), {
        cherryPick: resolve(cwd, '.git/CHERRY_PICK_HEAD'),
        orig: resolve(cwd, '.git/ORIG_HEAD'),
        revert: resolve(cwd, '.git/REVERT_HEAD'),
    });
    var gitMessages = {
        commit: resolve(cwd, '.git/COMMIT_EDITMSG'),
        merge: resolve(cwd, '.git/MERGE_MSG'),
        squash: resolve(cwd, '.git/SQUASH_MSG'),
    };
    var gitRefs = resolveTree(resolve(cwd, '.git/refs'), {
        heads: resolve(cwd, '.git/refs/heads'),
        remotes: resolve(cwd, '.git/refs/remotes'),
        tags: resolve(cwd, '.git/refs/tags'),
    });
    var git = resolveTree(resolve(cwd, '.git'), {
        ignore: resolve(cwd, '.gitignore'),
        hooks: resolve(cwd, '.git/hooks'),
        rebaseApply: resolve(cwd, '.git/rebase-apply'),
        rebaseMerge: resolve(cwd, '.git/rebase-merge'),
        modules: resolve(cwd, '.git/modules'),
        heads: gitHeads,
        messages: gitMessages,
        refs: gitRefs,
    });
    var npm = {
        ignore: resolve(cwd, '.npmignore'),
        package: resolve(cwd, 'package.json'),
        modules: resolve(cwd, 'node_modules'),
    };
    var manuals = resolveTree(resolve(cwd, '.tortilla/manuals'), {
        templates: resolve(cwd, '.tortilla/manuals/templates'),
        views: resolve(cwd, '.tortilla/manuals/views'),
    });
    var r = cache[cwd] = resolveTree(cwd, {
        tortillaDir: resolve(cwd, '.tortilla'),
        config: resolve(cwd, '.tortilla/config.js'),
        locales: resolve(cwd, '.tortilla/locales'),
        readme: resolve(cwd, 'README.md'),
        renovate: resolve(cwd, 'renovate.json'),
        storage: resolve(cwd, '.git/.tortilla'),
        gitModules: resolve(cwd, '.gitmodules'),
        travis: resolve(cwd, '.travis.yml'),
        manuals: manuals,
        tortilla: tortilla,
        cli: cli,
        git: git,
        npm: npm,
        resolveTree: resolveTree,
        resolveProject: resolveProject,
    });
    return r;
}
exports.resolveProject = resolveProject;
// Clone is necessary otherwise the original cache might be accidentally modified
exports.Paths = __assign({}, resolveProject(utils_1.Utils.cwd()));
// The same instance of the exported Paths module should reference different values
utils_1.Utils.on('cwdChange', function (cwd) {
    Object.assign(exports.Paths, resolveProject(cwd));
});
//# sourceMappingURL=paths.js.map