tortilla/dist/submodule.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Fs = require("fs-extra");
var path_1 = require("path");
var git_1 = require("./git");
var paths_1 = require("./paths");
var utils_1 = require("./utils");
// Like git-submodule-add, but will ensure that we're currently at root and will detach HEAD
function addSubmodule(name, url) {
    if (!name) {
        throw TypeError('Submodule name must be provided');
    }
    if (!url) {
        throw TypeError('Submodule URL must be provided');
    }
    {
        var isRoot = git_1.Git.rootHash() === git_1.Git(['rev-parse', 'HEAD']);
        if (!isRoot) {
            throw Error('Use `$ tortilla step edit --root` first');
        }
    }
    git_1.Git.print(['submodule', 'add', url, name]);
    var cwd = resolveSubmodulePath(name);
    var sha1 = git_1.Git(['rev-parse', 'HEAD'], { cwd: cwd });
    git_1.Git.print(['checkout', sha1], { cwd: cwd });
    git_1.Git(['add', '.gitmodules', name]);
}
// Will remove the submodule completely, even from the git-registry. This command doesn't
// exist on git and it can be very useful
function removeSubmodule(name) {
    if (!name) {
        throw TypeError('Submodule name must be provided');
    }
    {
        var isRoot = git_1.Git.rootHash() === git_1.Git(['rev-parse', 'HEAD']);
        if (!isRoot) {
            throw Error('Use `$ tortilla step edit --root` first');
        }
    }
    git_1.Git.print(['submodule', 'deinit', '-f', name]);
    Fs.removeSync(resolveSubmodulePath(name));
    Fs.remove(path_1.resolve(paths_1.Paths.git.modules, name));
    git_1.Git(['config', '--file=.gitmodules', '--remove-section', "submodule." + name]);
    // Adding to stage is necessary before we can clean the cache
    git_1.Git(['add', '.gitmodules']);
    // This will also stage the submodule
    git_1.Git.print(['rm', '--cached', '-rf', name]);
}
// Will run git-submodule-update --init, and it will remove deleted files from stage if
// pointed object doesn't exist in submodule's remote. This behavior is much more expected
// and less confusing rather than seeing that everything was deleted for an odd reason.
function updateSubmodule(name) {
    if (!name) {
        throw TypeError('Submodule name must be provided');
    }
    git_1.Git.print(['submodule', 'update', '--init', name]);
    var cwd = resolveSubmodulePath(name);
    // Will be effective only if hash doesn't exist
    git_1.Git(['reset', '.'], { cwd: cwd });
    git_1.Git(['checkout', '.'], { cwd: cwd });
}
// In other words, this will 'unclone' the submodule, but will keep it initialized. This is
// reliable method to get away from messy situations with submodules, so whenever you don't know
// what to do, run this command.
function resetSubmodule(name) {
    if (!name) {
        throw TypeError('Submodule name must be provided');
    }
    var cwd = resolveSubmodulePath(name);
    Fs.removeSync(cwd);
    git_1.Git.print(['checkout', cwd]);
}
function fetchSubmodule(name) {
    if (!name) {
        throw TypeError('Submodule name must be provided');
    }
    if (!isSubmoduleUpdated(name)) {
        throw Error("Submodule is not updated! Run \"$ tortilla submodule update " + name + "\"");
    }
    var cwd = resolveSubmodulePath(name);
    git_1.Git.print(['fetch', 'origin', '--tags', '-f'], { cwd: cwd });
}
// This will check out the specified submodule to provided ref. It will also guide you through
// with some detailed instructions if you should do things beforehand, this can prevent a lot of
// potential issues and confusion.
function checkoutSubmodule(name, ref) {
    if (!name) {
        throw TypeError('Submodule name must be provided');
    }
    if (!ref) {
        throw TypeError('Submodule ref must be provided');
    }
    {
        var isRoot = git_1.Git.rootHash() === git_1.Git(['rev-parse', 'HEAD']);
        if (!isRoot) {
            throw Error('Command must run in root! Run "$ tortilla step edit --root"');
        }
    }
    if (!isSubmoduleUpdated(name)) {
        throw Error("Submodule is not updated! Run \"$ tortilla submodule update " + name + "\"");
    }
    var cwd = resolveSubmodulePath(name);
    try {
        git_1.Git(['rev-parse', ref], { cwd: cwd });
    }
    catch (e) {
        throw Error("git-ref " + ref + " doesn't exist! Run \"$ tortilla submodule fetch " + name + "\"");
    }
    git_1.Git.print(['checkout', ref], { cwd: cwd });
    git_1.Git.print(['add', cwd]);
}
function isSubmoduleUpdated(name) {
    if (!name) {
        throw TypeError('Submodule name must be provided');
    }
    // Fetch most recent changes if already initialized
    return (Fs.existsSync(path_1.resolve(paths_1.Paths.git.modules, name)) &&
        Fs.existsSync(resolveSubmodulePath(name) + "/.git"));
}
function resolveSubmodulePath(name, relativePath) {
    if (relativePath === void 0) { relativePath = ''; }
    var absolutePath = path_1.resolve(utils_1.Utils.cwd(), name, relativePath);
    if (!Fs.existsSync(absolutePath)) {
        throw Error("Submodule folder \"" + name + "\" doesn't exist");
    }
    return absolutePath;
}
function listSubmodules() {
    var root = git_1.Git.root();
    if (!root) {
        return [];
    }
    var configData;
    try {
        configData = git_1.Git([
            'config', '--file', '.gitmodules', '--name-only', '--get-regexp', 'path',
        ]);
        // No submodules exit
    }
    catch (e) {
        return [];
    }
    return configData.split('\n').map(function (submodule) {
        return submodule.split('.')[1];
    });
}
function listSubmodulesUrls(whiteList) {
    if (whiteList === void 0) { whiteList = []; }
    return git_1.Git([
        'config', '--file', '.gitmodules', '--get-regexp', 'url',
    ]).split('\n')
        .filter(Boolean)
        .map(function (line) {
        var match = line.match(/^submodule\.([^\.]+)\.url\s(.+)$/);
        if (!match) {
            return;
        }
        var submodule = match[1];
        var url = match[2];
        if (!whiteList.length || whiteList.includes(submodule)) {
            return url;
        }
    })
        .filter(Boolean);
}
function isSubmodule() {
    var root = git_1.Git.root();
    if (!root) {
        return false;
    }
    // If the directory one level up the root is a git project then it means that
    // the current directory is a git project as well
    try {
        // This command should only work if we're in a git project
        return !!git_1.Git(['rev-parse', '--show-toplevel'], {
            cwd: path_1.resolve(root, '..'),
        });
    }
    catch (e) {
        return false;
    }
}
function getRemoteSubmoduleName(remote) {
    return remote
        .split('/')
        .pop()
        .split('.')
        .shift();
}
function getLocalSubmoduleName(givenPath) {
    if (!givenPath) {
        return '';
    }
    var givenPackPath = paths_1.Paths.resolveProject(givenPath).npm.package;
    var givenPackName = JSON.parse(Fs.readFileSync(givenPackPath).toString()).name;
    var submoduleName = listSubmodules().find(function (name) {
        var submodulePath = utils_1.Utils.cwd() + "/" + name;
        var submodulePackPath = paths_1.Paths.resolveProject(submodulePath).npm.package;
        var submodulePackName = JSON.parse(Fs.readFileSync(submodulePackPath).toString()).name;
        return submodulePackName === givenPackName;
    });
    return submoduleName || '';
}
// Will get the path of the development sub-repo
function getSubmoduleCwd(name) {
    var configLine = git_1.Git([
        'config', '--file', '.gitmodules', '--get-regexp', "submodule." + name + ".url",
    ]);
    if (!configLine) {
        return;
    }
    var relativePath = configLine.split(' ')[1];
    return path_1.resolve(utils_1.Utils.cwd(), relativePath);
}
// Gets data regards specified submodules from git's objects tree
function getSubmodulesFSNodes(_a) {
    var _b = _a === void 0 ? {
        cwd: utils_1.Utils.cwd(),
    } : _a, whitelist = _b.whitelist, blacklist = _b.blacklist, revision = _b.revision, cwd = _b.cwd;
    if (typeof revision === 'undefined') {
        revision = git_1.Git(['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: cwd });
    }
    return git_1.Git(['ls-tree', revision], { cwd: cwd })
        // Each line represents a node
        .split('\n')
        // Map splits into informative jsons
        .map(function (line) {
        // Each split in the output represents different data
        var _a = line.split(/\s+/), mode = _a[0], type = _a[1], hash = _a[2], file = _a[3];
        return { mode: mode, type: type, hash: hash, file: file };
    })
        // Filter submodules which are included in the list
        .filter(function (_a) {
        var type = _a.type, file = _a.file;
        return type === 'commit' &&
            (!whitelist || whitelist.includes(file)) &&
            (!blacklist || !blacklist.includes(file));
    });
}
exports.Submodule = {
    add: addSubmodule,
    remove: removeSubmodule,
    reset: resetSubmodule,
    fetch: fetchSubmodule,
    update: updateSubmodule,
    checkout: checkoutSubmodule,
    isUpdated: isSubmoduleUpdated,
    resolvePath: resolveSubmodulePath,
    list: listSubmodules,
    urls: listSubmodulesUrls,
    isOne: isSubmodule,
    getRemoteName: getRemoteSubmoduleName,
    getLocalName: getLocalSubmoduleName,
    getCwd: getSubmoduleCwd,
    getFSNodes: getSubmodulesFSNodes,
};
//# sourceMappingURL=submodule.js.map