tortilla/dist/git.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 Tmp = require("tmp");
var paths_1 = require("./paths");
var utils_1 = require("./utils");
/**
 Contains general git utilities.
 */
var exec = utils_1.Utils.exec;
// This RegExp will help us pluck the versions in a conflict and solve it
var conflict = /\n\s*<<<<<<< [^\n]+(\n(?:.|\n)+?)\n\s*=======(\n(?:.|\n)+?)\n\s*>>>>>>> [^\n]+/;
function git(argv, options) {
    return gitBody(utils_1.Utils.git, argv, options);
}
var gitPrint = git.print = function (argv, options) {
    if (options === void 0) { options = {}; }
    return gitBody(utils_1.Utils.git.print, argv, options);
};
// Push a tutorial based on the provided branch.
// e.g. given 'master' then 'master-history', 'master-root', 'master@0.1.0', etc, will be pushed.
// Note that everything will be pushed by FORCE and will override existing refs within the remote
function pushTutorial(remote, baseBranch) {
    var relatedBranches = git(['branch', '-l']).split('\n').map(function (branch) {
        if (!branch) {
            return null;
        }
        branch = branch.split(/\*?\s+/)[1];
        if (branch === baseBranch) {
            return branch;
        }
        if (branch === baseBranch + "-history") {
            return branch;
        }
        if (branch === baseBranch + "-root") {
            return branch;
        }
        if (new RegExp("^" + baseBranch + "-step\\d+$").test(branch)) {
            return branch;
        }
    }).filter(Boolean);
    var relatedTags = git(['tag', '-l']).split('\n').map(function (tag) {
        if (!tag) {
            return null;
        }
        if (new RegExp("^" + baseBranch + "@(\\d+\\.\\d+\\.\\d+|next)$").test(tag)) {
            return tag;
        }
        if (new RegExp("^" + baseBranch + "@root@(\\d+\\.\\d+\\.\\d+|next)$").test(tag)) {
            return tag;
        }
        if (new RegExp("^" + baseBranch + "@step\\d+@(\\d+\\.\\d+\\.\\d+|next)$").test(tag)) {
            return tag;
        }
    }).filter(Boolean);
    var refs = relatedBranches.concat(relatedTags);
    return gitPrint(['push', '-f', remote].concat(refs));
}
// Pull a tutorial based on the provided branch. e.g. given 'master' then 'master-history',
// 'master-root', 'master@0.1.0', etc, will be pulled.
function pullTutorial(remote, baseBranch) {
    var relatedBranches = [];
    var relatedTags = [];
    git(['ls-remote', '--tags', '--heads', remote]).split('\n').forEach(function (line) {
        if (!line) {
            return;
        }
        var _a = line.split(/\s+/), ref = _a[1];
        if (new RegExp("^refs/tags/" + baseBranch + "@(root|step-\\d+@)?(\\d+\\.\\d+\\.\\d+|next)$").test(ref)) {
            relatedTags.push(ref.split('/').slice(2).join('/'));
        }
        if (new RegExp("^refs/heads/" + baseBranch + "(-root|-history|-step\\d+)?$").test(ref)) {
            relatedBranches.push(ref.split('/').slice(2).join('/'));
        }
    });
    var refs = relatedBranches.concat(relatedTags);
    var activeBranchName = exports.Git.activeBranchName();
    try {
        var sha1 = exports.Git(['rev-parse', activeBranchName]);
        // Detach HEAD so we can change the reference of the branch
        exports.Git(['checkout', sha1]);
        // --tags flag will overwrite tags
        gitPrint(['fetch', '--tags', '-f', remote].concat(refs));
        // Make sure that all local branches track the right remote branches
        relatedBranches.forEach(function (branch) {
            try {
                exports.Git(['branch', '-D', branch]);
            }
            catch (e) {
                // Branch doesn't exist
            }
            exports.Git.print(['branch', '--track', branch, "remotes/" + remote + "/" + branch]);
        });
    }
    finally {
        // Get back to where we were, regardless of the outcome
        exports.Git(['checkout', activeBranchName]);
    }
}
// The body of the git execution function, useful since we use the same logic both for
// exec and spawn
function gitBody(handler, argv, options) {
    options = __assign({ env: {} }, options);
    // Zeroing environment vars which might affect other executions
    options.env = __assign({ GIT_DIR: null, GIT_WORK_TREE: null }, options.env);
    return handler(argv, options);
}
// Tells if rebasing or not
function isRebasing(path) {
    if (path === void 0) { path = null; }
    var paths = path ? paths_1.resolveProject(path).git : paths_1.Paths.git;
    return utils_1.Utils.exists(paths.rebaseMerge) || utils_1.Utils.exists(paths.rebaseApply);
}
// Tells if cherry-picking or not
function isCherryPicking() {
    return utils_1.Utils.exists(paths_1.Paths.git.heads.cherryPick) || utils_1.Utils.exists(paths_1.Paths.git.heads.revert);
}
// Tells if going to amend or not
function gonnaAmend() {
    return utils_1.Utils.childProcessOf('git', ['commit', '--amend']);
}
// Tells if a tag exists or not
function tagExists(tag) {
    try {
        git(['rev-parse', tag]);
        return true;
    }
    catch (err) {
        return false;
    }
}
// Get the recent commit by the provided arguments. An offset can be specified which
// means that the recent commit from several times back can be fetched as well
function getRecentCommit(offset, argv, options, path) {
    if (path === void 0) { path = null; }
    if (offset instanceof Array) {
        options = argv;
        argv = offset;
        offset = 0;
    }
    else {
        argv = argv || [];
        offset = offset || 0;
    }
    var hash = typeof offset === 'string' ? offset : ("HEAD~" + offset);
    argv = ['log', hash, '-1'].concat(argv);
    return git(argv, path ? __assign({}, options, { cwd: path }) : options);
}
// Gets a list of the modified files reported by git matching the provided pattern.
// This includes untracked files, changed files and deleted files
function getStagedFiles(pattern) {
    var stagedFiles = git(['diff', '--name-only', '--cached'])
        .split('\n')
        .filter(Boolean);
    return utils_1.Utils.filterMatches(stagedFiles, pattern);
}
// Gets active branch name
function getActiveBranchName(path) {
    if (path === void 0) { path = null; }
    if (!isRebasing(path)) {
        return git(['rev-parse', '--abbrev-ref', 'HEAD'], path ? { cwd: path } : null);
    }
    // Getting a reference for the hash of which the rebase have started
    var branchHash = git(['reflog', '--format=%gd %gs'], path ? { cwd: path } : null)
        .split('\n')
        .filter(Boolean)
        .map(function (line) { return line.split(' '); })
        .map(function (split) { return [split.shift(), split.join(' ')]; })
        .find(function (_a) {
        var ref = _a[0], msg = _a[1];
        return msg.match(/^rebase -i \(start\)/);
    })
        .shift()
        .match(/^HEAD@\{(\d+)\}$/)
        .slice(1)
        .map(function (i) { return "HEAD@{" + ++i + "}"; })
        .map(function (ref) { return git(['rev-parse', ref]); })
        .pop();
    // Comparing the found hash to each of the branches' hashes
    return Fs.readdirSync(paths_1.Paths.git.refs.heads).find(function (branchName) {
        return git(['rev-parse', branchName], path ? { cwd: path } : null) === branchHash;
    });
}
// Gets the root hash of HEAD
function getRootHash(head) {
    if (head === void 0) { head = 'HEAD'; }
    return git(['rev-list', '--max-parents=0', head]);
}
function getRoot() {
    try {
        return git(['rev-parse', '--show-toplevel']);
        // Not a git project
    }
    catch (e) {
        return '';
    }
}
function edit(initialContent) {
    var editor = getEditor();
    var file = Tmp.fileSync({ unsafeCleanup: true });
    Fs.writeFileSync(file.name, initialContent);
    exec.print('sh', ['-c', editor + " " + file.name]);
    var content = Fs.readFileSync(file.name).toString();
    file.removeCallback();
    return content;
}
// https://github.com/git/git/blob/master/git-rebase--interactive.sh#L257
function getEditor() {
    var editor = process.env.GIT_EDITOR;
    if (!editor) {
        try {
            editor = git(['config', 'core.editor']);
        }
        catch (e) {
            // Ignore
        }
    }
    if (!editor) {
        try {
            editor = git(['var', 'GIT_EDITOR']);
        }
        catch (e) {
            // Ignore
        }
    }
    if (!editor) {
        throw Error('Git editor could not be found');
    }
    return editor;
}
// Commander will split equal signs e.g. `--format=%H` which is is not the desired
// behavior for git. This puts the everything back together when necessary
function normalizeArgv(argv) {
    argv = argv.slice();
    {
        var i = argv.indexOf('--format');
        if (i !== -1) {
            argv.splice(i, 2, "--format=" + argv[i + 1]);
        }
    }
    return argv;
}
function getRevisionIdFromObject(object) {
    return git(['rev-list', '-n', '1', object]);
}
exports.Git = utils_1.Utils.extend(git.bind(null), git, {
    pushTutorial: pushTutorial,
    pullTutorial: pullTutorial,
    conflict: conflict,
    rebasing: isRebasing,
    cherryPicking: isCherryPicking,
    gonnaAmend: gonnaAmend,
    tagExists: tagExists,
    recentCommit: getRecentCommit,
    stagedFiles: getStagedFiles,
    activeBranchName: getActiveBranchName,
    rootHash: getRootHash,
    root: getRoot,
    edit: edit,
    editor: getEditor,
    normalizeArgv: normalizeArgv,
    getRevisionIdFromObject: getRevisionIdFromObject,
});
//# sourceMappingURL=git.js.map