tortilla/dist/manual.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Fs = require("fs-extra");
var Minimist = require("minimist");
var Path = require("path");
var config_1 = require("./config");
var git_1 = require("./git");
var paths_1 = require("./paths");
var renderer_1 = require("./renderer");
var step_1 = require("./step");
var translator_1 = require("./translator");
var utils_1 = require("./utils");
// register custom transforations from ./tortilla/config.js
config_1.Config.registerCustomTransformations();
/**
 Contains manual related utilities.
 */
function init() {
    if (require.main !== module) {
        return;
    }
    var argv = Minimist(process.argv.slice(2), {
        string: ['_'],
        boolean: ['all', 'root'],
    });
    var method = argv._[0];
    var step = argv._[1];
    var all = argv.all;
    var root = argv.root;
    if (!step && all) {
        step = 'all';
    }
    if (!step && root) {
        step = 'root';
    }
    switch (method) {
        case 'render':
            return renderManual(step);
    }
}
init();
// Converts manual into the opposite format
function renderManual(step) {
    if (typeof step === 'string') {
        var isSuperStep = !step.split('.')[1];
        if (!isSuperStep) {
            throw TypeError('Provided step must be a super step');
        }
    }
    else {
        var superMessage = step_1.Step.recentSuperCommit('%s') || '';
        var stepDescriptor = step_1.Step.descriptor(superMessage) || {};
        step = stepDescriptor.number || 'root';
    }
    // Convert all manuals since the beginning of history
    if (step === 'all') {
        return git_1.Git.print(['rebase', '-i', '--root', '--keep-empty'], {
            env: {
                GIT_SEQUENCE_EDITOR: "node " + paths_1.Paths.tortilla.editor + " render",
            },
        });
    }
    // Indicates whether we should continue rebasing at the end of the invocation.
    // If this script is not run by the git editor we should continue rebasing
    var shouldContinue = !git_1.Git.rebasing();
    // Enter rebase, after all this is what rebase-continue is all about
    if (shouldContinue) {
        utils_1.Utils.scopeEnv(step_1.Step.edit.bind(step_1.Step, step), {
            TORTILLA_STDIO: 'ignore',
        });
    }
    var localesDir = paths_1.Paths.manuals.templates + "/locales";
    var locales = [''];
    if (utils_1.Utils.exists(localesDir)) {
        locales = locales.concat(Fs.readdirSync(localesDir));
    }
    // Render manual for each locale
    locales.forEach(function (locale) {
        // Fetch the current manual and other useful models
        var manualTemplatePath = getManualTemplatePath(step, locale);
        var manualTemplate = Fs.readFileSync(manualTemplatePath, 'utf8');
        var manualViewPath = getManualViewPath(step, locale);
        var commitMessage = getStepCommitMessage(step);
        var manualView = renderManualView(manualTemplate, {
            step: step,
            commitMessage: commitMessage,
            templatePath: manualTemplatePath,
            viewPath: manualViewPath,
            language: locale,
        });
        // Rewrite manual
        Fs.ensureDir(paths_1.Paths.manuals.views);
        // In case a custom render target is specified, ensure its dir exists
        var target = process.env.TORTILLA_RENDER_TARGET;
        if (target) {
            var customTargetDir = Path.resolve(paths_1.Paths.manuals.views, target);
            Fs.ensureDir(customTargetDir);
        }
        Fs.ensureDirSync(Path.dirname(manualViewPath));
        Fs.writeFileSync(manualViewPath, manualView);
        // Amend changes
        git_1.Git(['add', manualViewPath]);
        // The following code is dedicated for locale-free manuals
        if (locale) {
            return;
        }
        var symlinkPath = Path.resolve(paths_1.Paths.manuals.views, 'root.md');
        // If this is the root step, create a symlink to README.md if not yet exists
        if (step !== 'root' || utils_1.Utils.exists(symlinkPath)) {
            return;
        }
        var relativeSymlink = Path.relative(Path.dirname(symlinkPath), manualViewPath);
        Fs.symlinkSync(relativeSymlink, symlinkPath);
        git_1.Git(['add', symlinkPath]);
    });
    if (shouldContinue || git_1.Git.stagedFiles().length) {
        git_1.Git.print(['commit', '--amend'], {
            env: {
                GIT_EDITOR: true,
            },
        });
    }
    if (shouldContinue) {
        git_1.Git.print(['rebase', '--continue'], {
            env: {
                GIT_EDITOR: true,
            },
        });
    }
}
// Renders manual template into informative view
function renderManualView(manual, scope) {
    var header;
    var body;
    var footer;
    translator_1.Translator.scopeLanguage(scope.language, function () {
        header = renderer_1.Renderer.renderTemplateFile('header', scope);
        body = renderer_1.Renderer.renderTemplate(manual, scope);
        footer = renderer_1.Renderer.renderTemplateFile('footer', scope);
    });
    return [header, body, footer].join('\n');
}
// Gets the manual template belonging to the given step
function getManualTemplatePath(step, locale) {
    locale = locale ? ("locales/" + locale) : '';
    var baseDir = Path.resolve(paths_1.Paths.manuals.templates, locale);
    var fileName = step === 'root' ? 'root.tmpl' : ("step" + step + ".tmpl");
    return Path.resolve(baseDir, fileName);
}
// Gets the manual view belonging to the given step
function getManualViewPath(step, locale) {
    locale = locale ? ("locales/" + locale) : '';
    // The sub-dir of our views in case a custom render target is specified
    var subDir = process.env.TORTILLA_RENDER_TARGET || '';
    var fileName = step === 'root' ? 'root.md' : ("step" + step + ".md");
    // If sub-dir exists, return its path e.g. manuals/view/medium
    if (subDir) {
        return Path.resolve(paths_1.Paths.manuals.views, subDir, locale, fileName);
    }
    // If we're trying to render root step, return README.md
    if (step === 'root' && !locale) {
        return paths_1.Paths.readme;
    }
    // Resolve normally e.g. manuals/views/step1.md
    return Path.resolve(paths_1.Paths.manuals.views, locale, fileName);
}
// Gets the commit message belonging to the given step
function getStepCommitMessage(step) {
    if (step === 'root') {
        var rootHash = git_1.Git.rootHash();
        return git_1.Git(['log', '-1', rootHash, '--format=%s']);
    }
    return git_1.Git(['log', '-1', '--grep', "^Step " + step + ":", '--format=%s']);
}
exports.Manual = {
    render: renderManual,
    manualTemplatePath: getManualTemplatePath,
    manualViewPath: getManualViewPath,
};
//# sourceMappingURL=manual.js.map