tortilla/dist/step.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
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 prompt_1 = require("./prompt");
var Rebase = require("./rebase");
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);
    // If file exists, use it instead of overriding it
    if (!Fs.existsSync(manualTemplatePath)) {
        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);
}
// The opposite of git rebase --continue: Will step back to the previously edited step
function stepBack(targetStep, options) {
    if (options === void 0) { options = { interactive: false }; }
    return __awaiter(this, void 0, void 0, function () {
        var previousSteps, times;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    if (!git_1.Git.rebasing()) {
                        throw Error('fatal: No rebase in progress?');
                    }
                    previousSteps = Rebase.getPreviousEditedSteps();
                    if (!previousSteps.length) {
                        throw Error('No previous steps found');
                    }
                    if (!targetStep) return [3 /*break*/, 1];
                    // Multiplier e.g. x3
                    if (/x\d+/.test(targetStep)) {
                        times = Number(targetStep.match(/x(\d+)/)[1]);
                        targetStep = previousSteps[times - 1];
                    }
                    // Step e.g. 1.1
                    else if (!/\d+(\.\d+)?/.test(targetStep)) {
                        throw TypeError('Provided argument is neither a step or a multiplier');
                    }
                    return [3 /*break*/, 4];
                case 1:
                    if (!options.interactive) return [3 /*break*/, 3];
                    return [4 /*yield*/, prompt_1.prompt([
                            {
                                type: 'list',
                                name: 'stepback',
                                message: 'Which step would you like to go back to?',
                                choices: previousSteps,
                            }
                        ])];
                case 2:
                    targetStep = _a.sent();
                    return [3 /*break*/, 4];
                case 3:
                    targetStep = previousSteps[0];
                    _a.label = 4;
                case 4:
                    if (!targetStep) {
                        throw TypeError('targetStep must be provided');
                    }
                    // Make sure it's actually relevant
                    if (previousSteps.every(function (s) { return s !== targetStep; })) {
                        throw TypeError("Provided target step " + targetStep + " was not edited");
                    }
                    // After retrieving target step, this is where the magic happens
                    // Message will be printed over here
                    Rebase.hardResetRebaseState(targetStep);
                    return [2 /*return*/];
            }
        });
    });
}
// 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();
    var allSteps = getAllSteps();
    steps = [].concat(steps).filter(Boolean);
    // Unwrap ranges, e.g.
    // 1...3.1 may become 1 2.1 2.2 2.3 2 3.1
    steps = steps.reduce(function (flattened, step) {
        var range = step.match(/(\d+(?:\.\d+)?)?\.\.(?:\.+)?(\d+(?:\.\d+)?)?/);
        if (!range) {
            return flattened.concat(step);
        }
        var start = range[1] || 'root';
        var end = range[2] || allSteps[allSteps.length - 1];
        var startIndex = allSteps.findIndex(function (s) { return s === start; });
        var endIndex = allSteps.findIndex(function (s) { return s === end; });
        if (startIndex === -1) {
            startIndex = 0;
        }
        if (endIndex === -1) {
            startIndex = Infinity;
        }
        return flattened.concat(allSteps.slice(startIndex, endIndex + 1));
    }, []);
    // Map git-refs to step indexes
    steps = steps.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);
    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));
    });
    // 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);
    }
    // Initialize rebase_states git project
    Fs.removeSync(paths_1.Paths.rebaseStates);
    git_1.Git(['init', paths_1.Paths.rebaseStates]);
    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));
}
// Gets a list of all steps, from root to the most recent step
function getAllSteps() {
    var allSteps = git_1.Git(['log', '--grep=^Step [0-9]\\+.\\?[0-9]*:', '--format=%s'])
        .split('\n')
        .map(function (message) { return getStepDescriptor(message); })
        .filter(Boolean)
        .map(function (descriptor) { return descriptor.number; })
        .reverse();
    allSteps.unshift('root');
    return allSteps;
}
/**
 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,
    back: stepBack,
    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,
    all: getAllSteps,
};
//# sourceMappingURL=step.js.map