tortilla/dist/step.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Fs = require("fs-extra");
var Minimist = require("minimist");
var Path = require("path");
var git_1 = require("./git");
var local_storage_1 = require("./local-storage");
var paths_1 = require("./paths");
var utils_1 = require("./utils");
// Get recent commit by specified arguments
function getRecentCommit(offset, format, grep) {
    if (typeof offset === 'string') {
        if (!grep) {
            grep = format;
        }
        format = offset;
        offset = 0;
    }
    var argv = [];
    if (format) {
        argv.push("--format=" + format);
    }
    if (grep) {
        argv.push("--grep=" + grep);
    }
    return git_1.Git.recentCommit(offset, argv);
}
// Get the recent step commit
function getRecentStepCommit(offset, format) {
    return getRecentCommit(offset, format, '^Step [0-9]\\+');
}
// Get the recent super step commit
function getRecentSuperStepCommit(offset, format) {
    return getRecentCommit(offset, format, '^Step [0-9]\\+:');
}
// Get the recent sub step commit
function getRecentSubStepCommit(offset, format) {
    return getRecentCommit(offset, format, '^Step [0-9]\\+\\.[0-9]\\+:');
}
// Extract step json from message
function getStepDescriptor(message) {
    if (message == null) {
        throw TypeError('A message must be provided');
    }
    var match = message.match(/^Step (\d+(?:\.\d+)?)\: ((?:.|\n)*)$/);
    return match && {
        number: match[1],
        message: match[2],
        type: match[1].split('.')[1] ? 'sub' : 'super',
    };
}
// Extract super step json from message
function getSuperStepDescriptor(message) {
    if (message == null) {
        throw TypeError('A message must be provided');
    }
    var match = message.match(/^Step (\d+)\: ((?:.|\n)*)$/);
    return match && {
        number: Number(match[1]),
        message: match[2],
    };
}
// Extract sub step json from message
function getSubStepDescriptor(message) {
    if (message == null) {
        throw TypeError('A message must be provided');
    }
    var match = message.match(/^Step ((\d+)\.(\d+))\: ((?:.|\n)*)$/);
    return match && {
        number: match[1],
        superNumber: Number(match[2]),
        subNumber: Number(match[3]),
        message: match[4],
    };
}
// Push a new step with the provided message
function pushStep(message, options) {
    var step = getNextStep();
    commitStep(step, message, options);
    // Meta-data for step editing
    local_storage_1.localStorage.setItem('REBASE_NEW_STEP', step);
}
// Pop the last step
function popStep() {
    var headHash = git_1.Git(['rev-parse', 'HEAD']);
    var rootHash = git_1.Git.rootHash();
    if (headHash === rootHash) {
        throw Error("Can't remove root");
    }
    var removedCommitMessage = git_1.Git.recentCommit(['--format=%s']);
    var stepDescriptor = getStepDescriptor(removedCommitMessage);
    git_1.Git.print(['reset', '--hard', 'HEAD~1']);
    // Meta-data for step editing
    if (stepDescriptor) {
        local_storage_1.localStorage.setItem('REBASE_NEW_STEP', getCurrentStep());
        // This will be used later on to update the manuals
        if (ensureStepMap()) {
            updateStepMap('remove', { step: stepDescriptor.number });
        }
        // Delete branch referencing the super step unless we're rebasing, in which case the
        // branches will be reset automatically at the end of the rebase
        if (stepDescriptor.type === 'super' && !git_1.Git.rebasing()) {
            var branch = git_1.Git.activeBranchName();
            git_1.Git(['branch', '-D', branch + "-step" + stepDescriptor.number]);
        }
    }
    else {
        console.warn('Removed commit was not a step');
        return;
    }
}
// Finish the current with the provided message and tag it
function tagStep(message) {
    var step = getNextSuperStep();
    var tag = "step" + step;
    var manualFile = tag + ".tmpl";
    var manualTemplatePath = Path.resolve(paths_1.Paths.manuals.templates, manualFile);
    Fs.ensureDirSync(paths_1.Paths.manuals.templates);
    Fs.ensureDirSync(paths_1.Paths.manuals.views);
    Fs.writeFileSync(manualTemplatePath, '');
    git_1.Git(['add', manualTemplatePath]);
    commitStep(step, message);
    // If we're in edit mode all the branches will be set after the rebase
    if (!git_1.Git.rebasing()) {
        var branch = git_1.Git.activeBranchName();
        // This branch will be used to run integration testing
        git_1.Git(['branch', branch + "-step" + step]);
    }
    // Meta-data for step editing
    local_storage_1.localStorage.setItem('REBASE_NEW_STEP', step);
}
// Get the hash of the step followed by ~1, mostly useful for a rebase
function getStepBase(step) {
    if (!step) {
        var message = getRecentStepCommit('%s');
        if (!message) {
            return '--root';
        }
        step = getStepDescriptor(message).number;
    }
    if (step === 'root') {
        return '--root';
    }
    var hash = git_1.Git.recentCommit([
        "--grep=^Step " + step + ":",
        '--format=%h',
    ]);
    if (!hash) {
        throw Error('Step not found');
    }
    return hash + "~1";
}
// Edit the provided step
function editStep(steps, options) {
    if (options === void 0) { options = {}; }
    var rootSha1 = git_1.Git.rootHash();
    // Map git-refs to step indexes
    steps = [].concat(steps).filter(Boolean).map(function (step) {
        // If an index was provided, return it; otherwise try to find the index by SHA1
        if (/^\d{1,5}(\.\d+)?$/.test(step) || step === 'root') {
            return step;
        }
        if (step === rootSha1) {
            return 'root';
        }
        var commitMessage = git_1.Git(['log', step, '-1', '--format=%s']);
        var descriptor = getStepDescriptor(commitMessage);
        return descriptor && descriptor.number;
    }).filter(Boolean);
    if (steps instanceof Array) {
        steps = steps.slice().sort(function (a, b) {
            var _a = a.split('.').concat('Infinity'), superA = _a[0], subA = _a[1];
            var _b = b.split('.').concat('Infinity'), superB = _b[0], subB = _b[1];
            // Always put the root on top
            if (a === 'root') {
                return -1;
            }
            if (b === 'root') {
                return 1;
            }
            // Put first steps first
            return ((superA - superB) ||
                (subA - subB));
        });
    }
    else {
        steps = [steps];
    }
    // The would always have to start from the first step
    var base = getStepBase(steps[0]);
    // '--root' might be fetched in case no steps where provided. We need to fill up
    // this missing information in the steps array
    if (!steps.length && base === '--root') {
        steps[0] = 'root';
    }
    var argv = [paths_1.Paths.tortilla.editor, 'edit'].concat(steps);
    // Update diffSteps
    if (options.udiff != null) {
        argv.push('--udiff');
    }
    // Update diffSteps in another repo
    if (options.udiff) {
        argv.push(options.udiff.toString());
    }
    // Storing locally so it can be used in further processes
    // Indicates that this operation is hooked into a submodule
    if (process.env.TORTILLA_SUBMODULE_CWD) {
        local_storage_1.localStorage.setItem('SUBMODULE_CWD', process.env.TORTILLA_SUBMODULE_CWD);
    }
    git_1.Git.print(['rebase', '-i', base, '--keep-empty'], {
        env: {
            GIT_SEQUENCE_EDITOR: "node " + argv.join(' '),
        },
    });
}
// Adjust all the step indexes from the provided step
function sortStep(step) {
    // If no step was provided, take the most recent one
    if (!step) {
        step = getRecentStepCommit('%s');
        step = getStepDescriptor(step);
        step = step ? step.number : 'root';
    }
    var newStep;
    var oldStep;
    var base;
    // If root, make sure to sort all step indexes since the beginning of history
    if (step === 'root') {
        newStep = '1';
        oldStep = 'root';
        base = '--root';
    }
    else { // Else, adjust only the steps in the given super step
        newStep = step.split('.').map(Number)[0];
        oldStep = newStep - 1 || 'root';
        newStep = newStep + "." + 1;
        base = getStepBase(newStep);
    }
    // Setting local storage variables so re-sortment could be done properly
    local_storage_1.localStorage.setItem('REBASE_NEW_STEP', newStep);
    local_storage_1.localStorage.setItem('REBASE_OLD_STEP', oldStep);
    git_1.Git.print(['rebase', '-i', base, '--keep-empty'], {
        env: {
            GIT_SEQUENCE_EDITOR: "node " + paths_1.Paths.tortilla.editor + " sort",
        },
    });
}
// Reword the provided step with the provided message
function rewordStep(step, message) {
    var base = getStepBase(step);
    var argv = [paths_1.Paths.tortilla.editor, 'reword'];
    if (message) {
        argv.push('-m', "\"" + message + "\"");
    }
    git_1.Git.print(['rebase', '-i', base, '--keep-empty'], {
        env: {
            GIT_SEQUENCE_EDITOR: "node " + argv.join(' '),
        },
    });
}
// Run git-show for given step index
function showStep(step) {
    var args = [];
    for (var _i = 1; _i < arguments.length; _i++) {
        args[_i - 1] = arguments[_i];
    }
    assertStep(step);
    step = step.split('.').join('\\.');
    var hash = git_1.Git(['log', "--grep=^Step " + step, '--format=%H']);
    if (!hash) {
        throw Error('Step not found');
    }
    git_1.Git.print(['show', hash].concat(args));
}
// Asserts whether provided string is a step index or not
function assertStep(step, silent) {
    if (silent === void 0) { silent = false; }
    if (typeof step !== 'string' && typeof step !== 'number') {
        if (silent) {
            return false;
        }
        throw TypeError('Provided argument is not of type string or number');
    }
    step = step.toString();
    if (!/\d+/.test(step) && !/\d+\.\d+/.test(step)) {
        if (silent) {
            return false;
        }
        throw TypeError('Provided argument is not a step');
    }
    return true;
}
// Add a new commit of the provided step with the provided message
function commitStep(step, message, options) {
    if (options === void 0) { options = {}; }
    var argv = ['commit'];
    if (message) {
        argv.push('-m', message);
    }
    if (options.allowEmpty) {
        argv.push('--allow-empty');
    }
    // Specified step is gonna be used for when forming the commit message
    local_storage_1.localStorage.setItem('HOOK_STEP', step);
    try {
        // commit
        git_1.Git.print(argv);
    }
    catch (err) {
        // Clearing storage to prevent conflicts with upcoming commits
        local_storage_1.localStorage.removeItem('HOOK_STEP');
        throw err;
    }
}
// Get the current step
function getCurrentStep() {
    // Probably root commit
    var recentStepCommit = getRecentStepCommit('%s');
    if (!recentStepCommit) {
        return 'root';
    }
    // Cover unexpected behavior
    var descriptor = getStepDescriptor(recentStepCommit);
    if (!descriptor) {
        return 'root';
    }
    return descriptor.number;
}
// Get the current super step
function getCurrentSuperStep() {
    // Probably root commit
    var recentStepCommit = getRecentSuperStepCommit('%s');
    if (!recentStepCommit) {
        return 'root';
    }
    // Cover unexpected behavior
    var descriptor = getSuperStepDescriptor(recentStepCommit);
    if (!descriptor) {
        return 'root';
    }
    return descriptor.number;
}
// Get the next step
function getNextStep(offset) {
    // Fetch data about recent step commit
    var stepCommitMessage = getRecentStepCommit(offset, '%s');
    var followedByStep = !!stepCommitMessage;
    // If no previous steps found return the first one
    if (!followedByStep) {
        return '1.1';
    }
    // Fetch data about current step
    var stepDescriptor = getStepDescriptor(stepCommitMessage);
    var stepNumbers = stepDescriptor.number.split('.');
    var superStepNumber = Number(stepNumbers[0]);
    var subStepNumber = Number(stepNumbers[1]);
    var isSuperStep = !subStepNumber;
    if (!offset) {
        // If this is a super step return the first sub step of a new step
        if (isSuperStep) {
            return superStepNumber + 1 + "." + 1;
        }
        // Else, return the next step as expected
        return superStepNumber + "." + (subStepNumber + 1);
    }
    // Fetch data about next step
    var nextStepCommitMessage = getRecentStepCommit(offset - 1, '%s');
    var nextStepDescriptor = getStepDescriptor(nextStepCommitMessage);
    var nextStepNumbers = nextStepDescriptor.number.split('.');
    var nextSubStepNumber = Number(nextStepNumbers[1]);
    var isNextSuperStep = !nextSubStepNumber;
    if (isNextSuperStep) {
        // If this is a super step return the next super step right away
        if (isSuperStep) {
            return (superStepNumber + 1).toString();
        }
        // Else, return the current super step
        return superStepNumber.toString();
    }
    // If this is a super step return the first sub step of the next step
    if (isSuperStep) {
        return superStepNumber + 1 + "." + 1;
    }
    // Else, return the next step as expected
    return superStepNumber + "." + (subStepNumber + 1);
}
// Get the next super step
function getNextSuperStep(offset) {
    return getNextStep(offset).split('.')[0];
}
// Pending flag indicates that this step map will be used in another tortilla repo
function initializeStepMap(pending) {
    var map = git_1.Git([
        'log', '--format=%s', '--grep=^Step [0-9]\\+',
    ])
        .split('\n')
        .filter(Boolean)
        .reduce(function (m, subject) {
        var num = getStepDescriptor(subject).number;
        m[num] = num;
        return m;
    }, {});
    local_storage_1.localStorage.setItem('STEP_MAP', JSON.stringify(map));
    if (pending) {
        local_storage_1.localStorage.setItem('STEP_MAP_PENDING', true);
    }
    else {
        local_storage_1.localStorage.removeItem('STEP_MAP_PENDING');
    }
}
// First argument represents the module we would like to read the steps map from
function getStepMap(submoduleCwd, checkPending) {
    var localStorage;
    // In case this process was launched from a submodule
    if (submoduleCwd) {
        localStorage = local_storage_1.localStorage.create(submoduleCwd);
    }
    else {
        localStorage = local_storage_1.localStorage;
    }
    if (ensureStepMap(submoduleCwd, checkPending)) {
        return JSON.parse(localStorage.getItem('STEP_MAP'));
    }
}
// Provided argument will run an extra condition to check whether the pending flag
// exists or not
function ensureStepMap(submoduleCwd, checkPending) {
    // Step map shouldn't be used in this process
    if (checkPending && local_storage_1.localStorage.getItem('STEP_MAP_PENDING')) {
        return false;
    }
    var paths;
    // In case this process was launched from a submodule
    if (submoduleCwd) {
        paths = paths_1.Paths.resolveProject(submoduleCwd);
    }
    else {
        paths = paths_1.Paths;
    }
    return utils_1.Utils.exists(Path.resolve(paths.storage, 'STEP_MAP'), 'file');
}
function disposeStepMap() {
    local_storage_1.localStorage.deleteItem('STEP_MAP');
    local_storage_1.localStorage.deleteItem('STEP_MAP_PENDING');
}
function updateStepMap(type, payload) {
    var map = getStepMap();
    switch (type) {
        case 'remove':
            delete map[payload.step];
            break;
        case 'reset':
            map[payload.oldStep] = payload.newStep;
            break;
    }
    local_storage_1.localStorage.setItem('STEP_MAP', JSON.stringify(map));
}
/**
 Contains step related utilities.
 */
