tortilla/dist/editor.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 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 step_1 = require("./step");
var utils_1 = require("./utils");
/**
 This is the editor for interactive rebases and amended commits. Instead of opening
 an editing software like 'nano' or 'vim', this module will edit the file by specified
 methods we choose.
 */
function init() {
    if (require.main !== module) {
        return;
    }
    var argv = Minimist(process.argv.slice(2), {
        string: ['_', 'message', 'm', 'udiff'],
    });
    // The first argument will be the rebase file path provided to us by git
    var method = argv._[0];
    var steps = argv._.slice(1, -1);
    var rebaseFilePath = argv._[argv._.length - 1];
    // This method doesn't require us to parse operations, it just resets todo from a string
    if (method === 'reset-todo') {
        var todo = new local_storage_1.localStorage.native(paths_1.Paths.rebaseStates).getItem('TODO');
        Fs.writeFileSync(rebaseFilePath, todo);
        return;
    }
    var message = argv.message || argv.m;
    var udiff = argv.udiff;
    // Rebase file path will always be appended at the end of the arguments vector,
    // therefore udiff has to have a value, otherwise it will be matched with the wrong
    // argument
    var options = {
        udiff: udiff === 'true' ? '' : udiff,
    };
    var rebaseFileContent = Fs.readFileSync(rebaseFilePath, 'utf8');
    // Convert to array of jsons so it would be more comfortable to word with
    var operations = disassemblyOperations(rebaseFileContent);
    // Set flag just in case recent rebase was aborted
    local_storage_1.localStorage.removeItem('REBASE_HOOKS_DISABLED');
    // Automatically invoke a method by the provided arguments.
    // The methods will manipulate the operations array.
    switch (method) {
        case 'edit':
            editStep(operations, steps, options);
            break;
        case 'edit-head':
            editHead(operations);
            break;
        case 'sort':
            sortSteps(operations, options);
            break;
        case 'reword':
            rewordStep(operations, message);
            break;
        case 'render':
            renderManuals(operations);
            break;
    }
    // Put everything back together and rewrite the rebase file
    var newRebaseFileContent = assemblyOperations(operations);
    Fs.writeFileSync(rebaseFilePath, newRebaseFileContent);
}
init();
// Edit the last step in the rebase file
function editStep(operations, steps, options) {
    // Create initial step map
    // Note that udiff is a string, since it may very well specify a module path
    if (options.udiff != null) {
        // Providing pending flag
        step_1.Step.initializeStepMap(!!options.udiff);
    }
    if (!steps || steps.length === 0) {
        var descriptor = step_1.Step.descriptor(operations[0].message);
        var step = (descriptor && descriptor.number) || 'root';
        steps = [step];
    }
    // This way we can store data on each step string
    // We have to keep it as `new String` and not `String`!
    /* tslint:disable-next-line */
    steps = steps.map(function (step) { return new String(step); });
    // Edit each commit which is relevant to the specified steps
    steps.forEach(function (step) {
        if (String(step) === 'root') {
            var operation = operations[0];
            operation.method = 'edit';
            step.operation = operation;
        }
        else {
            var operation = operations.find(function (_a) {
                var message = _a.message;
                if (!message) {
                    return;
                }
                var descriptor = step_1.Step.descriptor(message);
                return descriptor && descriptor.number === String(step);
            });
            if (!operation) {
                return;
            }
            operation.method = 'edit';
            step.operation = operation;
        }
    });
    // Probably editing the recent step in which case no sorts are needed
    if (operations.length > 1) {
        // Prepare meta-data for upcoming sorts
        var descriptor = step_1.Step.descriptor(operations[0].message);
        // Step exists
        if (descriptor) {
            local_storage_1.localStorage.setItem('REBASE_OLD_STEP', descriptor.number);
            local_storage_1.localStorage.setItem('REBASE_NEW_STEP', descriptor.number);
        }
        else {
            local_storage_1.localStorage.setItem('REBASE_OLD_STEP', 'root');
            local_storage_1.localStorage.setItem('REBASE_NEW_STEP', 'root');
        }
        // Building sort command
        var sort_1 = "node " + paths_1.Paths.tortilla.editor + " sort";
        if (options.udiff) {
            sort_1 = sort_1 + " --udiff=" + options.udiff;
        }
        sort_1 = "GIT_SEQUENCE_EDITOR=\"" + sort_1 + "\"";
        var saveRebaseState_1 = "GIT_SEQUENCE_EDITOR=\"node " + paths_1.Paths.tortilla.rebase + " stash-rebase-state\"";
        // Continue sorting the steps after step editing has been finished
        steps.forEach(function (step) {
            var operation = step.operation;
            if (!operation) {
                return;
            }
            var index = operations.indexOf(operation);
            // Insert the following operation AFTER the step's operation
            operations.splice(index + 1, 0, {
                method: 'exec',
                command: sort_1 + " git rebase --edit-todo",
            });
            // Insert the following operation BEFORE the step's operation
            operations.splice(index, 0, {
                method: 'exec',
                command: saveRebaseState_1 + " git rebase --edit-todo",
            });
        });
    }
    // Whether we edit the most recent step or not, rebranching process should be initiated
    var rebranchSuper = "GIT_SEQUENCE_EDITOR=\"node " + paths_1.Paths.tortilla.rebase + " rebranch-super\"";
    // After rebase has finished, update the brancehs referencing the super steps
    operations.push({
        method: 'exec',
        command: rebranchSuper + " git rebase --edit-todo",
    });
}
// Adjusts upcoming step numbers in rebase
function sortSteps(operations, options) {
    // Grab meta-data
    var oldStep = local_storage_1.localStorage.getItem('REBASE_OLD_STEP');
    var newStep = local_storage_1.localStorage.getItem('REBASE_NEW_STEP');
    var submoduleCwd = local_storage_1.localStorage.getItem('SUBMODULE_CWD');
    // If delta is 0 no sorts are needed
    if (oldStep === newStep) {
        local_storage_1.localStorage.setItem('REBASE_HOOKS_DISABLED', 1);
        // Escape unless we need to update stepDiffs for submodules
        if (!submoduleCwd) {
            return;
        }
    }
    var stepLimit = getStepLimit(oldStep, newStep);
    var editFlag = false;
    var offset = 0;
    operations.slice().some(function (operation, index) {
        var currStepDescriptor = step_1.Step.descriptor(operation.message || '');
        // Skip commits which are not step commits
        if (!currStepDescriptor) {
            return;
        }
        var currStepSplit = currStepDescriptor.number.split('.');
        var currSuperStep = currStepSplit[0];
        var currSubStep = currStepSplit[1];
        if (submoduleCwd) {
            // If this is a super step, replace pick operation with the super pick
            if (!currSubStep) {
                operations.splice(index + offset, 1, {
                    method: 'exec',
                    command: "node " + paths_1.Paths.tortilla.rebase + " super-pick " + operation.hash,
                });
            }
        }
        else if (currSuperStep > stepLimit) {
            // Prepend local storage item setting operation, this would be a flag which will be
            // used in git-hooks
            operations.splice(index + offset++, 0, {
                method: 'exec',
                command: "node " + paths_1.Paths.tortilla.localStorage + " set REBASE_HOOKS_DISABLED 1",
            });
            // Abort operations loop
            return true;
        }
        // If this is a super step, replace pick operation with the super pick
        if (!currSubStep) {
            operations.splice(index + offset, 1, {
                method: 'exec',
                command: "node " + paths_1.Paths.tortilla.rebase + " super-pick " + operation.hash,
            });
        }
        // If another step edit is pending, we will first perform the reword and only then
        // we will proceed to the editing itself, since we wanna ensure that all the previous
        // step indexes are already sorted
        if (operation.method === 'edit') {
            // Pick BEFORE edit
            operations.splice(index + offset++, 0, __assign({}, operation, { method: 'pick' }));
            // Update commit's step number
            operations.splice(index + offset++, 0, {
                method: 'exec',
                command: "GIT_EDITOR=true node " + paths_1.Paths.tortilla.rebase + " reword",
            });
            var editor = "GIT_SEQUENCE_EDITOR=\"node " + paths_1.Paths.tortilla.editor + " edit-head\"";
            // Replace edited step with the reworded one
            operations.splice(index + offset++, 0, {
                method: 'exec',
                command: editor + " git rebase --edit-todo",
            });
            operations.splice(index + offset, 1);
            // The sorting process should continue after we've finished editing the step, for now
            // we will need to abort the current sorting process
            return editFlag = true;
        }
        // Update commit's step number
        operations.splice(index + ++offset, 0, {
            method: 'exec',
            command: "GIT_EDITOR=true node " + paths_1.Paths.tortilla.rebase + " reword",
        });
    });
    // Remove hooks storage items so it won't affect post-rebase operations, but only if
    // there are no any further step edits pending
    if (!editFlag) {
        operations.push({
            method: 'exec',
            command: "node " + paths_1.Paths.tortilla.localStorage + " remove HOOK_STEP",
        });
        // If specified udiff is a path to another tortilla repo
        if (options.udiff) {
            var subCwd = utils_1.Utils.cwd();
            var cwd = Path.resolve(utils_1.Utils.cwd(), options.udiff);
            // Update the specified repo's manual files
            // Note that TORTILLA_CHILD_PROCESS and TORTILLA_CWD flags are set to
            // prevent external interventions, mostly because of tests
            operations.push({
                method: 'exec',
                command: utils_1.Utils.shCmd("\n          export GIT_DIR=" + cwd + "/.git\n          export GIT_WORK_TREE=" + cwd + "\n          export TORTILLA_CHILD_PROCESS=true\n          export TORTILLA_CWD=" + cwd + "\n          export TORTILLA_SUBMODULE_CWD=" + subCwd + "\n\n          if node " + paths_1.Paths.cli.tortilla + " step edit --root ; then\n            git rebase --continue\n          else\n            git rebase --abort\n          fi\n        "),
            });
        }
        // Ensure step map is being disposed
        operations.push({
            method: 'exec',
            command: "node " + paths_1.Paths.tortilla.localStorage + " remove STEP_MAP STEP_MAP_PENDING",
        });
    }
}
// Edit the commit which is presented as the current HEAD
function editHead(operations) {
    // Prepare meta-data for upcoming sorts
    var descriptor = step_1.Step.descriptor(operations[0].message);
    // Descriptor should always exist, but just in case
    if (descriptor) {
        local_storage_1.localStorage.setItem('REBASE_OLD_STEP', descriptor.number);
    }
    var head = git_1.Git.recentCommit(['--format=%h m']).split(' ');
    var hash = head.shift();
    var message = head.join(' ');
    // Remove head commit so there won't be any conflicts
    operations.push({
        method: 'exec',
        command: 'git reset --hard HEAD~1',
    });
    // Re-pick and edit head commit
    operations.push({
        method: 'edit',
        hash: hash,
        message: message,
    });
}
// Reword the last step in the rebase file
function rewordStep(operations, message) {
    var argv = [paths_1.Paths.tortilla.rebase, 'reword'];
    if (message) {
        argv.push("\"" + message + "\"");
    }
    // Replace original message with the provided message
    operations.splice(1, 0, {
        method: 'exec',
        command: "node " + argv.join(' '),
    });
}
// Render all manuals since the beginning of history to the opposite format
function renderManuals(operations) {
    var offset = 2;
    // Render README.md
    operations.splice(1, 0, {
        method: 'exec',
        command: "node " + paths_1.Paths.tortilla.manual + " render --root",
    });
    operations.slice(offset).forEach(function (operation, index) {
        var stepDescriptor = step_1.Step.superDescriptor(operation.message);
        if (!stepDescriptor) {
            return;
        }
        // Render step manual file
        operations.splice(index + ++offset, 0, {
            method: 'exec',
            command: "node " + paths_1.Paths.tortilla.manual + " render " + stepDescriptor.number,
        });
        return offset;
    });
    // Re-adjust branch references since hash values are outdated at this point
    operations.push({
        method: 'exec',
        command: "node " + paths_1.Paths.tortilla.rebase + " rebranch-super",
    });
}
// The step limit of which sorts are needed would be determined by the step
// which is greater
function getStepLimit(oldStep, newStep) {
    oldStep = oldStep === 'root' ? '0' : oldStep;
    var newSuperStep = newStep === 'root' ? '0' : newStep;
    // Grabbing step splits for easy access
    var oldStepSplits = oldStep.split('.');
    var newStepSplits = newStep.split('.');
    var oldSuperStep = oldStepSplits[0];
    newSuperStep = newStepSplits[0];
    var oldSubStep = oldStepSplits[1];
    var newSubStep = newStepSplits[1];
    if (oldSuperStep === newSuperStep) {
        // 1.1, 1.2 or 1.2, 1.1 or 1.1 or 1.1, 1
        if (oldSubStep) {
            return oldSuperStep;
        }
        // 1, 1.1
        return Infinity;
    }
    // 1, 2.1
    if (!oldSubStep && newSubStep && Number(newSuperStep) === Number(oldSuperStep) + 1) {
        return newSuperStep;
    }
    // 2.1, 1
    if (!newSubStep && oldSubStep && Number(oldSuperStep) === Number(newSuperStep) + 1) {
        return oldSuperStep;
    }
    // 1, 2 or 1, 3.1 or 1.1, 2.1 or 1.1, 2
    return Infinity;
}
// Convert rebase file content to operations array
function disassemblyOperations(rebaseFileContent) {
    var operations = rebaseFileContent.match(/^[a-z]+\s.{7}.*$/mg);
    if (!operations) {
        return [];
    }
    return operations.map(function (line) {
        var split = line.split(' ');
        return {
            method: split[0],
            hash: split[1],
            message: split.slice(2).join(' '),
        };
    });
}
// Convert operations array to rebase file content
function assemblyOperations(operations) {
    return operations
        // Compose lines
        .map(function (operation) { return Object
        .keys(operation)
        .map(function (k) { return operation[k]; })
        .join(' '); })
        // Connect lines
        .join('\n') + '\n';
}
//# sourceMappingURL=editor.js.map