tortilla/dist/essentials.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Fs = require("fs-extra");
var Handlebars = require("handlebars");
var Minimist = require("minimist");
var Path = require("path");
var ReadlineSync = require("readline-sync");
var Tmp = require("tmp");
var ascii_1 = require("./ascii");
var git_1 = require("./git");
var local_storage_1 = require("./local-storage");
var paths_1 = require("./paths");
var submodule_1 = require("./submodule");
var utils_1 = require("./utils");
/**
 Contains some essential utilities that should usually run once to create a project or
 initialize a project.
 */
var exec = utils_1.Utils.exec;
var tmpDir = Tmp.dirSync({ unsafeCleanup: true });
var tmpPaths = paths_1.Paths.resolveProject(tmpDir.name);
function init() {
    if (require.main !== module) {
        return;
    }
    var argv = Minimist(process.argv.slice(2), {
        string: ['_', 'message', 'm', 'output', 'o'],
        boolean: ['override'],
    });
    var method = argv._[0];
    var arg1 = argv._[1];
    var output = argv.output || argv.o;
    var override = argv.override;
    var options = {
        output: output,
        override: override,
    };
    switch (method) {
        case 'create':
            return createProject(arg1, options);
        case 'ensure':
            return ensureTortilla(arg1);
    }
}
init();
// Initialize tortilla project, it will use the skeleton as the template and it will fill
// it up with the provided details. Usually should only run once
function createProject(projectName, options) {
    projectName = projectName || 'tortilla-project';
    options = utils_1.Utils.extend({
        output: Path.resolve(projectName),
    }, options);
    // In case dir already exists verify the user's decision
    if (utils_1.Utils.exists(options.output)) {
        options.override = options.override || ReadlineSync.keyInYN([
            'Output path already exists.',
            'Would you like to override it and continue?',
        ].join('\n'));
        if (!options.override) {
            return;
        }
    }
    Fs.emptyDirSync(tmpDir.name);
    // Unpack skeleton
    exec.print('tar', [
        '--strip-components', 1, '-xf', paths_1.Paths.tortilla.skeleton, '-C', tmpDir.name
    ]);
    var packageName = utils_1.Utils.kebabCase(projectName);
    var title = utils_1.Utils.startCase(projectName);
    // Fill in template files
    overwriteTemplateFile(tmpPaths.npm.package, {
        name: packageName,
    });
    overwriteTemplateFile(tmpPaths.readme, {
        title: title,
    });
    // Git chores
    git_1.Git(['init'], { cwd: tmpDir.name });
    git_1.Git(['add', '.'], { cwd: tmpDir.name });
    git_1.Git(['commit', '-m', title], { cwd: tmpDir.name });
    if (options.message) {
        git_1.Git.print(['commit', '--amend', '-m', options.message], { cwd: tmpDir.name });
    }
    else {
        git_1.Git.print(['commit', '--amend'], { cwd: tmpDir.name });
    }
    // Initializing
    ensureTortilla(tmpPaths);
    // Copy from temp to output
    Fs.removeSync(options.output);
    Fs.copySync(tmpDir.name, options.output);
    tmpDir.removeCallback();
}
// Make sure that tortilla essentials are initialized on an existing project.
// Used most commonly when cloning or creating a project
function ensureTortilla(projectDir) {
    projectDir = projectDir || utils_1.Utils.cwd();
    var projectPaths = projectDir.resolve ? projectDir : paths_1.Paths.resolveProject(projectDir);
    var localStorage = local_storage_1.localStorage.create(projectPaths);
    var cwd = projectPaths.resolve();
    // If tortilla is already initialized don't do anything
    var isInitialized = localStorage.getItem('INIT');
    if (isInitialized) {
        return;
    }
    // Otherwise it might throw an error that dir doesn't exist
    Fs.ensureDirSync(projectPaths.git.hooks);
    var hookFiles = Fs.readdirSync(projectPaths.tortilla.hooks);
    // For each hook file in the hooks directory
    hookFiles.forEach(function (hookFile) {
        var handlerPath = Path.resolve(projectPaths.tortilla.hooks, hookFile);
        var hookName = Path.basename(hookFile, '.js');
        var hookPath = Path.resolve(projectPaths.git.hooks, hookName);
        // Place an executor in the project's git hooks
        var hook = [
            '',
            '### TORTILLA ###',
            'cd .',
            "node " + handlerPath + " \"$@\"",
        ].join('\n');
        // If exists, append logic
        if (utils_1.Utils.exists(hookPath, 'file')) {
            var contents = Fs.readFileSync(hookPath).toString();
            // Don't hook logic if already initialized
            if (!/\n### TORTILLA ###\n/.test(contents)) {
                contents += "\n" + hook;
                Fs.writeFileSync(hookPath, contents);
            }
        }
        else { // Else, create file
            Fs.writeFileSync(hookPath, "#!/bin/sh" + hook);
        }
        // Give read permissions to hooks so git can execute properly
        Fs.chmodSync(hookPath, '755');
    });
    // Create root branch reference for continues integration testing
    var activeBranchName = git_1.Git(['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: cwd });
    try {
        git_1.Git(['rev-parse', activeBranchName + "-root"], { cwd: cwd });
    }
    catch (e) {
        git_1.Git(['branch', activeBranchName + "-root", activeBranchName], { cwd: cwd });
    }
    // Ensure submodules are initialized
    submodule_1.Submodule.list().forEach(function (submodule) {
        submodule_1.Submodule.update(submodule);
        // If hash not found
        if (git_1.Git(['diff', '--name-only']).split('\n').filter(Boolean).includes(submodule)) {
            submodule_1.Submodule.reset(submodule);
        }
    });
    // Mark tortilla flag as initialized
    localStorage.setItem('INIT', true);
    localStorage.setItem('USE_STRICT', true);
    // The art should be printed only if the operation finished for all submodules
    if (!submodule_1.Submodule.isOne()) {
        ascii_1.Ascii.print('ready');
    }
}
// TODO: **Add tests**
function cloneProject(url, out) {
    if (!out) {
        // git@github.com:srtucker22/chatty.git -> chatty
        out = url.split('/').pop().split('.').shift();
    }
    out = Path.resolve(utils_1.Utils.cwd(), out);
    git_1.Git.print(['clone', url, out]);
    ensureTortilla(out);
    // List all branches in origin
    git_1.Git(['branch', '-a'], { cwd: out })
        .split('\n')
        .filter(Boolean)
        .filter(function (remoteBranch) {
        return /remotes\/origin\/[^\s]+$/.test(remoteBranch);
    })
        .map(function (remoteBranch) {
        return remoteBranch.trim();
    })
        .map(function (remoteBranch) {
        return remoteBranch.split('remotes/origin/').pop();
    })
        .forEach(function (remoteBranch) {
        var branchName = remoteBranch.split('/').pop();
        // Create all branches
        try {
            git_1.Git(['checkout', '-b', branchName], { cwd: out });
        }
        catch (e) {
            // Branch already exists. I don't care
        }
    });
    // Switch back to the original branch
    git_1.Git(['checkout', 'master'], { cwd: out });
}
// Will reclone the current project. By doing so, we will sync the most recent changes
function recloneProject(remote) {
    if (remote === void 0) { remote = 'origin'; }
    var proceed = ReadlineSync.keyInYN([
        '⚠ Warning ⚠',
        'Recloning will sync your project with the most recent changes but will discard',
        'the current git-state completely. Are you sure you would like to proceed?',
    ].join('\n'));
    if (!proceed) {
        return;
    }
    var url = git_1.Git(['remote', 'get-url', remote]);
    Fs.removeSync(utils_1.Utils.cwd());
    cloneProject(url, utils_1.Utils.cwd());
}
// Will force push our changes to the provided remote, including branches and tags
function pushChanges(remote) {
    if (remote === void 0) { remote = 'origin'; }
    var proceed = ReadlineSync.keyInYN([
        '⚠ Warning ⚠',
        'Pushing your changes will override the entire hosted project.',
        'Are you sure you would like to proceed?',
    ].join('\n'));
    if (!proceed) {
        return;
    }
    git_1.Git.print(['push', remote, '--mirror']);
}
function disposeTortilla(cwd) {
    if (cwd === void 0) { cwd = process.cwd(); }
    cwd = Path.resolve(cwd, process.cwd());
    var root = git_1.Git(['rev-parse', '--show-toplevel'], { cwd: cwd });
    var paths = paths_1.Paths.resolveProject(root);
    Fs.removeSync(paths.storage);
    // If hooks dir doesn't exist there's nothing to remove
    if (!Fs.existsSync(paths.git.hooks)) {
        return;
    }
    // Remove tortilla logic from hooks
    Fs.readdirSync(paths.git.hooks).forEach(function (hookFileName) {
        var hookFilePath = paths.git.hooks + "/" + hookFileName;
        var contents = Fs.readFileSync(hookFilePath).toString();
        contents = contents.replace(/### TORTILLA ###\n[^\n]+\n[^\n]+\n?/, '');
        Fs.writeFileSync(hookFilePath, contents);
    });
}
function overwriteTemplateFile(path, scope) {
    var templateContent = Fs.readFileSync(path, 'utf8');
    var viewContent = Handlebars.compile(templateContent)(scope);
    Fs.writeFileSync(path, viewContent);
}
exports.Essentials = {
    clone: cloneProject,
    reclone: recloneProject,
    create: createProject,
    ensure: ensureTortilla,
    push: pushChanges,
    dispose: disposeTortilla
};
//# sourceMappingURL=essentials.js.map