File Explorer

1"use strict";2Object.defineProperty(exports, "__esModule", { value: true });3exports.applyPatch = applyPatch;4exports.applyPatches = applyPatches;5var string_js_1 = require("../util/string.js");6var line_endings_js_1 = require("./line-endings.js");7var parse_js_1 = require("./parse.js");8var distance_iterator_js_1 = require("../util/distance-iterator.js");9/**10 * attempts to apply a unified diff patch.11 *12 * Hunks are applied first to last.13 * `applyPatch` first tries to apply the first hunk at the line number specified in the hunk header, and with all context lines matching exactly.14 * If that fails, it tries scanning backwards and forwards, one line at a time, to find a place to apply the hunk where the context lines match exactly.15 * If that still fails, and `fuzzFactor` is greater than zero, it increments the maximum number of mismatches (missing, extra, or changed context lines) that there can be between the hunk context and a region where we are trying to apply the patch such that the hunk will still be considered to match.16 * Regardless of `fuzzFactor`, lines to be deleted in the hunk *must* be present for a hunk to match, and the context lines *immediately* before and after an insertion must match exactly.17 *18 * Once a hunk is successfully fitted, the process begins again with the next hunk.19 * Regardless of `fuzzFactor`, later hunks must be applied later in the file than earlier hunks.20 *21 * If a hunk cannot be successfully fitted *anywhere* with fewer than `fuzzFactor` mismatches, `applyPatch` fails and returns `false`.22 *23 * If a hunk is successfully fitted but not at the line number specified by the hunk header, all subsequent hunks have their target line number adjusted accordingly.24 * (e.g. if the first hunk is applied 10 lines below where the hunk header said it should fit, `applyPatch` will *start* looking for somewhere to apply the second hunk 10 lines below where its hunk header says it goes.)25 *26 * If the patch was applied successfully, returns a string containing the patched text.27 * If the patch could not be applied (because some hunks in the patch couldn't be fitted to the text in `source`), `applyPatch` returns false.28 *29 * @param patch a string diff or the output from the `parsePatch` or `structuredPatch` methods.30 */31function applyPatch(source, patch, options) {32    if (options === void 0) { options = {}; }33    var patches;34    if (typeof patch === 'string') {35        patches = (0, parse_js_1.parsePatch)(patch);36    }37    else if (Array.isArray(patch)) {38        patches = patch;39    }40    else {41        patches = [patch];42    }43    if (patches.length > 1) {44        throw new Error('applyPatch only works with a single input.');45    }46    return applyStructuredPatch(source, patches[0], options);47}48function applyStructuredPatch(source, patch, options) {49    if (options === void 0) { options = {}; }50    if (options.autoConvertLineEndings || options.autoConvertLineEndings == null) {51        if ((0, string_js_1.hasOnlyWinLineEndings)(source) && (0, line_endings_js_1.isUnix)(patch)) {52            patch = (0, line_endings_js_1.unixToWin)(patch);53        }54        else if ((0, string_js_1.hasOnlyUnixLineEndings)(source) && (0, line_endings_js_1.isWin)(patch)) {55            patch = (0, line_endings_js_1.winToUnix)(patch);56        }57    }58    // Apply the diff to the input59    var lines = source.split('\n'), hunks = patch.hunks, compareLine = options.compareLine || (function (lineNumber, line, operation, patchContent) { return line === patchContent; }), fuzzFactor = options.fuzzFactor || 0;60    var minLine = 0;61    if (fuzzFactor < 0 || !Number.isInteger(fuzzFactor)) {62        throw new Error('fuzzFactor must be a non-negative integer');63    }64    // Special case for empty patch.65    if (!hunks.length) {66        return source;67    }68    // Before anything else, handle EOFNL insertion/removal. If the patch tells us to make a change69    // to the EOFNL that is redundant/impossible - i.e. to remove a newline that's not there, or add a70    // newline that already exists - then we either return false and fail to apply the patch (if71    // fuzzFactor is 0) or simply ignore the problem and do nothing (if fuzzFactor is >0).72    // If we do need to remove/add a newline at EOF, this will always be in the final hunk:73    var prevLine = '', removeEOFNL = false, addEOFNL = false;74    for (var i = 0; i < hunks[hunks.length - 1].lines.length; i++) {75        var line = hunks[hunks.length - 1].lines[i];76        if (line[0] == '\\') {77            if (prevLine[0] == '+') {78                removeEOFNL = true;79            }80            else if (prevLine[0] == '-') {81                addEOFNL = true;82            }83        }84        prevLine = line;85    }86    if (removeEOFNL) {87        if (addEOFNL) {88            // This means the final line gets changed but doesn't have a trailing newline in either the89            // original or patched version. In that case, we do nothing if fuzzFactor > 0, and if90            // fuzzFactor is 0, we simply validate that the source file has no trailing newline.91            if (!fuzzFactor && lines[lines.length - 1] == '') {92                return false;93            }94        }95        else if (lines[lines.length - 1] == '') {96            lines.pop();97        }98        else if (!fuzzFactor) {99            return false;100        }101    }102    else if (addEOFNL) {103        if (lines[lines.length - 1] != '') {104            lines.push('');105        }106        else if (!fuzzFactor) {107            return false;108        }109    }110    /**111     * Checks if the hunk can be made to fit at the provided location with at most `maxErrors`112     * insertions, substitutions, or deletions, while ensuring also that:113     * - lines deleted in the hunk match exactly, and114     * - wherever an insertion operation or block of insertion operations appears in the hunk, the115     *   immediately preceding and following lines of context match exactly116     *117     * `toPos` should be set such that lines[toPos] is meant to match hunkLines[0].118     *119     * If the hunk can be applied, returns an object with properties `oldLineLastI` and120     * `replacementLines`. Otherwise, returns null.121     */122    function applyHunk(hunkLines, toPos, maxErrors, hunkLinesI, lastContextLineMatched, patchedLines, patchedLinesLength) {123        if (hunkLinesI === void 0) { hunkLinesI = 0; }124        if (lastContextLineMatched === void 0) { lastContextLineMatched = true; }125        if (patchedLines === void 0) { patchedLines = []; }126        if (patchedLinesLength === void 0) { patchedLinesLength = 0; }127        var nConsecutiveOldContextLines = 0;128        var nextContextLineMustMatch = false;129        for (; hunkLinesI < hunkLines.length; hunkLinesI++) {130            var hunkLine = hunkLines[hunkLinesI], operation = (hunkLine.length > 0 ? hunkLine[0] : ' '), content = (hunkLine.length > 0 ? hunkLine.substr(1) : hunkLine);131            if (operation === '-') {132                if (compareLine(toPos + 1, lines[toPos], operation, content)) {133                    toPos++;134                    nConsecutiveOldContextLines = 0;135                }136                else {137                    if (!maxErrors || lines[toPos] == null) {138                        return null;139                    }140                    patchedLines[patchedLinesLength] = lines[toPos];141                    return applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1);142                }143            }144            if (operation === '+') {145                if (!lastContextLineMatched) {146                    return null;147                }148                patchedLines[patchedLinesLength] = content;149                patchedLinesLength++;150                nConsecutiveOldContextLines = 0;151                nextContextLineMustMatch = true;152            }153            if (operation === ' ') {154                nConsecutiveOldContextLines++;155                patchedLines[patchedLinesLength] = lines[toPos];156                if (compareLine(toPos + 1, lines[toPos], operation, content)) {157                    patchedLinesLength++;158                    lastContextLineMatched = true;159                    nextContextLineMustMatch = false;160                    toPos++;161                }162                else {163                    if (nextContextLineMustMatch || !maxErrors) {164                        return null;165                    }166                    // Consider 3 possibilities in sequence:167                    // 1. lines contains a *substitution* not included in the patch context, or168                    // 2. lines contains an *insertion* not included in the patch context, or169                    // 3. lines contains a *deletion* not included in the patch context170                    // The first two options are of course only possible if the line from lines is non-null -171                    // i.e. only option 3 is possible if we've overrun the end of the old file.172                    return (lines[toPos] && (applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength + 1) || applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1)) || applyHunk(hunkLines, toPos, maxErrors - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength));173                }174            }175        }176        // Before returning, trim any unmodified context lines off the end of patchedLines and reduce177        // toPos (and thus oldLineLastI) accordingly. This allows later hunks to be applied to a region178        // that starts in this hunk's trailing context.179        patchedLinesLength -= nConsecutiveOldContextLines;180        toPos -= nConsecutiveOldContextLines;181        patchedLines.length = patchedLinesLength;182        return {183            patchedLines: patchedLines,184            oldLineLastI: toPos - 1185        };186    }187    var resultLines = [];188    // Search best fit offsets for each hunk based on the previous ones189    var prevHunkOffset = 0;190    for (var i = 0; i < hunks.length; i++) {191        var hunk = hunks[i];192        var hunkResult = void 0;193        var maxLine = lines.length - hunk.oldLines + fuzzFactor;194        var toPos = void 0;195        for (var maxErrors = 0; maxErrors <= fuzzFactor; maxErrors++) {196            toPos = hunk.oldStart + prevHunkOffset - 1;197            var iterator = (0, distance_iterator_js_1.default)(toPos, minLine, maxLine);198            for (; toPos !== undefined; toPos = iterator()) {199                hunkResult = applyHunk(hunk.lines, toPos, maxErrors);200                if (hunkResult) {201                    break;202                }203            }204            if (hunkResult) {205                break;206            }207        }208        if (!hunkResult) {209            return false;210        }211        // Copy everything from the end of where we applied the last hunk to the start of this hunk212        for (var i_1 = minLine; i_1 < toPos; i_1++) {213            resultLines.push(lines[i_1]);214        }215        // Add the lines produced by applying the hunk:216        for (var i_2 = 0; i_2 < hunkResult.patchedLines.length; i_2++) {217            var line = hunkResult.patchedLines[i_2];218            resultLines.push(line);219        }220        // Set lower text limit to end of the current hunk, so next ones don't try221        // to fit over already patched text222        minLine = hunkResult.oldLineLastI + 1;223        // Note the offset between where the patch said the hunk should've applied and where we224        // applied it, so we can adjust future hunks accordingly:225        prevHunkOffset = toPos + 1 - hunk.oldStart;226    }227    // Copy over the rest of the lines from the old text228    for (var i = minLine; i < lines.length; i++) {229        resultLines.push(lines[i]);230    }231    return resultLines.join('\n');232}233/**234 * applies one or more patches.235 *236 * `patch` may be either an array of structured patch objects, or a string representing a patch in unified diff format (which may patch one or more files).237 *238 * This method will iterate over the contents of the patch and apply to data provided through callbacks. The general flow for each patch index is:239 *240 * - `options.loadFile(index, callback)` is called. The caller should then load the contents of the file and then pass that to the `callback(err, data)` callback. Passing an `err` will terminate further patch execution.241 * - `options.patched(index, content, callback)` is called once the patch has been applied. `content` will be the return value from `applyPatch`. When it's ready, the caller should call `callback(err)` callback. Passing an `err` will terminate further patch execution.242 *243 * Once all patches have been applied or an error occurs, the `options.complete(err)` callback is made.244 */245function applyPatches(uniDiff, options) {246    var spDiff = typeof uniDiff === 'string' ? (0, parse_js_1.parsePatch)(uniDiff) : uniDiff;247    var currentIndex = 0;248    function processIndex() {249        var index = spDiff[currentIndex++];250        if (!index) {251            return options.complete();252        }253        options.loadFile(index, function (err, data) {254            if (err) {255                return options.complete(err);256            }257            var updatedContent = applyPatch(data, index, options);258            options.patched(index, updatedContent, function (err) {259                if (err) {260                    return options.complete(err);261                }262                processIndex();263            });264        });265    }266    processIndex();267}268