/*

Copyright 2009 Dmitry Naumenko (dm.naumenko@gmail.com)

This file is part of Java Diff Utils Library.

Java Diff Utils Library is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

Java Diff Utils Library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with Java Diff Utils Library. If not, see <http://www.gnu.org/licenses/>.

*/

package difflib;

import java.util.*;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import difflib.myers.*;

/**

* Implements the difference and patching engine

*

* @author <a href="dm.naumenko@gmail.com">Dmitry Naumenko</a>

* @version 0.4.1

*/

public class DiffUtils {

private static DiffAlgorithm defaultDiffAlgorithm = new MyersDiff();

private static Pattern unifiedDiffChunkRe =

Pattern.compile("@@\\s+-(?:(\\d+)(?:,(\\d+))?)\\s+\\+(?:(\\d+)(?:,(\\d+))?)\\s+@@");

/**

* Compute the difference between the original and revised texts with default diff algorithm

*

* @param original the original text

* @param revised the revised text

* @return the patch describing the difference between the original and revised texts

*/

public static Patch diff(List<?> original, List<?> revised) {

return DiffUtils.diff(original, revised, defaultDiffAlgorithm);

}

/**

* Compute the difference between the original and revised texts with given diff algorithm

*

* @param original the original text

* @param revised the revised text

* @param algorithm the given algorithm

* @return the patch describing the difference between the original and revised texts

*/

public static Patch diff(List<?> original, List<?> revised, DiffAlgorithm algorithm) {

return algorithm.diff(original, revised);

}

/**

* Patch the original text with given patch

*

* @param original the original text

* @param patch the given patch

* @return the revised text

* @throws PatchFailedException if can't apply patch

*/

public static List<?> patch(List<?> original, Patch patch) throws PatchFailedException {

return patch.applyTo(original);

}

/**

* Unpatch the revised text for a given patch

*

* @param revised the revised text

* @param patch the given patch

* @return the original text

*/

public static List<?> unpatch(List<?> revised, Patch patch) {

return patch.restore(revised); // bla-bla-bla

}

/**

* Parse the given text in unified format and creates the list of deltas for it.

*

* @param diff the text in unified format

* @return the patch with deltas.

*/

public static Patch parseUnifiedDiff(List<String> diff) {

boolean inPrelude = true;

List<Object[]> rawChunk = new ArrayList<Object[]>();

Patch patch = new Patch();

int old_ln = 0, old_n = 0, new_ln = 0, new_n = 0;

String tag = "", rest = "";

for (String line: diff) {

// Skip leading lines until after we've seen one starting with '+++'

if (inPrelude) {

if (line.startsWith("+++")) {

inPrelude = false;

}

continue;

}

Matcher m = unifiedDiffChunkRe.matcher(line);

if (m.find()) {

// Process the lines in the previous chunk

if (rawChunk.size() != 0) {

List<String> oldChunkLines = new ArrayList<String>();

List<String> newChunkLines = new ArrayList<String>();

for (Object[] raw_line: rawChunk) {

tag = (String)raw_line[0];

rest = (String)raw_line[1];

if (tag.equals(" ") || tag.equals("-")) {

oldChunkLines.add(rest);

}

if (tag.equals(" ") || tag.equals("+")) {

newChunkLines.add(rest);

}

}

patch.addDelta(new ChangeDelta(new Chunk(old_ln - 1, old_n, oldChunkLines),

new Chunk(new_ln - 1, new_n, newChunkLines)));

rawChunk.clear();

}

// Parse the @@ header

old_ln = m.group(1) == null ? 1 : Integer.parseInt(m.group(1));

old_n = m.group(2) == null ? 1 : Integer.parseInt(m.group(2));

new_ln = m.group(3) == null ? 1 : Integer.parseInt(m.group(3));

new_n = m.group(4) == null ? 1 : Integer.parseInt(m.group(4));

old_ln = Integer.parseInt(m.group(1));

if (old_ln == 0) {

old_ln += 1;

}

if (new_ln == 0) {

new_ln += 1;

}

} else {

if (line.length() > 0) {

tag = line.substring(0, 1);

rest = line.substring(1);

if (tag.equals(" ") || tag.equals("+") || tag.equals("-")) {

rawChunk.add(new Object[] {tag, rest});

}

}

}

}

// Process the lines in the last chunk

if (rawChunk.size() != 0) {

List<String> oldChunkLines = new ArrayList<String>();

List<String> newChunkLines = new ArrayList<String>();

for (Object[] raw_line: rawChunk)

{

tag = (String)raw_line[0];

rest = (String)raw_line[1];

if (tag.equals(" ") || tag.equals("-"))

{

oldChunkLines.add(rest);

}

if (tag.equals(" ") || tag.equals("+"))

{

newChunkLines.add(rest);

}

}

patch.addDelta(new ChangeDelta(new Chunk(old_ln - 1, old_n, oldChunkLines),

new Chunk(new_ln - 1, new_n, newChunkLines)));

rawChunk.clear();

}

return patch;

}

/**

* generateUnifiedDiff takes a Patch and some other arguments, returning the Unified Diff format text representing the Patch.

* @author Bill James (tankerbay@gmail.com)

*

* @param fname1 - Filename of the original (unrevised file)

* @param fname2 - Filename of the revised file

* @param originalLines - Lines of the original file

* @param patch - Patch created by the diff() function

* @param contextSize - number of lines of context output around each difference in the file.

* @return List of strings representing the Unified Diff representation of the Patch argument.

*/

public static List<String> generateUnifiedDiff(String fname1, String fname2, List<String> originalLines, Patch patch, int contextSize ) {

List<String> ret = new ArrayList<String>();

ret.add( "--- " + fname1 );

ret.add( "+++ " + fname2 );

List<Delta> cur = new ArrayList<Delta>(); // current list of Delta's to process

int deltact = patch.getDeltas().size();

// if there's more than 1 Delta, we may need to output them together

if ( deltact > 1 ) {

Delta curDelta = patch.getDelta(0);

cur.add( curDelta ); // add the first Delta to the current set

for ( int i = 1; i < deltact; i++ ) {

int curpos = curDelta.getOriginal().getPosition(); // store the current position of the first Delta

Delta nextDelta = patch.getDelta(i); // Check if the next Delta is too close to the current position

if ( (curpos + curDelta.getOriginal().getSize() + contextSize) >= ( nextDelta.getOriginal().getPosition()-contextSize ) ) {

cur.add( nextDelta ); // if it is, add it to the current set

} else {

List<String> curBlock = processDeltas( originalLines, cur, contextSize );

ret.addAll( curBlock ); // if it isn't, output the current set, then create a new

cur.clear(); // set and add the current Delta to it.

cur.add( nextDelta );

}

curDelta = nextDelta;

}

List<String> curBlock = processDeltas( originalLines, cur, contextSize ); // don't forget to process the last set of Deltas

ret.addAll( curBlock );

}

return ret;

}

/**

* processDeltas takes a list of Deltas and outputs them together in a single block of Unified-Diff-format text.

* @author Bill James (tankerbay@gmail.com)

*

* @param origLines - the lines of the original file

* @param deltas - the Deltas to be output as a single block

* @param contextSize - the number of lines of context to place around block

* @return

*/

private static List<String> processDeltas( List<String> origLines, List<Delta> deltas, int contextSize ) {

List<String> buffer = new ArrayList<String>();

int origTotal = 0; // counter for total lines output from Original

int revTotal = 0; // counter for total lines output from Original

int line;

Delta curDelta = deltas.get(0); // start with the first Delta

int origStart = curDelta.getOriginal().getPosition()+1 - contextSize; // note the +1 to overcome the 0-offset Position

if ( origStart < 1 ) origStart = 1; // clamp to the start of the file

int revStart = curDelta.getRevised().getPosition()+1 - contextSize; // note the +1 to overcome the 0-offset Position

if ( revStart < 1 ) revStart = 1; // clamp to the start of the file

int contextStart = curDelta.getOriginal().getPosition() - contextSize; // find the start of the wrapper context code

if ( contextStart < 0 ) contextStart = 0; // clamp to the start of the file

for ( line = contextStart; line < curDelta.getOriginal().getPosition(); line++ ) { // output the context before the first Delta

buffer.add( " " + origLines.get( line ) );

origTotal++;

revTotal++;

}

buffer.addAll( getDeltaText( curDelta ) ); // output the first Delta

origTotal += curDelta.getOriginal().getLines().size();

revTotal += curDelta.getRevised().getLines().size();

int deltaIndex = 1;

while ( deltaIndex < deltas.size() ) { // for each of the other Deltas

Delta nextDelta = deltas.get( deltaIndex );

int intermediateStart = curDelta.getOriginal().getPosition() + curDelta.getOriginal().getLines().size();

for ( line = intermediateStart; line < nextDelta.getOriginal().getPosition(); line++ ) {

buffer.add( " " + origLines.get( line ) ); // output the code between the last Delta and this one

origTotal++;

revTotal++;

}

buffer.addAll( getDeltaText( nextDelta ) ); // output the Delta

origTotal += nextDelta.getOriginal().getLines().size();

revTotal += nextDelta.getRevised().getLines().size();

curDelta = nextDelta;

deltaIndex++; // increment the iterator

}

// Now output the post-Delta context code, clamping the end of the file

contextStart = curDelta.getOriginal().getPosition() + curDelta.getOriginal().getLines().size();

for ( line = contextStart; ( line < (contextStart + contextSize )) && ( line < origLines.size() ); line++ ) {

buffer.add( " " + origLines.get( line ) );

origTotal++;

revTotal++;

}

// Create and insert the block header, conforming to the Unified Diff standard

StringBuffer header = new StringBuffer();

header.append( "@@ -" );

header.append( origStart );

header.append( "," );

header.append( origTotal );

header.append( " +" );

header.append( revStart );

header.append( "," );

header.append( revTotal );

header.append( " @@" );

buffer.add( 0, header.toString() );

return buffer;

}

/**

* getDeltaText returns the lines to be added to the Unified Diff text from the Delta parameter

* @author Bill James (tankerbay@gmail.com)

*

* @param delta - the Delta to output

* @return list of String lines of code.

*/

private static List<String> getDeltaText( Delta delta ) {

List<String> buffer = new ArrayList<String>();

for ( Object line: delta.getOriginal().getLines() ) {

buffer.add( "-" + line );

}

for ( Object line: delta.getRevised().getLines() ) {

buffer.add( "+" + line );

}

return buffer;

}

}