tortilla/dist/dump.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 Path = require("path");
var ReadlineSync = require("readline-sync");
var semver = require("semver");
var Tmp = require("tmp");
var git_1 = require("./git");
var paths_1 = require("./paths");
var release_1 = require("./release");
var submodule_1 = require("./submodule");
var utils_1 = require("./utils");
var defaultDumpFileName = 'tutorial.json';
var headEnd = '[//]: # (head-end)\n';
var footStart = '[//]: # (foot-start)\n';
// Dumps tutorial into a JSON file
// Output path defaults to cwd
function dumpProject(out, options) {
    if (out === void 0) { out = utils_1.Utils.cwd(); }
    if (options === void 0) { options = {}; }
    if (out instanceof Object && !(out instanceof String)) {
        options = out;
        out = utils_1.Utils.cwd();
    }
    options = __assign({ filter: options.filter, reject: options.reject }, options);
    // Output path is relative to cwd
    out = Path.resolve(utils_1.Utils.cwd(), out);
    // If provided output path is a dir assume the dump file should be created inside of it
    if (utils_1.Utils.exists(out, 'dir')) {
        out = Path.join(out, defaultDumpFileName);
    }
    if (utils_1.Utils.exists(out, 'file')) {
        options.override = options.override || ReadlineSync.keyInYN([
            'Output path already exists.',
            'Would you like to override it and continue?',
        ].join('\n'));
        if (!options.override) {
            return;
        }
    }
    console.log();
    console.log("Dumping into " + out + "...");
    console.log();
    // Ensure submodules are updated
    // Note that we don't necessarily have to init tortilla, which is useful if we wanna reset
    // the submodules url before we proceed any further
    submodule_1.Submodule.list().forEach(function (submodule) {
        submodule_1.Submodule.update(submodule);
    });
    // Will recursively ensure dirs as well
    Fs.ensureFileSync(out);
    // Run command once
    var tags = git_1.Git([
        'log', '--tags', '--simplify-by-decoration', '--pretty=format:%ci %d'
    ]).split('\n')
        .filter(Boolean)
        .map(function (line) {
        return line.match(/^([^(]+)  \(.*tag: ([^@]+@\d+\.\d+\.\d+).*\)$/) ||
            line.match(/^([^(]+)  \(.*tag: ([^@]+@next).*\)$/);
    })
        .filter(Boolean)
        .map(function (_a) {
        var str = _a[0], date = _a[1], name = _a[2];
        return ({
            date: date,
            name: name,
        });
    })
        .sort(function (a, b) {
        return new Date(a.date) > new Date(b.date) ? -1 : 1;
    });
    var branchNames = tags
        .map(function (tag) {
        return tag.name.split('@')[0];
    })
        .reduce(function (prev, branchName) {
        if (!prev.includes(branchName)) {
            prev.push(branchName);
        }
        return prev;
    }, []);
    if (options.filter) {
        branchNames = branchNames.filter(function (branchName) {
            return options.filter.includes(branchName);
        });
    }
    if (options.reject) {
        branchNames = branchNames.filter(function (branchName) {
            return !options.reject.includes(branchName);
        });
    }
    var pack = Fs.readJsonSync(paths_1.Paths.npm.package);
    // TODO: Update test data
    // Will be defined per branch for compatibility reasons
    var repoUrl = (typeof pack.repository === 'string' ? pack.repository :
        typeof pack.repository === 'object' ? pack.repository.url :
            '').replace(/\.git$/, '');
    var dump = branchNames.map(function (branchName) {
        var historyBranchName = branchName + "-history";
        // Check if branch exists
        try {
            git_1.Git(['rev-parse', historyBranchName]);
            // If not, create it
        }
        catch (e) {
            git_1.Git.print(['branch', '--track', historyBranchName, "remotes/origin/" + historyBranchName]);
        }
        // Run command once
        var releaseTags = tags
            .filter(function (tag) {
            return tag.name.match(branchName);
        })
            .map(function (tag) { return ({
            date: tag.date,
            version: tag.name.split('@').pop(),
        }); });
        var releases = releaseTags.map(function (releaseTag, releaseIndex) {
            var prevReleaseTag = releaseTags[releaseIndex + 1] || {};
            var tagName = branchName + "@" + releaseTag.version;
            var tagRevision = git_1.Git(['rev-parse', tagName]);
            var historyRevision = git_1.Git([
                'log', historyBranchName, "--grep=^" + tagName + ":", '--format=%H',
            ]).split('\n')
                .filter(Boolean)
                .pop();
            // Instead of printing diff to stdout we will receive it as a buffer
            var changesDiff = release_1.Release.diff(prevReleaseTag.version, releaseTag.version, null, {
                branch: branchName,
                pipe: true
            });
            var manuals = Fs
                .readdirSync(paths_1.Paths.manuals.views)
                // There might also be transformed manuals inside nested dirs. If we will take
                // these dirs into an account there will be additional unexpected manuals in the
                // formed dump file
                .filter(function (fileName) { return /\.md$/.test(fileName); })
                .sort(utils_1.Utils.naturalSort)
                .map(function (manualName, stepIndex) {
                var format = '%H %s';
                var stepLog;
                var manualPath;
                // Step
                if (stepIndex) {
                    manualPath = Path.resolve(paths_1.Paths.manuals.views, manualName);
                    stepLog = git_1.Git([
                        'log', tagRevision, "--grep=^Step " + stepIndex + ":", "--format=" + format,
                    ]);
                }
                else {
                    manualPath = paths_1.Paths.readme;
                    stepLog = git_1.Git([
                        'log', git_1.Git.rootHash(tagRevision), "--format=" + format,
                    ]);
                }
                manualPath = Path.relative(utils_1.Utils.cwd(), manualPath);
                stepLog = stepLog.split(' ');
                var stepRevision = stepLog.shift();
                var manualTitle = stepLog.join(' ');
                var stepPack = JSON.parse(git_1.Git(['show', stepRevision + ":package.json"]));
                var keywords = stepPack.keywords || [];
                // Removing header and footer, since the view should be used externally on a
                // different host which will make sure to show these two
                var manualView = git_1.Git(['show', stepRevision + ":" + manualPath]);
                if (manualView.includes(headEnd)) {
                    manualView = manualView
                        .split(headEnd)
                        .slice(1)
                        .join(headEnd);
                }
                if (manualView.includes(footStart)) {
                    manualView = manualView
                        .split(footStart)
                        .slice(0, -1)
                        .join(footStart);
                }
                manualView = manualView.trim();
                return {
                    manualTitle: manualTitle,
                    stepRevision: stepRevision,
                    manualView: manualView,
                    keywords: keywords
                };
            });
            return {
                releaseVersion: releaseTag.version,
                releaseDate: releaseTag.date,
                tagName: tagName,
                tagRevision: tagRevision,
                historyRevision: historyRevision,
                changesDiff: changesDiff,
                manuals: manuals,
            };
        });
        return {
            repoUrl: repoUrl,
            branchName: branchName,
            historyBranchName: historyBranchName,
            releases: releases,
        };
    });
    Fs.writeJsonSync(out, dump, { spaces: 2 });
    console.log();
    console.log('Dump finished.');
    console.log();
}
// TODO: Make client calculate the diff on a service worker
// or serve the created HTML file (using SSR)
function diffReleases(dump, srcTag, dstTag) {
    var _a = srcTag.split('@'), srcBranchName = _a[0], srcReleaseVersion = _a[1];
    var _b = dstTag.split('@'), dstBranchName = _b[0], dstReleaseVersion = _b[1];
    if (!srcReleaseVersion && !dstReleaseVersion) {
        srcReleaseVersion = srcBranchName;
        dstReleaseVersion = dstBranchName;
        srcBranchName = null;
        dstBranchName = null;
    }
    if (semverEq(srcReleaseVersion, dstReleaseVersion)) {
        return '';
    }
    // Test result will be used later on
    var reversed = semverGt(srcReleaseVersion, dstReleaseVersion);
    if (reversed) {
        var temp = void 0;
        temp = srcReleaseVersion;
        srcReleaseVersion = dstReleaseVersion;
        dstReleaseVersion = temp;
        temp = srcBranchName;
        srcBranchName = dstBranchName;
        dstBranchName = temp;
    }
    // If an FS path was provided
    if (typeof dump === 'string' || dump instanceof String) {
        // Resolving path relative to cwd
        // Note that this is the process cwd and not the project cwd
        dump = Path.resolve(process.cwd(), dump);
        // Parsing JSON
        dump = Fs.readJSONSync(dump);
    }
    var srcDir = buildRelease(dump, srcReleaseVersion, srcBranchName);
    var dstDir = buildRelease(dump, dstReleaseVersion, dstBranchName);
    Fs.removeSync(srcDir.name + "/.git");
    Fs.copySync(dstDir.name + "/.git", srcDir.name + "/.git");
    var diff = utils_1.Utils.scopeEnv(function () {
        git_1.Git(['add', '.']);
        try {
            git_1.Git(['commit', '-m', dstReleaseVersion]);
            // No changes were made between releases
            // Probably due to missing versions of submodules
        }
        catch (e) {
            return '';
        }
        return reversed
            ? git_1.Git(['diff', 'HEAD^', 'HEAD'])
            : git_1.Git(['diff', 'HEAD', 'HEAD^']);
    }, {
        TORTILLA_CWD: srcDir.name
    });
    srcDir.removeCallback();
    dstDir.removeCallback();
    return postTransformDiff(diff);
}
function buildRelease(dump, releaseVersion, branchName) {
    // If no branch was provided, assuming this is a chunk
    var chunk = branchName ? dump.find(function (c) { return c.branchName === branchName; }) : dump;
    var releaseIndex = chunk.releases.findIndex(function (r) { return r.releaseVersion === releaseVersion; });
    // Most recent release would come LAST
    var releases = chunk.releases.slice(releaseIndex - chunk.releases.length).reverse();
    var diffs = releases.map(function (r) { return r.changesDiff; }).filter(Boolean).map(preTransformDiff);
    var dir = Tmp.dirSync({ unsafeCleanup: true });
    utils_1.Utils.scopeEnv(function () {
        git_1.Git(['init']);
        diffs.forEach(function (diff) {
            try {
                git_1.Git(['apply'], {
                    input: diff
                });
            }
            catch (e) {
                e.message += " (version " + releaseVersion + ")";
                throw e;
            }
        });
        git_1.Git(['add', '.']);
        git_1.Git(['commit', '-m', releaseVersion]);
    }, {
        TORTILLA_CWD: dir.name
    });
    return dir;
}
// TODO: Add tests
// Turns binary files into placeholders so diff can be applied
function preTransformDiff(diff) {
    return diff
        .replace(/Binary files \/dev\/null and b\/([^ ]+) differ/g, [
        '--- /dev/null',
        '+++ b/$1',
        '@@ -0,0 +1 @@',
        '+__tortilla_bin__',
    ].join('\n'))
        .replace(/Binary files a\/([^ ]+) and \/dev\/null differ/g, [
        '--- a/$1',
        '+++ /dev/null',
        '@@ -1 +0,0 @@',
        '-__tortilla_bin__',
    ].join('\n'))
        .replace(/Binary files a\/([^ ]+) and b\/([^ ]+) differ/g, [
        '--- a/$1',
        '+++ b/$2',
        '@@ -1 +1 @@',
        '-__tortilla_bin__',
        '+__tortilla_bin__',
    ].join('\n'));
}
// Turns placeholders into binary files so diff can be loyal
function postTransformDiff(diff) {
    return diff
        .replace(/--- \/dev\/null\n\+\+\+ b\/(.+)\n@@ -0,0 \+1 @@\n\+__tortilla_bin__/g, 'Binary files /dev/null and b/$1 differ')
        .replace(/--- a\/(.+)\n\+\+\+ \/dev\/null\n@@ -1 \+0,0 @@\n-__tortilla_bin__/g, 'Binary files a/$1 and /dev/null differ')
        .replace(/--- a\/(.+)\n\+\+\+ b\/(.+)\n@@ -1 \+1 @@\n-__tortilla_bin__\n\+__tortilla_bin__/g, 'Binary files a/$1 and b/$2 differ');
}
// Add vNext to semver.eq()
function semverEq(src, dst) {
    if (src === 'next' && dst === 'next') {
        return true;
    }
    if (src === 'next') {
        return false;
    }
    if (dst === 'next') {
        return false;
    }
    return semver.eq(src, dst);
}
// Add vNext to semver.gt()
function semverGt(src, dst) {
    if (src === 'next' && dst === 'next') {
        return false;
    }
    if (src === 'next') {
        return true;
    }
    if (dst === 'next') {
        return false;
    }
    return semver.gt(src, dst);
}
exports.Dump = {
    create: dumpProject,
    diffReleases: diffReleases
};
//# sourceMappingURL=dump.js.map