(function () {
    if (require.main !== module) {
        return;
    }
    var argv = Minimist(process.argv.slice(2), {
        string: ['_', 'message', 'm'],
        boolean: ['root', 'udiff', 'allow-empty'],
    });
    var method = argv._[0];
    var step = argv._[1];
    var message = argv.message || argv.m;
    var root = argv.root;
    var allowEmpty = argv['allow-empty'];
    var udiff = argv.udiff;
    if (!step && root) {
        step = 'root';
    }
    var options = {
        allowEmpty: allowEmpty,
        udiff: udiff,
    };
    switch (method) {
        case 'push':
            return pushStep(message, options);
        case 'pop':
            return popStep();
        case 'tag':
            return tagStep(message);
        case 'edit':
            return editStep(step, options);
        case 'sort':
            return sortStep(step);
        case 'reword':
            return rewordStep(step, message);
    }
})();
exports.Step = {
    push: pushStep,
    pop: popStep,
    tag: tagStep,
    edit: editStep,
    sort: sortStep,
    reword: rewordStep,
    show: showStep,
    assert: assertStep,
    commit: commitStep,
    current: getCurrentStep,
    currentSuper: getCurrentSuperStep,
    next: getNextStep,
    nextSuper: getNextSuperStep,
    base: getStepBase,
    recentCommit: getRecentStepCommit,
    recentSuperCommit: getRecentSuperStepCommit,
    recentSubCommit: getRecentSubStepCommit,
    descriptor: getStepDescriptor,
    superDescriptor: getSuperStepDescriptor,
    subDescriptor: getSubStepDescriptor,
    initializeStepMap: initializeStepMap,
    getStepMap: getStepMap,
    ensureStepMap: ensureStepMap,
    disposeStepMap: disposeStepMap,
    updateStepMap: updateStepMap,
};
//# sourceMappingURL=step.js.map