tortilla/dist/release.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);
};
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 Path = require("path");
var Tmp = require("tmp");
var git_1 = require("./git");
var local_storage_1 = require("./local-storage");
var paths_1 = require("./paths");
var prompt_1 = require("./prompt");
var step_1 = require("./step");
var submodule_1 = require("./submodule");
var utils_1 = require("./utils");
/**
 The 'release' module contains different utilities and methods which are responsible
 for release management. Before invoking any method, be sure to fetch **all** the step
 tags from the git-host, since most calculations are based on them.
 */
// TODO: Create a dedicated registers/temp dirs module with no memory leaks
var tmp1Dir = Tmp.dirSync({ unsafeCleanup: true });
var tmp2Dir = Tmp.dirSync({ unsafeCleanup: true });
var tmp3Dir = Tmp.dirSync({ unsafeCleanup: true });
function promptForGitRevision(submoduleName, submodulePath) {
    return __awaiter(this, void 0, void 0, function () {
        var mostRecentCommit, answer, commitId;
        var _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    mostRecentCommit = git_1.Git.recentCommit(null, '--format=oneline', null, submodulePath);
                    return [4 /*yield*/, prompt_1.prompt([
                            {
                                type: 'list',
                                name: 'update-module',
                                message: "Submodule '" + submoduleName + "' is pointing to the following commit: " + mostRecentCommit + ", is that correct?",
                                choices: [
                                    { name: "Yes, it's the correct commit!", value: 'yes' },
                                    { name: "No - I need to make sure some things before releasing", value: 'exit' },
                                ],
                                default: 'yes',
                            },
                        ])];
                case 1:
                    answer = _b.sent();
                    if (answer === 'yes') {
                        commitId = git_1.Git.recentCommit(null, '--format="%H"', null, submodulePath);
                        return [2 /*return*/, (_a = {},
                                _a[submodulePath] = { gitRevision: commitId },
                                _a)];
                    }
                    else if (answer === 'exit') {
                        return [2 /*return*/, null];
                    }
                    return [2 /*return*/];
            }
        });
    });
}
function promptAndHandleSubmodules(listSubmodules) {
    return __awaiter(this, void 0, void 0, function () {
        var modulesToVersionsMap, _i, listSubmodules_1, submodulePath, fullPath, submoduleName, isTortillaProject, allReleases, answer, result;
        var _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    console.log("\u2139\uFE0F Found total of " + listSubmodules.length + " submodules.");
                    console.log("\u2757 Note that you need to make sure your submodules are pointing the correct versions:");
                    console.log("\t- If your submodule is a Tortilla project, make sure to release a new version there.");
                    console.log("\t- If your submodule is NOT a Tortilla project, make sure it's updated and pointing to the correct Git revision.\n");
                    modulesToVersionsMap = {};
                    _i = 0, listSubmodules_1 = listSubmodules;
                    _b.label = 1;
                case 1:
                    if (!(_i < listSubmodules_1.length)) return [3 /*break*/, 8];
                    submodulePath = listSubmodules_1[_i];
                    fullPath = Path.resolve(utils_1.Utils.cwd(), submodulePath);
                    submoduleName = Path.basename(submodulePath);
                    submodule_1.Submodule.update(submoduleName);
                    // If hash doesn't exist
                    if (git_1.Git(['diff', '--name-only']).split('\n').filter(Boolean).includes(submoduleName)) {
                        // Fetch so we can have all release tags available to us
                        submodule_1.Submodule.fetch(submoduleName);
                    }
                    isTortillaProject = utils_1.Utils.exists(paths_1.resolveProject(fullPath).tortillaDir);
                    if (!isTortillaProject) return [3 /*break*/, 5];
                    allReleases = getAllReleasesOfAllBranches(fullPath);
                    if (!(allReleases.length === 0)) return [3 /*break*/, 2];
                    console.log("\uD83D\uDED1 Found a Tortilla project submodule: '" + submoduleName + "', but there are no Tortilla releases!");
                    console.log("Please make sure to release a version with Tortilla, and then try again");
                    return [2 /*return*/, null];
                case 2: return [4 /*yield*/, prompt_1.prompt([
                        {
                            type: 'list',
                            name: submodulePath,
                            message: "Submodule '" + submoduleName + "' is a valid Tortilla project. Please pick a release from the list:",
                            choices: allReleases.map(function (releaseInfo) { return releaseInfo.tagName; }),
                        },
                    ])];
                case 3:
                    answer = _b.sent();
                    modulesToVersionsMap = __assign({}, (modulesToVersionsMap || {}), (_a = {}, _a[fullPath] = { tortillaVersion: answer }, _a));
                    _b.label = 4;
                case 4: return [3 /*break*/, 7];
                case 5: return [4 /*yield*/, promptForGitRevision(submoduleName, fullPath)];
                case 6:
                    result = _b.sent();
                    if (result === null) {
                        return [2 /*return*/, null];
                    }
                    modulesToVersionsMap = __assign({}, modulesToVersionsMap, result);
                    _b.label = 7;
                case 7:
                    _i++;
                    return [3 /*break*/, 1];
                case 8: return [2 /*return*/, modulesToVersionsMap];
            }
        });
    });
}
// Creates a bumped release tag of the provided type
// e.g. if the current release is @1.0.0 and we provide this function with a release type
// of 'patch', the new release would be @1.0.1
function bumpRelease(releaseType, options) {
    return __awaiter(this, void 0, void 0, function () {
        var currentRelease, listSubmodules, submodulesRevisions, onInitialCheckout, hasSubmodules, e_1, branch, formattedRelease, rootHash, rootTag, tag;
        var _this = this;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    options = options || {};
                    if (releaseType === 'next') {
                        currentRelease = {
                            major: 0,
                            minor: 0,
                            patch: 0,
                            next: true,
                        };
                    }
                    else {
                        currentRelease = getCurrentRelease(true);
                        // Increase release type
                        switch (releaseType) {
                            case 'major':
                                currentRelease.major++;
                                currentRelease.minor = 0;
                                currentRelease.patch = 0;
                                break;
                            case 'minor':
                                currentRelease.minor++;
                                currentRelease.patch = 0;
                                break;
                            case 'patch':
                                currentRelease.patch++;
                                break;
                            default:
                                throw Error('Provided release type must be one of "major", "minor", "patch" or "next"');
                        }
                    }
                    listSubmodules = submodule_1.Submodule.list();
                    submodulesRevisions = {};
                    onInitialCheckout = function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
                        return [2 /*return*/, undefined];
                    }); }); };
                    hasSubmodules = listSubmodules.length > 0;
                    if (hasSubmodules) {
                        // This will run at the root commit, just before we render all the manuals
                        onInitialCheckout = function () { return __awaiter(_this, void 0, void 0, function () {
                            var _i, _a, _b, submodulePath, revisionChoice;
                            return __generator(this, function (_c) {
                                switch (_c.label) {
                                    case 0: return [4 /*yield*/, promptAndHandleSubmodules(listSubmodules)];
                                    case 1:
                                        submodulesRevisions = _c.sent();
                                        if (!submodulesRevisions || Object.keys(submodulesRevisions).length !== listSubmodules.length) {
                                            throw new Error("Unexpected submodules versions results!");
                                        }
                                        else {
                                            for (_i = 0, _a = Object.entries(submodulesRevisions); _i < _a.length; _i++) {
                                                _b = _a[_i], submodulePath = _b[0], revisionChoice = _b[1];
                                                if (revisionChoice && revisionChoice.tortillaVersion) {
                                                    console.log("\u25B6\uFE0F Checking out \"" + revisionChoice.tortillaVersion + "\" in Tortilla submodule \"" + Path.basename(submodulePath) + "\"...");
                                                    git_1.Git(['checkout', revisionChoice.tortillaVersion], { cwd: submodulePath });
                                                }
                                                else if (revisionChoice && revisionChoice.gitRevision) {
                                                    console.log("\u25B6\uFE0F Checking out \"" + revisionChoice.gitRevision + "\" in submodule \"" + Path.basename(submodulePath) + "\"...");
                                                    git_1.Git(['checkout', revisionChoice.gitRevision], { cwd: submodulePath });
                                                }
                                            }
                                        }
                                        return [2 /*return*/];
                                }
                            });
                        }); };
                    }
                    // Since 'next' release is weakly held, it should be overridden by the given release
                    deleteNextReleaseTags();
                    _a.label = 1;
                case 1:
                    _a.trys.push([1, , 6, 7]);
                    // Store potential release so it can be used during rendering
                    local_storage_1.localStorage.setItem('POTENTIAL_RELEASE', JSON.stringify(currentRelease));
                    step_1.Step.edit('root');
                    // Render once we continue
                    git_1.Git.print(['rebase', '--edit-todo'], {
                        env: {
                            GIT_SEQUENCE_EDITOR: "node " + paths_1.Paths.tortilla.editor + " render",
                        },
                    });
                    _a.label = 2;
                case 2:
                    _a.trys.push([2, 4, , 5]);
                    return [4 /*yield*/, onInitialCheckout()];
                case 3:
                    _a.sent();
                    return [3 /*break*/, 5];
                case 4:
                    e_1 = _a.sent();
                    // Abort before throw if error occurred
                    git_1.Git.print(['rebase', '--abort']);
                    throw e_1;
                case 5:
                    git_1.Git.print(['rebase', '--continue']);
                    return [3 /*break*/, 7];
                case 6:
                    local_storage_1.localStorage.removeItem('POTENTIAL_RELEASE');
                    return [7 /*endfinally*/];
                case 7:
                    branch = git_1.Git.activeBranchName();
                    formattedRelease = formatRelease(currentRelease);
                    rootHash = git_1.Git.rootHash();
                    rootTag = [branch, 'root', formattedRelease].join('@');
                    // Create root tag
                    // e.g. master@root@1.0.1
                    createReleaseTag(rootTag, rootHash);
                    // Create a release tag for each super step
                    git_1.Git([
                        // Log commits
                        'log',
                        // Specifically for steps
                        '--grep', '^Step [0-9]\\+:',
                        // Formatted with their subject followed by their hash
                        '--format=%s %H',
                    ]).split('\n')
                        .filter(Boolean)
                        .forEach(function (line) {
                        // Extract data
                        var words = line.split(' ');
                        var hash = words.pop();
                        var subject = words.join(' ');
                        var descriptor = step_1.Step.descriptor(subject);
                        var currentTag = [branch, "step" + descriptor.number, formattedRelease].join('@');
                        // Create tag
                        // e.g. master@step1@1.0.1
                        createReleaseTag(currentTag, hash);
                    });
                    tag = branch + "@" + formattedRelease;
                    // Create a tag with the provided message which will reference to HEAD
                    // e.g. 'master@1.0.1'
                    if (options.message) {
                        createReleaseTag(tag, 'HEAD', options.message);
                        // If no message provided, open the editor
                    }
                    else {
                        createReleaseTag(tag, 'HEAD', true);
                    }
                    createDiffReleasesBranch();
                    printCurrentRelease();
                    return [2 /*return*/];
            }
        });
    });
}
// Removes all the references of the most recent release so the previous one would be the latest
function revertRelease() {
    var branch = git_1.Git.activeBranchName();
    // Getting all branch release tags. Most recent would be first
    var branchTags = git_1.Git(['tag', '-l'])
        .split('\n')
        .map(function (tag) {
        if (!tag) {
            return null;
        }
        if (new RegExp("^" + branch + "@(\\d+\\.\\d+\\.\\d+|next)$").test(tag)) {
            return tag;
        }
        if (new RegExp("^" + branch + "@root@(\\d+\\.\\d+\\.\\d+|next)$").test(tag)) {
            return tag;
        }
        if (new RegExp("^" + branch + "@step\\d+@(\\d+\\.\\d+\\.\\d+|next)$").test(tag)) {
            return tag;
        }
    })
        .filter(Boolean)
        .map(function (tag) {
        var splitted = tag.split('@');
        return {
            tag: tag,
            deformatted: deformatRelease(splitted[1]),
        };
    })
        .sort(function (a, b) { return (b.deformatted.next ? 1 : a.deformatted.next ? -1 :
        (b.deformatted.major - a.deformatted.major) ||
            (b.deformatted.minor - a.deformatted.minor) ||
            (b.deformatted.patch - a.deformatted.patch)); })
        .map(function (_a) {
        var tag = _a.tag;
        return tag;
    });
    if (!branchTags.length) {
        throw Error("No release found for branch " + branch);
    }
    var recentRelease = branchTags[0].split('@').pop();
    var recentReleaseTags = branchTags.filter(function (t) { return t.split('@').pop() === recentRelease; });
    git_1.Git.print(['tag', '--delete'].concat(recentReleaseTags));
    // Move history branch pointer one commit backward
    try {
        git_1.Git.print(['branch', '-f', branch + "-history", branch + "-history~1"]);
    }
    // was probably root, in which case we will delete the history branch
    catch (e) {
        git_1.Git.print(['branch', '--delete', branch + "-history"]);
    }
    console.log(branch + "@" + recentRelease + " has been successfuly reverted");
}
// Creates a branch that represents a list of our releases, this way we can view any
// diff combination in the git-host
function createDiffReleasesBranch() {
    var destinationDir = createDiffReleasesRepo();
    var sourceDir = destinationDir === tmp1Dir.name ? tmp2Dir.name : tmp1Dir.name;
    // e.g. master
    var currBranch = git_1.Git.activeBranchName();
    // e.g. master-history
    var historyBranch = currBranch + "-history";
    // Make sure source is empty
    Fs.emptyDirSync(sourceDir);
    // Create dummy repo in source
    git_1.Git(['init', sourceDir, '--bare']);
    git_1.Git(['checkout', '-b', historyBranch], { cwd: destinationDir });
    git_1.Git(['push', sourceDir, historyBranch], { cwd: destinationDir });
    // Pull the newly created project to the branch name above
    if (git_1.Git.tagExists(historyBranch)) {
        git_1.Git(['branch', '-D', historyBranch]);
    }
    git_1.Git(['fetch', sourceDir, historyBranch]);
    git_1.Git(['branch', historyBranch, 'FETCH_HEAD']);
    // Clear registers
    tmp1Dir.removeCallback();
    tmp2Dir.removeCallback();
}
// Invokes 'git diff' with the given releases. An additional arguments vector which will
// be invoked as is may be provided
function diffRelease(sourceRelease, destinationRelease, argv, options) {
    if (options === void 0) { options = {}; }
    // Will work even if null
    argv = argv || [];
    // Will assume that we would like to run diff with the most recent release
    if (!destinationRelease) {
        var releases = getAllReleases().map(formatRelease);
        var destinationIndex = releases.indexOf(sourceRelease) + 1;
        destinationRelease = releases[destinationIndex];
    }
    var branch = options.branch || git_1.Git.activeBranchName();
    // Compose tags
    // If release ain't exist we will print the entire changes
    var sourceReleaseTag = sourceRelease && branch + "@" + sourceRelease;
    var destinationReleaseTag = branch + "@" + destinationRelease;
    // Create repo
    var sourceDir = createDiffReleasesRepo(sourceReleaseTag, destinationReleaseTag);
    var gitOptions = {
        cwd: sourceDir,
        stdio: options.pipe ? 'pipe' : 'inherit'
    };
    // Exclude manual view files because we already have templates
    argv.push('--', '.', "':!.tortilla/manuals/views'", "':!README.md'");
    // Exclude submodules Tortilla files completely
    submodule_1.Submodule.getFSNodes({ cwd: sourceDir }).forEach(function (_a) {
        var file = _a.file;
        argv.push("':!" + file + "/.tortilla'", "':!" + file + "/README.md'");
    });
    var result;
    if (sourceReleaseTag) {
        // Run 'diff' between the newly created commits
        result = git_1.Git.print(['diff', 'HEAD^', 'HEAD'].concat(argv), gitOptions);
    }
    else {
        // Run so called 'diff' between HEAD and --root. A normal diff won't work here
        result = git_1.Git.print(['show', '--format='].concat(argv), gitOptions);
    }
    // Clear registers
    tmp1Dir.removeCallback();
    tmp2Dir.removeCallback();
    // If the right arguments were specified we could receive the diff as a string
    // Remove trailing white space so patch can be applied
    return result.output && result.output.join('').replace(/ +\n/g, '\n');
}
// Creates the releases diff repo in a temporary dir. The result will be a path for the
// newly created repo
function createDiffReleasesRepo() {
    var tags = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        tags[_i] = arguments[_i];
    }
    if (tags.length === 0) {
        var branch_1 = git_1.Git.activeBranchName();
        // Fetch all releases in reversed order, since the commits are going to be stacked
        // in the opposite order
        tags = getAllReleases()
            .map(formatRelease)
            .reverse()
            .map(function (releaseString) { return branch_1 + "@" + releaseString; });
    }
    else {
        // Sometimes an empty argument might be provided e.g. diffRelease() method
        tags = tags.filter(Boolean);
    }
    var submodules = submodule_1.Submodule.list();
    // Resolve relative git module paths into absolute ones so they can be initialized
    // later on
    var submodulesUrls = submodules.reduce(function (result, submodule) {
        var urlField = "submodule." + submodule + ".url";
        var url = git_1.Git(['config', '--file', '.gitmodules', urlField]);
        // Resolve relative paths
        if (url.substr(0, 1) === '.') {
            url = Path.resolve(utils_1.Utils.cwd(), url);
        }
        result[submodule] = url;
        return result;
    }, {});
    // We're gonna clone the projects once, and copy paste them whenever a re-clone is needed
    var submodulesProjectsDir = tmp3Dir.name;
    Fs.ensureDirSync(submodulesProjectsDir);
    var existingSubmodules = Fs.readdirSync(submodulesProjectsDir);
    var submodulesProjects = submodules.reduce(function (result, submodule) {
        var url = submodulesUrls[submodule];
        result[submodule] = submodulesProjectsDir + '/' + submodule;
        // Clone only if haven't cloned before
        if (!existingSubmodules.includes(submodule)) {
            var authorizedUrl = addHttpCredentials(url);
            git_1.Git.print(['clone', authorizedUrl, submodule], { cwd: submodulesProjectsDir });
        }
        return result;
    }, {});
    // The 'registers' are directories which will be used for temporary FS calculations
    var destinationDir = tmp1Dir.name;
    var sourceDir = tmp2Dir.name;
    // Make sure register2 is empty
    Fs.emptyDirSync(sourceDir);
    // Initialize an empty git repo in register2
    git_1.Git(['init'], { cwd: sourceDir });
    // Start building the diff-branch by stacking releases on top of each-other
    return tags.reduce(function (registers, tag, index) {
        sourceDir = registers[0];
        destinationDir = registers[1];
        var sourcePaths = paths_1.Paths.resolveProject(sourceDir);
        var destinationPaths = paths_1.Paths.resolveProject(destinationDir);
        // Make sure destination is empty
        Fs.emptyDirSync(destinationDir);
        // Copy current git dir to destination
        Fs.copySync(paths_1.Paths.git.resolve(), destinationPaths.git.resolve(), {
            filter: function (filePath) {
                // Exclude .git/.tortilla
                return !/\.git\/\.tortilla/.test(filePath);
            },
        });
        // Checkout release
        git_1.Git(['checkout', tag], { cwd: destinationDir });
        git_1.Git(['checkout', '.'], { cwd: destinationDir });
        // Dir will be initialized with git at master by default
        submodule_1.Submodule.getFSNodes({
            whitelist: submodules,
            revision: tag,
        }).forEach(function (_a) {
            var hash = _a.hash, file = _a.file;
            var args = [];
            for (var _i = 1; _i < arguments.length; _i++) {
                args[_i - 1] = arguments[_i];
            }
            var url = submodulesUrls[file];
            var subDir = destinationDir + "/" + file;
            var subPaths = paths_1.Paths.resolveProject(subDir);
            Fs.copySync(submodulesProjects[file], subDir);
            try {
                git_1.Git(['checkout', hash], { cwd: subDir });
            }
            catch (e) {
                console.warn();
                console.warn("Object " + hash + " is missing for submodule " + file + " at release " + tag + ".");
                console.warn("I don't think release for submodule exists anymore...");
                console.warn();
            }
            Fs.removeSync(subPaths.readme);
            Fs.removeSync(subPaths.tortillaDir);
            Fs.removeSync(subPaths.git.resolve());
        });
        // Removing views which are irrelevant to diff. It's much more comfortable to view
        // the templates instead
        Fs.removeSync(destinationPaths.readme);
        Fs.removeSync(destinationPaths.manuals.views);
        Fs.removeSync(destinationPaths.gitModules);
        Fs.removeSync(destinationPaths.git.resolve());
        // Copy destination to source, but without the git dir so there won't be any
        // conflicts with the commits
        Fs.copySync(sourcePaths.git.resolve(), destinationPaths.git.resolve());
        // Add commit for release
        git_1.Git(['add', '.'], { cwd: destinationDir });
        git_1.Git(['add', '-u'], { cwd: destinationDir });
        // Extracting tag message
        var tagLine = git_1.Git(['tag', '-l', tag, '-n99']);
        var tagMessage = tagLine.replace(/([^\s]+)\s+((?:.|\n)+)/, '$1: $2');
        // Creating a new commit with the tag's message
        git_1.Git(['commit', '-m', tagMessage, '--allow-empty'], {
            cwd: destinationDir,
        });
        return registers.reverse();
    }, [
        sourceDir, destinationDir,
    ]).shift();
}
function printCurrentRelease() {
    var currentRelease = getCurrentRelease();
    var formattedRelease = formatRelease(currentRelease);
    var branch = git_1.Git.activeBranchName();
    console.log();
    console.log("\uD83C\uDF1F Release: " + formattedRelease);
    console.log("\uD83C\uDF1F Branch:  " + branch);
    console.log();
}
// Will transform SSH url into HTTP and will add credentials to HTTP. Originally created
// because of tortilla.academy github app.
function addHttpCredentials(url) {
    if (!process.env.TORTILLA_USERNAME || !process.env.TORTILLA_PASSWORD) {
        return url;
    }
    // e.g. git@github.com:Urigo/WhatsApp.git
    var sshMatch = url.match(/^\w+@(\w+\.\w+):([\w-]+\/[\w-]+)\.git$/);
    if (sshMatch) {
        url = "https://" + sshMatch[1] + "/" + sshMatch[2];
    }
    return url.replace(/^http(s)?:\/\/(.+)$/, "http$1://" + process.env.TORTILLA_USERNAME + ":" + process.env.TORTILLA_PASSWORD + "@$2");
}
// Gets the current release based on the latest release tag
// e.g. if we have the tags 'master@0.0.1', 'master@0.0.2' and 'master@0.1.0' this method
// will return { major: 0, minor: 1, patch: 0, next: false }
function getCurrentRelease(skipNext) {
    if (skipNext === void 0) { skipNext = false; }
    // Return potential release, if defined
    var potentialRelease = local_storage_1.localStorage.getItem('POTENTIAL_RELEASE');
    if (potentialRelease) {
        return JSON.parse(potentialRelease);
    }
    var allReleases = getAllReleases();
    var currentRelease = allReleases.shift();
    // If version was yet to be released, assume this is a null version
    if (!currentRelease) {
        return {
            major: 0,
            minor: 0,
            patch: 0,
            next: false,
        };
    }
    // Skip next if we asked to and if necessary
    if (skipNext && currentRelease.next) {
        currentRelease = allReleases.shift();
    }
    // No version before next
    if (!currentRelease) {
        return {
            major: 0,
            minor: 0,
            patch: 0,
            next: false,
        };
    }
    return currentRelease;
}
function getAllReleasesOfAllBranches(path) {
    if (path === void 0) { path = null; }
    return git_1.Git(['tag'], path ? { cwd: path } : null)
        // Put tags into an array
        .split('\n')
        // If no tags found, filter the empty string
        .filter(Boolean)
        // Filter all the release tags which are proceeded by their release
        .filter(function (tagName) {
        var pattern1 = /^[^@]+@\d+\.\d+\.\d+$/;
        var pattern2 = /^[^@]+@next$/;
        return (tagName.match(pattern1) ||
            tagName.match(pattern2));
    })
        // Map all the release strings
        .map(function (tagName) {
        var splitted = tagName.split('@');
        return {
            tagName: tagName,
            deformatted: deformatRelease(splitted[1]),
        };
    })
        // Put the latest release first
        .sort(function (a, b) { return (b.deformatted.next ? 1 : a.deformatted.next ? -1 :
        (b.deformatted.major - a.deformatted.major) ||
            (b.deformatted.minor - a.deformatted.minor) ||
            (b.deformatted.patch - a.deformatted.patch)); });
}
// Gets a list of all the releases represented as JSONs e.g.
// [{ major: 0, minor: 1, patch: 0 }]
function getAllReleases(path, branch) {
    if (path === void 0) { path = null; }
    if (branch === void 0) { branch = git_1.Git.activeBranchName(path); }
    return git_1.Git(['tag'], path ? { cwd: path } : null)
        // Put tags into an array
        .split('\n')
        // If no tags found, filter the empty string
        .filter(Boolean)
        // Filter all the release tags which are proceeded by their release
        .filter(function (tagName) {
        var pattern1 = new RegExp("^" + branch + "@\\d+\\.\\d+\\.\\d+");
        var pattern2 = new RegExp(branch + "@next$");
        return (tagName.match(pattern1) ||
            tagName.match(pattern2));
    })
        // Map all the release strings
        .map(function (tagName) { return tagName.split('@').pop(); })
        // Deformat all the releases into a json so it would be more comfortable to work with
        .map(function (releaseString) { return deformatRelease(releaseString); })
        // Put the latest release first
        .sort(function (a, b) { return (b.next ? 1 : a.next ? -1 :
        (b.major - a.major) ||
            (b.minor - a.minor) ||
            (b.patch - a.patch)); });
}
// Takes a release json and puts it into a pretty string
// e.g. { major: 1, minor: 1, patch: 1, next: false } -> '1.1.1'
function formatRelease(releaseJson) {
    if (releaseJson.next) {
        return 'next';
    }
    return [
        releaseJson.major,
        releaseJson.minor,
        releaseJson.patch,
    ].join('.');
}
// Takes a release string and puts it into a pretty json object
// e.g. '1.1.1' -> { major: 1, minor: 1, patch: 1, next: false }
function deformatRelease(releaseString) {
    if (releaseString === 'next') {
        return {
            major: 0,
            minor: 0,
            patch: 0,
            next: true,
        };
    }
    var releaseSlices = releaseString.split('.').map(Number);
    return {
        major: releaseSlices[0],
        minor: releaseSlices[1],
        patch: releaseSlices[2],
        next: false,
    };
}
function createReleaseTag(tag, dstHash, message) {
    var srcHash = git_1.Git.activeBranchName();
    if (srcHash === 'HEAD') {
        srcHash = git_1.Git(['rev-parse', 'HEAD']);
    }
    git_1.Git(['checkout', dstHash]);
    // Remove files which shouldn't be included in releases
    // TODO: Remove files based on a user defined blacklist
    Fs.removeSync(paths_1.Paths.travis);
    Fs.removeSync(paths_1.Paths.renovate);
    // Releasing a version
    git_1.Git.print(['commit', '--amend'], { env: { GIT_EDITOR: true } });
    // Provide a quick message
    if (typeof message === 'string') {
        git_1.Git.print(['tag', tag, '-m', message]);
        // Open editor
    }
    else if (message === true) {
        git_1.Git.print(['tag', tag, '-a']);
        // No message
    }
    else {
        git_1.Git(['tag', tag]);
    }
    // Returning to the original hash
    git_1.Git(['checkout', srcHash]);
    // Restore renovate.json and .travis.yml
    git_1.Git(['checkout', '.']);
}
// Delete all @next tag releases of the current branch.
// e.g. master@next, master@root@next, master@step1@next
function deleteNextReleaseTags() {
    var branch = git_1.Git.activeBranchName();
    git_1.Git(['tag', '-l']).split('\n').filter(Boolean).forEach(function (tagName) {
        if (new RegExp("^" + branch + "@").test(tagName) &&
            new RegExp("@next$").test(tagName)) {
            git_1.Git(['tag', '--delete', tagName]);
        }
    });
}
exports.Release = {
    bump: bumpRelease,
    revert: revertRelease,
    createDiffBranch: createDiffReleasesBranch,
    printCurrent: printCurrentRelease,
    current: getCurrentRelease,
    all: getAllReleases,
    diff: diffRelease,
    format: formatRelease,
    deformat: deformatRelease,
};
//# sourceMappingURL=release.js.map