Attachment #127474 for bug #267020

View | Details | Raw Unified | Return to bug 267020
Collapse All | Expand All





public class FileDiffResult implements IFilePatchResult {

	private FilePatch2 fDiff;
	private boolean fMatches= false;
	private boolean fDiffProblem;
	private String fErrorMessage;

	private final PatchConfiguration configuration;
	private String charset;
	
	public FileDiffResult(FilePatch2 diff, PatchConfiguration configuration) {
		super();
		fDiff = diff;
		this.configuration = configuration;

		charset = Utilities.getCharset(content);
		//If this diff is an addition, make sure that it doesn't already exist
		boolean exists = targetExists(content);
		if (fDiff.getDiffType(getConfiguration().isReversed()) == FilePatch2.ADDITION) {
			if ((!exists || isEmpty(content)) && canCreateTarget(content)) {
				fMatches= true;
			} else {

			monitor = new NullProgressMonitor();
		fBeforeLines = new ArrayList(lines);
		// TODO: What about deletions?
		if (fDiff.getDiffType(getConfiguration().isReversed()) == FilePatch2.ADDITION) {
			// Additions don't need to adjust the fuzz factor
			// TODO: What about the after lines?
			return -1;

		return failedHunks;
	}

	public FilePatch2 getDiff() {
		return fDiff;
	}





/*******************************************************************************
 * Copyright (c) 2006, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.compare.internal.core.patch;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.compare.patch.IFilePatch2;
import org.eclipse.compare.patch.IFilePatchResult;
import org.eclipse.compare.patch.IHunk;
import org.eclipse.compare.patch.PatchConfiguration;
import org.eclipse.compare.patch.ReaderCreator;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;

/**
 * A file diff represents a set of hunks that were associated with the
 * same path in a patch file.
 */
public class FileDiff implements IFilePatch2 {

	/**
	 * Difference constant (value 1) indicating one side was added.
	 */
	public static final int ADDITION= 1;
	/**
	 * Difference constant (value 2) indicating one side was removed.
	 */
	public static final int DELETION= 2;
	/**
	 * Difference constant (value 3) indicating side changed.
	 */
	public static final int CHANGE= 3;
	
	private IPath fOldPath, fNewPath;
	private long oldDate, newDate;
	private List fHunks= new ArrayList();
	private DiffProject fProject; //the project that contains this diff
	private String header;
	private int addedLines, removedLines;
	
	/**
	 * Create a file diff for the given path and date information.
	 * @param oldPath the path of the before state of the file
	 * @param oldDate the timestamp of the before state
	 * @param newPath the path of the after state
	 * @param newDate the timestamp of the after state
	 */
 	public FileDiff(IPath oldPath, long oldDate, IPath newPath, long newDate) {
		fOldPath= oldPath;
		this.oldDate = oldDate;
		fNewPath= newPath;
		this.newDate = newDate;
	}
	
 	/**
 	 * Return the parent project or <code>null</code> if there isn't one.
 	 * @return the parent project or <code>null</code>
 	 */
	public DiffProject getProject() {
		return fProject;
	}
	
	/**
	 * Set the project of this diff to the given project.
	 * This method should only be called from
	 * {@link DiffProject#add(FileDiff)}
	 * @param diffProject the parent project
	 */
	void setProject(DiffProject diffProject) {
		if (fProject == diffProject)
			return;
		if (fProject != null)
			fProject.remove(this);
		this.fProject= diffProject;
	}
	
	/**
	 * Get the path of the file diff.
	 * @param reverse whether the path of the before state or after state 
	 * should be used
	 * @return the path of the file diff
	 */
	public IPath getPath(boolean reverse) {
		if (getDiffType(reverse) == ADDITION) {
			if (reverse)
				return fOldPath;
			return fNewPath;
		}
		if (reverse && fNewPath != null)
			return fNewPath;
		if (fOldPath != null)
			return fOldPath;
		return fNewPath;
	}
	
	/**
	 * Add the hunk to this file diff.
	 * @param hunk the hunk
	 */
	public void add(Hunk hunk) {
		fHunks.add(hunk);
		hunk.setParent(this);
	}
	
	/**
	 * Remove the hunk from this file diff
	 * @param hunk the hunk
	 */
	protected void remove(Hunk hunk) {
		fHunks.remove(hunk);
	}
	
	/**
	 * Return the hunks associated with this file diff.
	 * @return the hunks associated with this file diff
	 */
	public IHunk[] getHunks() {
		return (IHunk[]) fHunks.toArray(new IHunk[fHunks.size()]);
	}
	
	/**
	 * Return the number of hunks associated with this file diff.
	 * @return the number of hunks associated with this file diff
	 */
	public int getHunkCount() {
		return fHunks.size();
	}
	
	/**
	 * Return the difference type of this file diff.
	 * @param reverse whether the patch is being reversed
	 * @return the type of this file diff
	 */
	public int getDiffType(boolean reverse) {
		if (fHunks.size() == 1) {
			boolean add = false;
			boolean delete = false;
			Iterator iter = fHunks.iterator();
			while (iter.hasNext()){
				Hunk hunk = (Hunk) iter.next();
				int type =hunk.getHunkType(reverse);
				if (type == ADDITION){
					add = true;
				} else if (type == DELETION ){
					delete = true;
				}
			}
			if (add && !delete){
				return ADDITION;
			} else if (!add && delete){
				return DELETION;
			}
		}
		return CHANGE;
	}
	
	/**
	 * Return the path of this file diff with the specified number
	 * of leading segments striped.
	 * @param strip the number of leading segments to strip from the path
	 * @param reverse whether the patch is being reversed
	 * @return the path of this file diff with the specified number
	 * of leading segments striped
	 */
	public IPath getStrippedPath(int strip, boolean reverse) {
		IPath path= getPath(reverse);
		if (strip > 0 && strip < path.segmentCount())
			path= path.removeFirstSegments(strip);
		return path;
	}
	
	/**
	 * Return the segment count of the path of this file diff.
	 * @return the segment count of the path of this file diff
	 */
	public int segmentCount() {
		//Update prefix count - go through all of the diffs and find the smallest
		//path segment contained in all diffs.
		int length= 99;
		if (fOldPath != null)
			length= Math.min(length, fOldPath.segmentCount());
		if (fNewPath != null)
			length= Math.min(length, fNewPath.segmentCount());
		return length;
	}
	
	public IFilePatchResult apply(ReaderCreator content,
			PatchConfiguration configuration, IProgressMonitor monitor) {
		FileDiffResult result = new FileDiffResult(this, configuration);
		result.refresh(content, monitor);
		return result;
	}

	public IPath getTargetPath(PatchConfiguration configuration) {
		return getStrippedPath(configuration.getPrefixSegmentStripCount(), configuration.isReversed());
	}

	public FileDiff asRelativeDiff() {
		if (fProject == null)
			return this;
		IPath adjustedOldPath = null;
		if (fOldPath != null) {
			adjustedOldPath = new Path(null, fProject.getName()).append(fOldPath);
		}
		IPath adjustedNewPath = null;
		if (fNewPath != null) {
			adjustedNewPath = new Path(null, fProject.getName()).append(fNewPath);
		}
		FileDiff diff = create(adjustedOldPath, 0, adjustedNewPath, 0);
		for (Iterator iterator = fHunks.iterator(); iterator.hasNext();) {
			Hunk hunk = (Hunk) iterator.next();
			// Creating the hunk adds it to the parent diff
			new Hunk(diff, hunk);
		}
		return diff;
	}

	protected FileDiff create(IPath oldPath, long oldDate, IPath newPath,
			long newDate) {
		return new FileDiff(oldPath, oldDate, newPath, newDate);
	}

	public void setHeader(String header) {
		this.header = header;
	}

	public String getHeader() {
		return header;
	}

	public long getBeforeDate() {
		return oldDate;
	}

	public long getAfterDate() {
		return newDate;
	}

	public void setAddedLines(int addedLines) {
		this.addedLines = addedLines;
	}
	
	public void setRemovedLines(int removedLines) {
		this.removedLines = removedLines;
	}

	public int getAddedLines() {
		return addedLines;
	}
	
	public int getRemovedLines() {
		return removedLines;
	}

}




	 * Add the file diff to this project.
	 * @param diff the file diff.
	 */
	public void add(FilePatch2 diff) {
		fDiffs.add(diff);
		if (diff.getProject() != this)
			diff.setProject(this);

	 * Remove the file diff from this project.
	 * @param diff the diff to be removed
	 */
	public void remove(FilePatch2 diff) {
		fDiffs.remove(diff);
	}


	 * @param diff a file diff
	 * @return whether this project contains the given diff
	 */
	public boolean contains(FilePatch2 diff) {
		return fDiffs.contains(diff);
	}


	 * Return the file diffs associated with this project.
	 * @return the file diffs associated with this project
	 */
	public FilePatch2[] getFileDiffs() {
		return (FilePatch2[]) fDiffs.toArray(new FilePatch2[fDiffs.size()]);
	}
}




 */
public class Hunk implements IHunk {

	private FilePatch2 fParent;
	private int fOldStart, fOldLength;
	private int fNewStart, fNewLength;
	private String[] fLines;
	private int hunkType;
	private String charset = null;

	public static Hunk createHunk(FilePatch2 parent, int[] oldRange, int[] newRange, List lines, boolean hasLineAdditions, boolean hasLineDeletions, boolean hasContextLines) {
		int oldStart = 0;
		int oldLength = 0;
		int newStart = 0;

		else
			newStart= 0;
		newLength= newRange[1];
		int hunkType = FilePatch2.CHANGE;
		if (!hasContextLines) {
			if (hasLineAdditions && !hasLineDeletions) {
				hunkType = FilePatch2.ADDITION;
			} else if (!hasLineAdditions && hasLineDeletions) {
				hunkType = FilePatch2.DELETION;
			}
		}
		return new Hunk(parent, hunkType, oldStart, oldLength, newStart, newLength, (String[]) lines.toArray(new String[lines.size()]));
	}
	
	public Hunk(FilePatch2 parent, int hunkType, int oldStart, int oldLength,
			int newStart, int newLength, String[] lines) {
		fParent = parent;
        if (fParent != null) {

		fLines = lines;
	}
	
    public Hunk(FilePatch2 parent, Hunk toCopy) {
    	this(parent, toCopy.hunkType, toCopy.fOldStart, toCopy.fOldLength, toCopy.fNewStart, toCopy.fNewLength, toCopy.fLines);
    }


	
	public int getHunkType(boolean reverse) {
		if (reverse) {
			if (hunkType == FilePatch2.ADDITION)
				return FilePatch2.DELETION;
			if (hunkType == FilePatch2.DELETION)
				return FilePatch2.ADDITION;
		}
		return hunkType;
	}


	/**
	 * Set the parent of this hunk. This method
	 * should only be invoked from {@link FilePatch2#add(Hunk)}
	 * @param diff the parent of this hunk
	 */
	void setParent(FilePatch2 diff) {
		if (fParent == diff)
			return;
		if (fParent != null)

		fParent = diff;	
	}

	public FilePatch2 getParent() {
		return fParent;
	}
	





	private boolean fIsWorkspacePatch;
	private DiffProject[] fDiffProjects;
	private FilePatch2[] fDiffs;

	// API for writing new multi-project patch format
	public static final String MULTIPROJECTPATCH_HEADER= "### Eclipse Workspace Patch"; //$NON-NLS-1$

		lr.close();

		fDiffProjects= (DiffProject[]) diffProjects.values().toArray(new DiffProject[diffProjects.size()]);
		fDiffs = (FilePatch2[]) diffs.toArray(new FilePatch2[diffs.size()]);
	}

	protected FilePatch2 createFileDiff(IPath oldPath, long oldDate,
			IPath newPath, long newDate) {
		return new FilePatch2(oldPath, oldDate, newPath, newDate);
	}

	private String readUnifiedDiff(List diffs, LineReader lr, String line, String diffArgs, String fileName, DiffProject diffProject) throws IOException {
		List newDiffs= new ArrayList();
		String nextLine= readUnifiedDiff(newDiffs, lr, line, diffArgs, fileName);
		for (Iterator iter= newDiffs.iterator(); iter.hasNext();) {
			FilePatch2 diff= (FilePatch2) iter.next();
			diffProject.add(diff);
			diffs.add(diff);
		}

			} else if (line.startsWith("--- ")) { //$NON-NLS-1$
				line= readUnifiedDiff(diffs, lr, line, diffArgs, fileName);
				if (!headerLines.isEmpty())
					setHeader((FilePatch2)diffs.get(diffs.size() - 1), headerLines);
				diffArgs= fileName= null;
				reread= true;
			} else if (line.startsWith("*** ")) { //$NON-NLS-1$
				line= readContextDiff(diffs, lr, line, diffArgs, fileName);
				if (!headerLines.isEmpty())
					setHeader((FilePatch2)diffs.get(diffs.size() - 1), headerLines);
				diffArgs= fileName= null;
				reread= true;
			}

		
		lr.close();
		
		fDiffs = (FilePatch2[]) diffs.toArray(new FilePatch2[diffs.size()]);
	}
	
	private void setHeader(FilePatch2 diff, List headerLines) {
		String header = LineReader.createString(false, headerLines);
		diff.setHeader(header);
		headerLines.clear();

			
		String[] newArgs= split(line.substring(4));
	
		FilePatch2 diff = createFileDiff(extractPath(oldArgs, 0, fileName),
				extractDate(oldArgs, 1), extractPath(newArgs, 0, fileName),
				extractDate(newArgs, 1));
		diffs.add(diff);

		
		String[] newArgs= split(line.substring(4));
						
		FilePatch2 diff = createFileDiff(extractPath(oldArgs, 0, fileName),
				extractDate(oldArgs, 1), extractPath(newArgs, 0, fileName),
				extractDate(newArgs, 1));
		diffs.add(diff);

		return fDiffProjects;
	}

	public FilePatch2[] getDiffs() {
		return fDiffs;
	}
	
	public FilePatch2[] getAdjustedDiffs() {
		if (!isWorkspacePatch() || fDiffs.length == 0)
			return fDiffs;
		List result = new ArrayList();
		for (int i = 0; i < fDiffs.length; i++) {
			FilePatch2 diff = fDiffs[i];
			result.add(diff.asRelativeDiff());
		}
		return (FilePatch2[]) result.toArray(new FilePatch2[result.size()]);
	}

}




import java.util.Arrays;
import java.util.Comparator;

import org.eclipse.compare.internal.core.patch.FilePatch2;
import org.eclipse.compare.internal.core.patch.Hunk;
import org.eclipse.core.runtime.IPath;


	public static IFilePatch2 createFilePatch(IPath oldPath, long oldDate,
			IPath newPath, long newDate, IHunk[] hunks) {
		reorder(hunks);
		FilePatch2 fileDiff = new FilePatch2(oldPath, oldDate, newPath, newDate);
		for (int i = 0; i < hunks.length; i++) {
			fileDiff.add((Hunk) hunks[i]);
		}

			boolean hasLineAdditions = checkForPrefix(ADDITION_PREFIX, lines);
			boolean hasLineDeletions = checkForPrefix(REMOVAL_PREFIX, lines);
			if (hasLineAdditions && !hasLineDeletions) {
				return FilePatch2.ADDITION;
			} else if (!hasLineAdditions && hasLineDeletions) {
				return FilePatch2.DELETION;
			}
		}
		return FilePatch2.CHANGE;
	}

	private static int getHunkLength(String[] lines, boolean old) {




/*******************************************************************************
 * Copyright (c) 2006, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.compare.internal.core.patch;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.compare.patch.IFilePatch2;
import org.eclipse.compare.patch.IFilePatchResult;
import org.eclipse.compare.patch.IHunk;
import org.eclipse.compare.patch.PatchConfiguration;
import org.eclipse.compare.patch.ReaderCreator;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;

/**
 * A file diff represents a set of hunks that were associated with the
 * same path in a patch file.
 */
public class FilePatch2 implements IFilePatch2 {

	/**
	 * Difference constant (value 1) indicating one side was added.
	 */
	public static final int ADDITION= 1;
	/**
	 * Difference constant (value 2) indicating one side was removed.
	 */
	public static final int DELETION= 2;
	/**
	 * Difference constant (value 3) indicating side changed.
	 */
	public static final int CHANGE= 3;
	
	private IPath fOldPath, fNewPath;
	private long oldDate, newDate;
	private List fHunks= new ArrayList();
	private DiffProject fProject; //the project that contains this diff
	private String header;
	private int addedLines, removedLines;
	
	/**
	 * Create a file diff for the given path and date information.
	 * @param oldPath the path of the before state of the file
	 * @param oldDate the timestamp of the before state
	 * @param newPath the path of the after state
	 * @param newDate the timestamp of the after state
	 */
 	public FilePatch2(IPath oldPath, long oldDate, IPath newPath, long newDate) {
		fOldPath= oldPath;
		this.oldDate = oldDate;
		fNewPath= newPath;
		this.newDate = newDate;
	}
	
 	/**
 	 * Return the parent project or <code>null</code> if there isn't one.
 	 * @return the parent project or <code>null</code>
 	 */
	public DiffProject getProject() {
		return fProject;
	}
	
	/**
	 * Set the project of this diff to the given project.
	 * This method should only be called from
	 * {@link DiffProject#add(FilePatch2)}
	 * @param diffProject the parent project
	 */
	void setProject(DiffProject diffProject) {
		if (fProject == diffProject)
			return;
		if (fProject != null)
			fProject.remove(this);
		this.fProject= diffProject;
	}
	
	/**
	 * Get the path of the file diff.
	 * @param reverse whether the path of the before state or after state 
	 * should be used
	 * @return the path of the file diff
	 */
	public IPath getPath(boolean reverse) {
		if (getDiffType(reverse) == ADDITION) {
			if (reverse)
				return fOldPath;
			return fNewPath;
		}
		if (reverse && fNewPath != null)
			return fNewPath;
		if (fOldPath != null)
			return fOldPath;
		return fNewPath;
	}
	
	/**
	 * Add the hunk to this file diff.
	 * @param hunk the hunk
	 */
	public void add(Hunk hunk) {
		fHunks.add(hunk);
		hunk.setParent(this);
	}
	
	/**
	 * Remove the hunk from this file diff
	 * @param hunk the hunk
	 */
	protected void remove(Hunk hunk) {
		fHunks.remove(hunk);
	}
	
	/**
	 * Return the hunks associated with this file diff.
	 * @return the hunks associated with this file diff
	 */
	public IHunk[] getHunks() {
		return (IHunk[]) fHunks.toArray(new IHunk[fHunks.size()]);
	}
	
	/**
	 * Return the number of hunks associated with this file diff.
	 * @return the number of hunks associated with this file diff
	 */
	public int getHunkCount() {
		return fHunks.size();
	}
	
	/**
	 * Return the difference type of this file diff.
	 * @param reverse whether the patch is being reversed
	 * @return the type of this file diff
	 */
	public int getDiffType(boolean reverse) {
		if (fHunks.size() == 1) {
			boolean add = false;
			boolean delete = false;
			Iterator iter = fHunks.iterator();
			while (iter.hasNext()){
				Hunk hunk = (Hunk) iter.next();
				int type =hunk.getHunkType(reverse);
				if (type == ADDITION){
					add = true;
				} else if (type == DELETION ){
					delete = true;
				}
			}
			if (add && !delete){
				return ADDITION;
			} else if (!add && delete){
				return DELETION;
			}
		}
		return CHANGE;
	}
	
	/**
	 * Return the path of this file diff with the specified number
	 * of leading segments striped.
	 * @param strip the number of leading segments to strip from the path
	 * @param reverse whether the patch is being reversed
	 * @return the path of this file diff with the specified number
	 * of leading segments striped
	 */
	public IPath getStrippedPath(int strip, boolean reverse) {
		IPath path= getPath(reverse);
		if (strip > 0 && strip < path.segmentCount())
			path= path.removeFirstSegments(strip);
		return path;
	}
	
	/**
	 * Return the segment count of the path of this file diff.
	 * @return the segment count of the path of this file diff
	 */
	public int segmentCount() {
		//Update prefix count - go through all of the diffs and find the smallest
		//path segment contained in all diffs.
		int length= 99;
		if (fOldPath != null)
			length= Math.min(length, fOldPath.segmentCount());
		if (fNewPath != null)
			length= Math.min(length, fNewPath.segmentCount());
		return length;
	}
	
	public IFilePatchResult apply(ReaderCreator content,
			PatchConfiguration configuration, IProgressMonitor monitor) {
		FileDiffResult result = new FileDiffResult(this, configuration);
		result.refresh(content, monitor);
		return result;
	}

	public IPath getTargetPath(PatchConfiguration configuration) {
		return getStrippedPath(configuration.getPrefixSegmentStripCount(), configuration.isReversed());
	}

	public FilePatch2 asRelativeDiff() {
		if (fProject == null)
			return this;
		IPath adjustedOldPath = null;
		if (fOldPath != null) {
			adjustedOldPath = new Path(null, fProject.getName()).append(fOldPath);
		}
		IPath adjustedNewPath = null;
		if (fNewPath != null) {
			adjustedNewPath = new Path(null, fProject.getName()).append(fNewPath);
		}
		FilePatch2 diff = create(adjustedOldPath, 0, adjustedNewPath, 0);
		for (Iterator iterator = fHunks.iterator(); iterator.hasNext();) {
			Hunk hunk = (Hunk) iterator.next();
			// Creating the hunk adds it to the parent diff
			new Hunk(diff, hunk);
		}
		return diff;
	}

	protected FilePatch2 create(IPath oldPath, long oldDate, IPath newPath,
			long newDate) {
		return new FilePatch2(oldPath, oldDate, newPath, newDate);
	}

	public void setHeader(String header) {
		this.header = header;
	}

	public String getHeader() {
		return header;
	}

	public long getBeforeDate() {
		return oldDate;
	}

	public long getAfterDate() {
		return newDate;
	}

	public void setAddedLines(int addedLines) {
		this.addedLines = addedLines;
	}
	
	public void setRemovedLines(int removedLines) {
		this.removedLines = removedLines;
	}

	public int getAddedLines() {
		return addedLines;
	}
	
	public int getRemovedLines() {
		return removedLines;
	}

}

Lines 18-24 Link Here

(-)src/org/eclipse/compare/tests/FileDiffResultTest.java (-2 / +2 lines)
18	import java.util.ArrayList;	18	import java.util.ArrayList;
19		19
20	import org.eclipse.compare.internal.Utilities;	20	import org.eclipse.compare.internal.Utilities;
21	import org.eclipse.compare.internal.core.patch.FileDiff;	21	import org.eclipse.compare.internal.core.patch.FilePatch2;
22	import org.eclipse.compare.internal.core.patch.FileDiffResult;	22	import org.eclipse.compare.internal.core.patch.FileDiffResult;
23	import org.eclipse.compare.internal.core.patch.Hunk;	23	import org.eclipse.compare.internal.core.patch.Hunk;
24	import org.eclipse.compare.internal.patch.Patcher;	24	import org.eclipse.compare.internal.patch.Patcher;
Lines 216-222 Link Here
216	/**	216	/**
217	* A mock FileDiff class.	217	* A mock FileDiff class.
218	*/	218	*/
219	private class MyFileDiff extends FileDiff {	219	private class MyFileDiff extends FilePatch2 {
220	protected MyFileDiff() {	220	protected MyFileDiff() {
221	super(null, 0, null, 0);	221	super(null, 0, null, 0);
222	add(Hunk.createHunk(this, new int[] { 0, 0 }, new int[] { 0, 0 },	222	add(Hunk.createHunk(this, new int[] { 0, 0 }, new int[] { 0, 0 },




import junit.framework.AssertionFailedError;
import junit.framework.TestCase;

import org.eclipse.compare.internal.core.patch.FilePatch2;
import org.eclipse.compare.internal.core.patch.FileDiffResult;
import org.eclipse.compare.internal.core.patch.LineReader;
import org.eclipse.compare.internal.patch.WorkspacePatcher;

			e.printStackTrace();
		}
		
		FilePatch2[] diffs= patcher.getDiffs();
		Assert.assertEquals(diffs.length, 1);
		
		FileDiffResult diffResult = patcher.getDiffResult(diffs[0]);

		}
		
		//Sort the diffs by project 
		FilePatch2[] diffs= patcher.getDiffs();
		
		//Iterate through all of the original files, apply the diffs that belong to the file and compare
		//with the corresponding outcome file




import org.eclipse.compare.CompareConfiguration;
import org.eclipse.compare.internal.ComparePreferencePage;
import org.eclipse.compare.internal.CompareUIPlugin;
import org.eclipse.compare.internal.core.patch.FilePatch2;
import org.eclipse.compare.internal.core.patch.PatchReader;
import org.eclipse.compare.internal.patch.FilePatch;
import org.eclipse.compare.internal.patch.PatchWizard;
import org.eclipse.compare.internal.patch.PatchWizardDialog;
import org.eclipse.compare.internal.patch.Utilities;

		BufferedReader reader = Utilities.createReader(storage);
		try {
			PatchReader patchReader = new PatchReader() {
				protected FilePatch2 createFileDiff(IPath oldPath, long oldDate,
						IPath newPath, long newDate) {
					return new FilePatch(oldPath, oldDate, newPath,
							newDate);
				}
			};
			patchReader.parse(reader);
			FilePatch2[] fileDiffs = patchReader.getAdjustedDiffs();

			IFilePatch[] filePatch = new IFilePatch[fileDiffs.length];
			for (int i = 0; i < fileDiffs.length; i++) {
				filePatch[i] = (FilePatch) fileDiffs[i];
			}

			return filePatch;





import org.eclipse.compare.internal.core.Messages;
import org.eclipse.compare.internal.core.patch.DiffProject;
import org.eclipse.compare.internal.core.patch.FilePatch2;
import org.eclipse.compare.internal.core.patch.FileDiffResult;
import org.eclipse.compare.internal.core.patch.Hunk;
import org.eclipse.compare.internal.core.patch.PatchReader;

	//	private static final int NORMAL= 2;
	//	private static final int UNIFIED= 3;
	
	private FilePatch2[] fDiffs;
	private IResource fTarget;
	// patch options
	private Set disabledElements = new HashSet();

	 * Returns an array of Diffs after a sucessfull call to <code>parse</code>.
	 * If <code>parse</code> hasn't been called returns <code>null</code>.
	 */
	public FilePatch2[] getDiffs() {
		if (fDiffs == null)
			return new FilePatch2[0];
		return fDiffs;
	}
	
	public IPath getPath(FilePatch2 diff) {
		return diff.getStrippedPath(getStripPrefixSegments(), isReversed());
	}


	
	public void parse(BufferedReader reader) throws IOException {
		PatchReader patchReader = new PatchReader() {
			protected FilePatch2 createFileDiff(IPath oldPath, long oldDate,
					IPath newPath, long newDate) {
				return new FilePatch(oldPath, oldDate, newPath, newDate);
			}
		};
		patchReader.parse(reader);

	}
	
	public void countLines() {
		FilePatch2[] fileDiffs = getDiffs();
		for (int i = 0; i < fileDiffs.length; i++) {
			int addedLines = 0;
			int removedLines = 0;
			FilePatch2 fileDiff = fileDiffs[i];
			for (int j = 0; j < fileDiff.getHunkCount(); j++) {
				IHunk hunk = fileDiff.getHunks()[j];
				String[] lines = ((Hunk) hunk).getLines();

			list.add(singleFile);
		else {
			for (i= 0; i < fDiffs.length; i++) {
				FilePatch2 diff= fDiffs[i];
				if (isEnabled(diff)) {
					switch (diff.getDiffType(isReversed())) {
					case FilePatch2.CHANGE:
						list.add(createPath(container, getPath(diff)));
						break;
					}

			
			int workTicks= WORK_UNIT;
			
			FilePatch2 diff= fDiffs[i];
			if (isEnabled(diff)) {
				
				IPath path= getPath(diff);

				
				int type= diff.getDiffType(isReversed());
				switch (type) {
				case FilePatch2.ADDITION:
					// patch it and collect rejected hunks
					List result= apply(diff, file, true, failed);
					if (result != null)
						store(LineReader.createString(isPreserveLineDelimeters(), result), file, new SubProgressMonitor(pm, workTicks));
					workTicks-= WORK_UNIT;
					break;
				case FilePatch2.DELETION:
					file.delete(true, true, new SubProgressMonitor(pm, workTicks));
					workTicks-= WORK_UNIT;
					break;
				case FilePatch2.CHANGE:
					// patch it and collect rejected hunks
					result= apply(diff, file, false, failed);
					if (result != null)

		return pp;
	}
	
	List apply(FilePatch2 diff, IFile file, boolean create, List failedHunks) {
		FileDiffResult result = getDiffResult(diff);
		List lines = LineReader.load(file, create);
		result.patch(lines, null);

	}
	

	public IFile getTargetFile(FilePatch2 diff) {
		IPath path = diff.getStrippedPath(getStripPrefixSegments(), isReversed());
		return existsInTarget(path);
	}

		int length= 99;
		if (fDiffs!=null)
			for (int i= 0; i<fDiffs.length; i++) {
				FilePatch2 diff= fDiffs[i];
				length= Math.min(length, diff.segmentCount());
			}
		return length;
	}
	
	public void addDiff(FilePatch2 newDiff){
		FilePatch2[] temp = new FilePatch2[fDiffs.length + 1];
		System.arraycopy(fDiffs,0, temp, 0, fDiffs.length);
		temp[fDiffs.length] = newDiff;
		fDiffs = temp;
	}
	
	public void removeDiff(FilePatch2 diffToRemove){
		FilePatch2[] temp = new FilePatch2[fDiffs.length - 1];
		int counter = 0;
		for (int i = 0; i < fDiffs.length; i++) {
			if (fDiffs[i] != diffToRemove){

	public void setEnabled(Object element, boolean enabled) {
		if (element instanceof DiffProject) 
			setEnabledProject((DiffProject) element, enabled);
		if (element instanceof FilePatch2) 
			setEnabledFile((FilePatch2)element, enabled);
		if (element instanceof Hunk) 
			setEnabledHunk((Hunk) element, enabled);
	}
	
	private void setEnabledProject(DiffProject projectDiff, boolean enabled) {
		FilePatch2[] diffFiles = projectDiff.getFileDiffs();
		for (int i = 0; i < diffFiles.length; i++) {
			setEnabledFile(diffFiles[i], enabled);
		}
	}
	
	private void setEnabledFile(FilePatch2 fileDiff, boolean enabled) {
		IHunk[] hunks = fileDiff.getHunks();
		for (int i = 0; i < hunks.length; i++) {
			setEnabledHunk((Hunk) hunks[i], enabled);

	private void setEnabledHunk(Hunk hunk, boolean enabled) {
		if (enabled) {
			disabledElements.remove(hunk);
			FilePatch2 file = hunk.getParent();
			disabledElements.remove(file);
			DiffProject project = file.getProject();
			if (project != null)
				disabledElements.remove(project);
		} else {
			disabledElements.add(hunk);
			FilePatch2 file = hunk.getParent();
			if (disabledElements.containsAll(Arrays.asList(file.getHunks()))) {
				disabledElements.add(file);
				DiffProject project = file.getProject();

	public int guessFuzzFactor(IProgressMonitor monitor) {
		try {
			monitor.beginTask(Messages.Patcher_2, IProgressMonitor.UNKNOWN);
			FilePatch2[] diffs= getDiffs();
			if (diffs==null||diffs.length<=0)
				return -1;
			int fuzz= -1;
			for (int i= 0; i<diffs.length; i++) {
				FilePatch2 d= diffs[i];
				IFile file= getTargetFile(d);
				if (file != null && file.exists()) {
					List lines= LineReader.load(file, false);

		refresh(getDiffs());
	}
	
	protected void refresh(FilePatch2[] diffs) {
		for (int i = 0; i < diffs.length; i++) {
			FilePatch2 diff = diffs[i];
			FileDiffResult result = getDiffResult(diff);
			((WorkspaceFileDiffResult)result).refresh();
		}
	}
	
	public FileDiffResult getDiffResult(FilePatch2 diff) {
		FileDiffResult result = (FileDiffResult)diffResults.get(diff);
		if (result == null) {
			result = new WorkspaceFileDiffResult(diff, getConfiguration());

	 * @param diff the diff
	 * @return the project that contains the diff
	 */
	public DiffProject getProject(FilePatch2 diff) {
		return diff.getProject();
	}


	 * @param diff the file diff
	 * @param contents the contents for the file diff
	 */
	public void cacheContents(FilePatch2 diff, byte[] contents) {
		contentCache.put(diff, contents);
	}
	

	 * given file diff.
	 * @param diff the file diff
	 * @return whether contents have been cached for the file diff
	 * @see #cacheContents(FilePatch2, byte[])
	 */
	public boolean hasCachedContents(FilePatch2 diff) {
		return contentCache.containsKey(diff);
	}


	 * @param diff the file diff
	 * @return the content lines that are cached for the file diff
	 */
	public List getCachedLines(FilePatch2 diff) {
		byte[] contents = (byte[])contentCache.get(diff);
		if (contents != null) {
			BufferedReader reader = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(contents)));

	 * @return the contents that are cached for the given diff or
	 * <code>null</code>
	 */
	public byte[] getCachedContents(FilePatch2 diff) {
		return (byte[])contentCache.get(diff);
	}
	

			mergedHunks.remove(hunk);
	}

	public IProject getTargetProject(FilePatch2 diff) {
		DiffProject dp = getProject(diff);
		if (dp != null)
			return Utilities.getProject(dp);

Lines 21-27 Link Here

(-)compare/org/eclipse/compare/internal/patch/UnmatchedHunkTypedElement.java (-2 / +2 lines)
21	import org.eclipse.compare.ITypedElement;	21	import org.eclipse.compare.ITypedElement;
22	import org.eclipse.compare.internal.CompareUIPlugin;	22	import org.eclipse.compare.internal.CompareUIPlugin;
23	import org.eclipse.compare.internal.ContentChangeNotifier;	23	import org.eclipse.compare.internal.ContentChangeNotifier;
24	import org.eclipse.compare.internal.core.patch.FileDiff;	24	import org.eclipse.compare.internal.core.patch.FilePatch2;
25	import org.eclipse.compare.internal.core.patch.HunkResult;	25	import org.eclipse.compare.internal.core.patch.HunkResult;
26	import org.eclipse.compare.patch.PatchConfiguration;	26	import org.eclipse.compare.patch.PatchConfiguration;
27	import org.eclipse.core.resources.IFile;	27	import org.eclipse.core.resources.IFile;
Lines 79-85 Link Here
79	changeNotifier.fireContentChanged();	79	changeNotifier.fireContentChanged();
80	}	80	}
81		81
82	private FileDiff getDiff() {	82	private FilePatch2 getDiff() {
83	return getHunkResult().getDiffResult().getDiff();	83	return getHunkResult().getDiffResult().getDiff();
84	}	84	}
85		85

Lines 12-18 Link Here

(-)compare/org/eclipse/compare/internal/patch/WorkspaceFileDiffResult.java (-2 / +2 lines)
12		12
13	import java.util.List;	13	import java.util.List;
14		14
15	import org.eclipse.compare.internal.core.patch.FileDiff;	15	import org.eclipse.compare.internal.core.patch.FilePatch2;
16	import org.eclipse.compare.internal.core.patch.FileDiffResult;	16	import org.eclipse.compare.internal.core.patch.FileDiffResult;
17	import org.eclipse.compare.patch.PatchConfiguration;	17	import org.eclipse.compare.patch.PatchConfiguration;
18	import org.eclipse.core.resources.IFile;	18	import org.eclipse.core.resources.IFile;
Lines 21-27 Link Here
21		21
22	public class WorkspaceFileDiffResult extends FileDiffResult {	22	public class WorkspaceFileDiffResult extends FileDiffResult {
23		23
24	public WorkspaceFileDiffResult(FileDiff diff,	24	public WorkspaceFileDiffResult(FilePatch2 diff,
25	PatchConfiguration configuration) {	25	PatchConfiguration configuration) {
26	super(diff, configuration);	26	super(diff, configuration);
27	}	27	}





import org.eclipse.compare.internal.core.Messages;
import org.eclipse.compare.internal.core.patch.DiffProject;
import org.eclipse.compare.internal.core.patch.FilePatch2;
import org.eclipse.compare.internal.core.patch.Hunk;
import org.eclipse.compare.internal.core.patch.PatchReader;
import org.eclipse.compare.patch.IHunk;

				return;
			}

			FilePatch2[] diffs = getDiffs();
			if (pm != null) {
				String message= Messages.WorkspacePatcher_0;
				pm.beginTask(message, diffs.length * WORK_UNIT);


				int workTicks= WORK_UNIT;

				FilePatch2 diff= diffs[i];
				if (isAccessible(diff)) {
					IFile file= getTargetFile(diff);
					IPath path= file.getProjectRelativePath();


					int type= diff.getDiffType(isReversed());
					switch (type) {
						case FilePatch2.ADDITION :
							// patch it and collect rejected hunks
							List result= apply(diff, file, true, failed);
							if (result != null)
								store(LineReader.createString(isPreserveLineDelimeters(), result), file, new SubProgressMonitor(pm, workTicks));
							workTicks -= WORK_UNIT;
							break;
						case FilePatch2.DELETION :
							file.delete(true, true, new SubProgressMonitor(pm, workTicks));
							workTicks -= WORK_UNIT;
							break;
						case FilePatch2.CHANGE :
							// patch it and collect rejected hunks
							result= apply(diff, file, false, failed);
							if (result != null)

		}
	}
	
	private boolean isAccessible(FilePatch2 diff) {
		return isEnabled(diff) && Utilities.getProject(diff.getProject()).isAccessible();
	}


	 */
	public IFile[] getTargetFiles(DiffProject project) {
		List files= new ArrayList();
		FilePatch2[] diffs = project.getFileDiffs();
		for (int i = 0; i < diffs.length; i++) {
			FilePatch2 diff = diffs[i];
			if (isEnabled(diff)) {
				files.add(getTargetFile(diff));
			}

		return (IFile[]) files.toArray(new IFile[files.size()]);
	}

	public IFile getTargetFile(FilePatch2 diff) {
		IPath path = diff.getStrippedPath(getStripPrefixSegments(), isReversed());
		DiffProject project = getProject(diff);
		if (project != null)

		return super.getTargetFile(diff);
	}
	
	private IPath getFullPath(FilePatch2 diff) {
		IPath path = diff.getStrippedPath(getStripPrefixSegments(), isReversed());
		DiffProject project = getProject(diff);
		if (project != null)

	}	
	
	protected Object getElementParent(Object element) {
		if (element instanceof FilePatch2 && fDiffProjects != null) {
			FilePatch2 diff = (FilePatch2) element;
			for (int i = 0; i < fDiffProjects.length; i++) {
				DiffProject project = fDiffProjects[i];
				if (project.contains(diff))

		return (IPath)retargetedDiffs.get(object);
	}

	public void retargetDiff(FilePatch2 diff, IFile file) {
		retargetedDiffs.put(diff, diff.getPath(false));
		IHunk[] hunks = diff.getHunks();
		

			diff.getProject().remove(diff);
		}
		removeDiff(diff);
		FilePatch2 newDiff = getDiffForFile(file);
		for (int i = 0; i < hunks.length; i++) {
			Hunk hunk = (Hunk) hunks[i];
			newDiff.add(hunk);
		}
	}

	private FilePatch2 getDiffForFile(IFile file) {
		DiffProject diffProject = null;
		FilePatch2[] diffsToCheck;
		if (isWorkspacePatch()){
			// Check if the diff project already exists for the file
			IProject project = file.getProject();

		}
		// Check to see if a diff already exists for the file
		for (int i = 0; i < diffsToCheck.length; i++) {
			FilePatch2 fileDiff = diffsToCheck[i];
			if (isDiffForFile(fileDiff, file)) {
				return fileDiff;
			}

		
		// Create a new diff for the file
		IPath path = getDiffPath(file);
		FilePatch2 newDiff = new FilePatch2(path, 0, path, 0);
		if (diffProject != null){
			diffProject.add(newDiff);
		}

		return file.getFullPath().removeFirstSegments(getTarget().getFullPath().segmentCount());
	}

	private boolean isDiffForFile(FilePatch2 fileDiff, IFile file) {
		return getFullPath(fileDiff).equals(file.getFullPath());
	}


	}

	public void retargetHunk(Hunk hunk, IFile file) {
		FilePatch2 newDiff = getDiffForFile(file);
		newDiff.add(hunk);
	}

	public void retargetProject(DiffProject project, IProject targetProject) {
		retargetedDiffs.put(project, Utilities.getProject(project).getFullPath());
		FilePatch2[] diffs = project.getFileDiffs();
		DiffProject selectedProject = getDiffProject(targetProject);
		if (selectedProject == null)
			selectedProject = addDiffProjectForProject(targetProject);




import java.util.ArrayList;

import org.eclipse.compare.internal.core.patch.DiffProject;
import org.eclipse.compare.internal.core.patch.FilePatch2;
import org.eclipse.compare.internal.core.patch.Hunk;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.Assert;

		} else if (fSelectedNode instanceof PatchFileDiffNode) {
			PatchFileDiffNode node = (PatchFileDiffNode) fSelectedNode;
			//copy over all hunks to new target resource
			FilePatch2 diff = node.getDiffResult().getDiff();
			return NLS.bind(PatchMessages.RetargetPatchElementDialog_0, fPatcher.getPath(diff));
		} else if (fSelectedNode instanceof HunkDiffNode) {
			HunkDiffNode node = (HunkDiffNode) fSelectedNode;

			} else if (fSelectedNode instanceof PatchFileDiffNode && fSelectedResource instanceof IFile) {
				PatchFileDiffNode node = (PatchFileDiffNode) fSelectedNode;
				//copy over all hunks to new target resource
				FilePatch2 diff = node.getDiffResult().getDiff();
				fPatcher.retargetDiff(diff, (IFile)fSelectedResource);
			} else if (fSelectedNode instanceof HunkDiffNode && fSelectedResource instanceof IFile) {
				HunkDiffNode node = (HunkDiffNode) fSelectedNode;




import org.eclipse.compare.*;
import org.eclipse.compare.internal.*;
import org.eclipse.compare.internal.core.patch.DiffProject;
import org.eclipse.compare.internal.core.patch.FilePatch2;
import org.eclipse.compare.internal.core.patch.FileDiffResult;
import org.eclipse.compare.internal.core.patch.HunkResult;
import org.eclipse.compare.patch.PatchConfiguration;

		getViewer().refresh();
	}
	
	private void processDiffs(FilePatch2[] diffs) { 
		for (int i = 0; i < diffs.length; i++) {
			processDiff(diffs[i], getRoot());
		}

		//create diffProject nodes
		for (int i = 0; i < diffProjects.length; i++) {
			PatchProjectDiffNode projectNode = new PatchProjectDiffNode(getRoot(), diffProjects[i], getPatcher().getConfiguration());
			FilePatch2[] diffs = diffProjects[i].getFileDiffs();
			for (int j = 0; j < diffs.length; j++) {
				FilePatch2 fileDiff = diffs[j];
				processDiff(fileDiff, projectNode);
			}
		}
	}

	private void processDiff(FilePatch2 diff, DiffNode parent) {
		FileDiffResult diffResult = getPatcher().getDiffResult(diff);
		PatchFileDiffNode node = PatchFileDiffNode.createDiffNode(parent, diffResult);
		HunkResult[] hunkResults = diffResult.getHunkResults();




import org.eclipse.compare.internal.ComparePreferencePage;
import org.eclipse.compare.internal.CompareUIPlugin;
import org.eclipse.compare.internal.ICompareUIConstants;
import org.eclipse.compare.internal.core.patch.FilePatch2;
import org.eclipse.compare.internal.core.patch.Hunk;
import org.eclipse.compare.patch.IHunk;
import org.eclipse.core.runtime.Assert;

				&& (removedLinesRegex == null || "".equals(removedLinesRegex))) { //$NON-NLS-1$
			
			fPatcher.countLines();
			FilePatch2[] fileDiffs = fPatcher.getDiffs();
			for (int i = 0; i < fileDiffs.length; i++) {
				added += fileDiffs[i].getAddedLines();
				removed += fileDiffs[i].getRemovedLines();

			Pattern addedPattern = Pattern.compile(addedLinesRegex);
			Pattern removedPattern = Pattern.compile(removedLinesRegex);

			FilePatch2[] fileDiffs = fPatcher.getDiffs();
			for (int i = 0; i < fileDiffs.length; i++) {
				IHunk[] hunks = fileDiffs[i].getHunks();
				for (int j = 0; j < hunks.length; j++) {




/*******************************************************************************
 * Copyright (c) 2006, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

package org.eclipse.compare.internal.patch;

import org.eclipse.compare.*;
import org.eclipse.compare.internal.core.patch.FilePatch2;
import org.eclipse.compare.internal.core.patch.FileDiffResult;
import org.eclipse.compare.patch.PatchConfiguration;
import org.eclipse.compare.structuremergeviewer.*;

	private static int convertFileDiffTypeToDifferencerType(int fileDiffKind) {
		int kind;
		switch (fileDiffKind) {
		case FilePatch2.ADDITION:
			kind = Differencer.ADDITION;
			break;
		case FilePatch2.DELETION:
			kind = Differencer.DELETION;
			break;
		case FilePatch2.CHANGE:
			kind = Differencer.CHANGE;
			break;
		default:




/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at


import org.eclipse.compare.internal.ICompareContextIds;
import org.eclipse.compare.internal.Utilities;
import org.eclipse.compare.internal.core.patch.FilePatch2;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;

		// Read in the patch
		readInPatch();
		
		FilePatch2[] diffs= patcher.getDiffs();
		if (diffs == null || diffs.length == 0) {
			String format= PatchMessages.InputPatchPage_NoDiffsFound_format;	
			String message= MessageFormat.format(format, new String[] { fPatchSource });

			return false;
		}

		FilePatch2[] diffs= patcher.getDiffs();
		if (diffs == null || diffs.length == 0)
			return false;
		return true;




/*******************************************************************************
 * Copyright (c) 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.compare.internal.patch;

import org.eclipse.compare.internal.core.patch.FileDiff;
import org.eclipse.compare.patch.IFilePatch;
import org.eclipse.compare.patch.IFilePatchResult;
import org.eclipse.compare.patch.PatchConfiguration;
import org.eclipse.core.resources.IStorage;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;

public class FileDiffWrapper extends FileDiff implements IFilePatch {

	public FileDiffWrapper(IPath oldPath, long oldDate, IPath newPath,
			long newDate) {
		super(oldPath, oldDate, newPath, newDate);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.compare.patch.IFilePatch#apply(org.eclipse.core.resources
	 * .IStorage, org.eclipse.compare.patch.PatchConfiguration,
	 * org.eclipse.core.runtime.IProgressMonitor)
	 */
	public IFilePatchResult apply(IStorage content,
			PatchConfiguration configuration, IProgressMonitor monitor) {
		return apply(content != null ? Utilities.getReaderCreator(content)
				: null, configuration, monitor);
	}

	protected FileDiff create(IPath oldPath, long oldDate, IPath newPath,
			long newDate) {
		return new FileDiffWrapper(oldPath, oldDate, newPath, newDate);
	}

}




/*******************************************************************************
 * Copyright (c) 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.compare.internal.patch;

import org.eclipse.compare.internal.core.patch.FilePatch2;
import org.eclipse.compare.patch.IFilePatch;
import org.eclipse.compare.patch.IFilePatchResult;
import org.eclipse.compare.patch.PatchConfiguration;
import org.eclipse.core.resources.IStorage;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;

public class FilePatch extends FilePatch2 implements IFilePatch {

	public FilePatch(IPath oldPath, long oldDate, IPath newPath,
			long newDate) {
		super(oldPath, oldDate, newPath, newDate);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.compare.patch.IFilePatch#apply(org.eclipse.core.resources
	 * .IStorage, org.eclipse.compare.patch.PatchConfiguration,
	 * org.eclipse.core.runtime.IProgressMonitor)
	 */
	public IFilePatchResult apply(IStorage content,
			PatchConfiguration configuration, IProgressMonitor monitor) {
		return apply(content != null ? Utilities.getReaderCreator(content)
				: null, configuration, monitor);
	}

	protected FilePatch2 create(IPath oldPath, long oldDate, IPath newPath,
			long newDate) {
		return new FilePatch(oldPath, oldDate, newPath, newDate);
	}

}

Return to bug 267020

Lines 32-38 Link Here

(-)src/org/eclipse/compare/internal/core/patch/FileDiffResult.java (-5 / +5 lines)
32		32
33	public class FileDiffResult implements IFilePatchResult {	33	public class FileDiffResult implements IFilePatchResult {
34		34
35	private FileDiff fDiff;	35	private FilePatch2 fDiff;
36	private boolean fMatches= false;	36	private boolean fMatches= false;
37	private boolean fDiffProblem;	37	private boolean fDiffProblem;
38	private String fErrorMessage;	38	private String fErrorMessage;
Lines 41-47 Link Here
41	private final PatchConfiguration configuration;	41	private final PatchConfiguration configuration;
42	private String charset;	42	private String charset;
43		43
44	public FileDiffResult(FileDiff diff, PatchConfiguration configuration) {	44	public FileDiffResult(FilePatch2 diff, PatchConfiguration configuration) {
45	super();	45	super();
46	fDiff = diff;	46	fDiff = diff;
47	this.configuration = configuration;	47	this.configuration = configuration;
Lines 73-79 Link Here
73	charset = Utilities.getCharset(content);	73	charset = Utilities.getCharset(content);
74	//If this diff is an addition, make sure that it doesn't already exist	74	//If this diff is an addition, make sure that it doesn't already exist
75	boolean exists = targetExists(content);	75	boolean exists = targetExists(content);
76	if (fDiff.getDiffType(getConfiguration().isReversed()) == FileDiff.ADDITION) {	76	if (fDiff.getDiffType(getConfiguration().isReversed()) == FilePatch2.ADDITION) {
77	if ((!exists \|\| isEmpty(content)) && canCreateTarget(content)) {	77	if ((!exists \|\| isEmpty(content)) && canCreateTarget(content)) {
78	fMatches= true;	78	fMatches= true;
79	} else {	79	} else {
Lines 220-226 Link Here
220	monitor = new NullProgressMonitor();	220	monitor = new NullProgressMonitor();
221	fBeforeLines = new ArrayList(lines);	221	fBeforeLines = new ArrayList(lines);
222	// TODO: What about deletions?	222	// TODO: What about deletions?
223	if (fDiff.getDiffType(getConfiguration().isReversed()) == FileDiff.ADDITION) {	223	if (fDiff.getDiffType(getConfiguration().isReversed()) == FilePatch2.ADDITION) {
224	// Additions don't need to adjust the fuzz factor	224	// Additions don't need to adjust the fuzz factor
225	// TODO: What about the after lines?	225	// TODO: What about the after lines?
226	return -1;	226	return -1;
Lines 268-274 Link Here
268	return failedHunks;	268	return failedHunks;
269	}	269	}
270		270
271	public FileDiff getDiff() {	271	public FilePatch2 getDiff() {
272	return fDiff;	272	return fDiff;
273	}	273	}
274		274

Lines 35-41 Link Here

(-)src/org/eclipse/compare/internal/core/patch/DiffProject.java (-5 / +5 lines)
35	* Add the file diff to this project.	35	* Add the file diff to this project.
36	* @param diff the file diff.	36	* @param diff the file diff.
37	*/	37	*/
38	public void add(FileDiff diff) {	38	public void add(FilePatch2 diff) {
39	fDiffs.add(diff);	39	fDiffs.add(diff);
40	if (diff.getProject() != this)	40	if (diff.getProject() != this)
41	diff.setProject(this);	41	diff.setProject(this);
Lines 53-59 Link Here
53	* Remove the file diff from this project.	53	* Remove the file diff from this project.
54	* @param diff the diff to be removed	54	* @param diff the diff to be removed
55	*/	55	*/
56	public void remove(FileDiff diff) {	56	public void remove(FilePatch2 diff) {
57	fDiffs.remove(diff);	57	fDiffs.remove(diff);
58	}	58	}
59		59
Lines 62-68 Link Here
62	* @param diff a file diff	62	* @param diff a file diff
63	* @return whether this project contains the given diff	63	* @return whether this project contains the given diff
64	*/	64	*/
65	public boolean contains(FileDiff diff) {	65	public boolean contains(FilePatch2 diff) {
66	return fDiffs.contains(diff);	66	return fDiffs.contains(diff);
67	}	67	}
68		68
Lines 70-76 Link Here
70	* Return the file diffs associated with this project.	70	* Return the file diffs associated with this project.
71	* @return the file diffs associated with this project	71	* @return the file diffs associated with this project
72	*/	72	*/
73	public FileDiff[] getFileDiffs() {	73	public FilePatch2[] getFileDiffs() {
74	return (FileDiff[]) fDiffs.toArray(new FileDiff[fDiffs.size()]);	74	return (FilePatch2[]) fDiffs.toArray(new FilePatch2[fDiffs.size()]);
75	}	75	}
76	}	76	}

Lines 24-37 Link Here

(-)src/org/eclipse/compare/internal/core/patch/Hunk.java (-14 / +14 lines)
24	*/	24	*/
25	public class Hunk implements IHunk {	25	public class Hunk implements IHunk {
26		26
27	private FileDiff fParent;	27	private FilePatch2 fParent;
28	private int fOldStart, fOldLength;	28	private int fOldStart, fOldLength;
29	private int fNewStart, fNewLength;	29	private int fNewStart, fNewLength;
30	private String[] fLines;	30	private String[] fLines;
31	private int hunkType;	31	private int hunkType;
32	private String charset = null;	32	private String charset = null;
33		33
34	public static Hunk createHunk(FileDiff parent, int[] oldRange, int[] newRange, List lines, boolean hasLineAdditions, boolean hasLineDeletions, boolean hasContextLines) {	34	public static Hunk createHunk(FilePatch2 parent, int[] oldRange, int[] newRange, List lines, boolean hasLineAdditions, boolean hasLineDeletions, boolean hasContextLines) {
35	int oldStart = 0;	35	int oldStart = 0;
36	int oldLength = 0;	36	int oldLength = 0;
37	int newStart = 0;	37	int newStart = 0;
Lines 46-63 Link Here
46	else	46	else
47	newStart= 0;	47	newStart= 0;
48	newLength= newRange[1];	48	newLength= newRange[1];
49	int hunkType = FileDiff.CHANGE;	49	int hunkType = FilePatch2.CHANGE;
50	if (!hasContextLines) {	50	if (!hasContextLines) {
51	if (hasLineAdditions && !hasLineDeletions) {	51	if (hasLineAdditions && !hasLineDeletions) {
52	hunkType = FileDiff.ADDITION;	52	hunkType = FilePatch2.ADDITION;
53	} else if (!hasLineAdditions && hasLineDeletions) {	53	} else if (!hasLineAdditions && hasLineDeletions) {
54	hunkType = FileDiff.DELETION;	54	hunkType = FilePatch2.DELETION;
55	}	55	}
56	}	56	}
57	return new Hunk(parent, hunkType, oldStart, oldLength, newStart, newLength, (String[]) lines.toArray(new String[lines.size()]));	57	return new Hunk(parent, hunkType, oldStart, oldLength, newStart, newLength, (String[]) lines.toArray(new String[lines.size()]));
58	}	58	}
59		59
60	public Hunk(FileDiff parent, int hunkType, int oldStart, int oldLength,	60	public Hunk(FilePatch2 parent, int hunkType, int oldStart, int oldLength,
61	int newStart, int newLength, String[] lines) {	61	int newStart, int newLength, String[] lines) {
62	fParent = parent;	62	fParent = parent;
63	if (fParent != null) {	63	if (fParent != null) {
Lines 71-77 Link Here
71	fLines = lines;	71	fLines = lines;
72	}	72	}
73		73
74	public Hunk(FileDiff parent, Hunk toCopy) {	74	public Hunk(FilePatch2 parent, Hunk toCopy) {
75	this(parent, toCopy.hunkType, toCopy.fOldStart, toCopy.fOldLength, toCopy.fNewStart, toCopy.fNewLength, toCopy.fLines);	75	this(parent, toCopy.hunkType, toCopy.fOldStart, toCopy.fOldLength, toCopy.fNewStart, toCopy.fNewLength, toCopy.fLines);
76	}	76	}
77		77
Lines 129-138 Link Here
129		129
130	public int getHunkType(boolean reverse) {	130	public int getHunkType(boolean reverse) {
131	if (reverse) {	131	if (reverse) {
132	if (hunkType == FileDiff.ADDITION)	132	if (hunkType == FilePatch2.ADDITION)
133	return FileDiff.DELETION;	133	return FilePatch2.DELETION;
134	if (hunkType == FileDiff.DELETION)	134	if (hunkType == FilePatch2.DELETION)
135	return FileDiff.ADDITION;	135	return FilePatch2.ADDITION;
136	}	136	}
137	return hunkType;	137	return hunkType;
138	}	138	}
Lines 153-162 Link Here
153		153
154	/**	154	/**
155	* Set the parent of this hunk. This method	155	* Set the parent of this hunk. This method
156	* should only be invoked from {@link FileDiff#add(Hunk)}	156	* should only be invoked from {@link FilePatch2#add(Hunk)}
157	* @param diff the parent of this hunk	157	* @param diff the parent of this hunk
158	*/	158	*/
159	void setParent(FileDiff diff) {	159	void setParent(FilePatch2 diff) {
160	if (fParent == diff)	160	if (fParent == diff)
161	return;	161	return;
162	if (fParent != null)	162	if (fParent != null)
Lines 164-170 Link Here
164	fParent = diff;	164	fParent = diff;
165	}	165	}
166		166
167	public FileDiff getParent() {	167	public FilePatch2 getParent() {
168	return fParent;	168	return fParent;
169	}	169	}
170		170

Lines 53-59 Link Here

(-)src/org/eclipse/compare/internal/core/patch/PatchReader.java (-15 / +15 lines)
53		53
54	private boolean fIsWorkspacePatch;	54	private boolean fIsWorkspacePatch;
55	private DiffProject[] fDiffProjects;	55	private DiffProject[] fDiffProjects;
56	private FileDiff[] fDiffs;	56	private FilePatch2[] fDiffs;
57		57
58	// API for writing new multi-project patch format	58	// API for writing new multi-project patch format
59	public static final String MULTIPROJECTPATCH_HEADER= "### Eclipse Workspace Patch"; //$NON-NLS-1$	59	public static final String MULTIPROJECTPATCH_HEADER= "### Eclipse Workspace Patch"; //$NON-NLS-1$
Lines 152-170 Link Here
152	lr.close();	152	lr.close();
153		153
154	fDiffProjects= (DiffProject[]) diffProjects.values().toArray(new DiffProject[diffProjects.size()]);	154	fDiffProjects= (DiffProject[]) diffProjects.values().toArray(new DiffProject[diffProjects.size()]);
155	fDiffs = (FileDiff[]) diffs.toArray(new FileDiff[diffs.size()]);	155	fDiffs = (FilePatch2[]) diffs.toArray(new FilePatch2[diffs.size()]);
156	}	156	}
157		157
158	protected FileDiff createFileDiff(IPath oldPath, long oldDate,	158	protected FilePatch2 createFileDiff(IPath oldPath, long oldDate,
159	IPath newPath, long newDate) {	159	IPath newPath, long newDate) {
160	return new FileDiff(oldPath, oldDate, newPath, newDate);	160	return new FilePatch2(oldPath, oldDate, newPath, newDate);
161	}	161	}
162		162
163	private String readUnifiedDiff(List diffs, LineReader lr, String line, String diffArgs, String fileName, DiffProject diffProject) throws IOException {	163	private String readUnifiedDiff(List diffs, LineReader lr, String line, String diffArgs, String fileName, DiffProject diffProject) throws IOException {
164	List newDiffs= new ArrayList();	164	List newDiffs= new ArrayList();
165	String nextLine= readUnifiedDiff(newDiffs, lr, line, diffArgs, fileName);	165	String nextLine= readUnifiedDiff(newDiffs, lr, line, diffArgs, fileName);
166	for (Iterator iter= newDiffs.iterator(); iter.hasNext();) {	166	for (Iterator iter= newDiffs.iterator(); iter.hasNext();) {
167	FileDiff diff= (FileDiff) iter.next();	167	FilePatch2 diff= (FilePatch2) iter.next();
168	diffProject.add(diff);	168	diffProject.add(diff);
169	diffs.add(diff);	169	diffs.add(diff);
170	}	170	}
Lines 195-207 Link Here
195	} else if (line.startsWith("--- ")) { //$NON-NLS-1$	195	} else if (line.startsWith("--- ")) { //$NON-NLS-1$
196	line= readUnifiedDiff(diffs, lr, line, diffArgs, fileName);	196	line= readUnifiedDiff(diffs, lr, line, diffArgs, fileName);
197	if (!headerLines.isEmpty())	197	if (!headerLines.isEmpty())
198	setHeader((FileDiff)diffs.get(diffs.size() - 1), headerLines);	198	setHeader((FilePatch2)diffs.get(diffs.size() - 1), headerLines);
199	diffArgs= fileName= null;	199	diffArgs= fileName= null;
200	reread= true;	200	reread= true;
201	} else if (line.startsWith("*** ")) { //$NON-NLS-1$	201	} else if (line.startsWith("*** ")) { //$NON-NLS-1$
202	line= readContextDiff(diffs, lr, line, diffArgs, fileName);	202	line= readContextDiff(diffs, lr, line, diffArgs, fileName);
203	if (!headerLines.isEmpty())	203	if (!headerLines.isEmpty())
204	setHeader((FileDiff)diffs.get(diffs.size() - 1), headerLines);	204	setHeader((FilePatch2)diffs.get(diffs.size() - 1), headerLines);
205	diffArgs= fileName= null;	205	diffArgs= fileName= null;
206	reread= true;	206	reread= true;
207	}	207	}
Lines 215-224 Link Here
215		215
216	lr.close();	216	lr.close();
217		217
218	fDiffs = (FileDiff[]) diffs.toArray(new FileDiff[diffs.size()]);	218	fDiffs = (FilePatch2[]) diffs.toArray(new FilePatch2[diffs.size()]);
219	}	219	}
220		220
221	private void setHeader(FileDiff diff, List headerLines) {	221	private void setHeader(FilePatch2 diff, List headerLines) {
222	String header = LineReader.createString(false, headerLines);	222	String header = LineReader.createString(false, headerLines);
223	diff.setHeader(header);	223	diff.setHeader(header);
224	headerLines.clear();	224	headerLines.clear();
Lines 238-244 Link Here
238		238
239	String[] newArgs= split(line.substring(4));	239	String[] newArgs= split(line.substring(4));
240		240
241	FileDiff diff = createFileDiff(extractPath(oldArgs, 0, fileName),	241	FilePatch2 diff = createFileDiff(extractPath(oldArgs, 0, fileName),
242	extractDate(oldArgs, 1), extractPath(newArgs, 0, fileName),	242	extractDate(oldArgs, 1), extractPath(newArgs, 0, fileName),
243	extractDate(newArgs, 1));	243	extractDate(newArgs, 1));
244	diffs.add(diff);	244	diffs.add(diff);
Lines 344-350 Link Here
344		344
345	String[] newArgs= split(line.substring(4));	345	String[] newArgs= split(line.substring(4));
346		346
347	FileDiff diff = createFileDiff(extractPath(oldArgs, 0, fileName),	347	FilePatch2 diff = createFileDiff(extractPath(oldArgs, 0, fileName),
348	extractDate(oldArgs, 1), extractPath(newArgs, 0, fileName),	348	extractDate(oldArgs, 1), extractPath(newArgs, 0, fileName),
349	extractDate(newArgs, 1));	349	extractDate(newArgs, 1));
350	diffs.add(diff);	350	diffs.add(diff);
Lines 657-675 Link Here
657	return fDiffProjects;	657	return fDiffProjects;
658	}	658	}
659		659
660	public FileDiff[] getDiffs() {	660	public FilePatch2[] getDiffs() {
661	return fDiffs;	661	return fDiffs;
662	}	662	}
663		663
664	public FileDiff[] getAdjustedDiffs() {	664	public FilePatch2[] getAdjustedDiffs() {
665	if (!isWorkspacePatch() \|\| fDiffs.length == 0)	665	if (!isWorkspacePatch() \|\| fDiffs.length == 0)
666	return fDiffs;	666	return fDiffs;
667	List result = new ArrayList();	667	List result = new ArrayList();
668	for (int i = 0; i < fDiffs.length; i++) {	668	for (int i = 0; i < fDiffs.length; i++) {
669	FileDiff diff = fDiffs[i];	669	FilePatch2 diff = fDiffs[i];
670	result.add(diff.asRelativeDiff());	670	result.add(diff.asRelativeDiff());
671	}	671	}
672	return (FileDiff[]) result.toArray(new FileDiff[result.size()]);	672	return (FilePatch2[]) result.toArray(new FilePatch2[result.size()]);
673	}	673	}
674		674
675	}	675	}

Lines 36-42 Link Here

(-)src/org/eclipse/compare/tests/PatchTest.java (-3 / +3 lines)
36	import junit.framework.AssertionFailedError;	36	import junit.framework.AssertionFailedError;
37	import junit.framework.TestCase;	37	import junit.framework.TestCase;
38		38
39	import org.eclipse.compare.internal.core.patch.FileDiff;	39	import org.eclipse.compare.internal.core.patch.FilePatch2;
40	import org.eclipse.compare.internal.core.patch.FileDiffResult;	40	import org.eclipse.compare.internal.core.patch.FileDiffResult;
41	import org.eclipse.compare.internal.core.patch.LineReader;	41	import org.eclipse.compare.internal.core.patch.LineReader;
42	import org.eclipse.compare.internal.patch.WorkspacePatcher;	42	import org.eclipse.compare.internal.patch.WorkspacePatcher;
Lines 456-462 Link Here
456	e.printStackTrace();	456	e.printStackTrace();
457	}	457	}
458		458
459	FileDiff[] diffs= patcher.getDiffs();	459	FilePatch2[] diffs= patcher.getDiffs();
460	Assert.assertEquals(diffs.length, 1);	460	Assert.assertEquals(diffs.length, 1);
461		461
462	FileDiffResult diffResult = patcher.getDiffResult(diffs[0]);	462	FileDiffResult diffResult = patcher.getDiffResult(diffs[0]);
Lines 513-519 Link Here
513	}	513	}
514		514
515	//Sort the diffs by project	515	//Sort the diffs by project
516	FileDiff[] diffs= patcher.getDiffs();	516	FilePatch2[] diffs= patcher.getDiffs();
517		517
518	//Iterate through all of the original files, apply the diffs that belong to the file and compare	518	//Iterate through all of the original files, apply the diffs that belong to the file and compare
519	//with the corresponding outcome file	519	//with the corresponding outcome file

Removed Link Here

(-)src/org/eclipse/compare/internal/core/patch/FileDiff.java (-266 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.compare.internal.core.patch;
12
13	import java.util.ArrayList;
14	import java.util.Iterator;
15	import java.util.List;
16
17	import org.eclipse.compare.patch.IFilePatch2;
18	import org.eclipse.compare.patch.IFilePatchResult;
19	import org.eclipse.compare.patch.IHunk;
20	import org.eclipse.compare.patch.PatchConfiguration;
21	import org.eclipse.compare.patch.ReaderCreator;
22	import org.eclipse.core.runtime.IPath;
23	import org.eclipse.core.runtime.IProgressMonitor;
24	import org.eclipse.core.runtime.Path;
25
26	/**
27	* A file diff represents a set of hunks that were associated with the
28	* same path in a patch file.
29	*/
30	public class FileDiff implements IFilePatch2 {
31
32	/**
33	* Difference constant (value 1) indicating one side was added.
34	*/
35	public static final int ADDITION= 1;
36	/**
37	* Difference constant (value 2) indicating one side was removed.
38	*/
39	public static final int DELETION= 2;
40	/**
41	* Difference constant (value 3) indicating side changed.
42	*/
43	public static final int CHANGE= 3;
44
45	private IPath fOldPath, fNewPath;
46	private long oldDate, newDate;
47	private List fHunks= new ArrayList();
48	private DiffProject fProject; //the project that contains this diff
49	private String header;
50	private int addedLines, removedLines;
51
52	/**
53	* Create a file diff for the given path and date information.
54	* @param oldPath the path of the before state of the file
55	* @param oldDate the timestamp of the before state
56	* @param newPath the path of the after state
57	* @param newDate the timestamp of the after state
58	*/
59	public FileDiff(IPath oldPath, long oldDate, IPath newPath, long newDate) {
60	fOldPath= oldPath;
61	this.oldDate = oldDate;
62	fNewPath= newPath;
63	this.newDate = newDate;
64	}
65
66	/**
67	* Return the parent project or <code>null</code> if there isn't one.
68	* @return the parent project or <code>null</code>
69	*/
70	public DiffProject getProject() {
71	return fProject;
72	}
73
74	/**
75	* Set the project of this diff to the given project.
76	* This method should only be called from
77	* {@link DiffProject#add(FileDiff)}
78	* @param diffProject the parent project
79	*/
80	void setProject(DiffProject diffProject) {
81	if (fProject == diffProject)
82	return;
83	if (fProject != null)
84	fProject.remove(this);
85	this.fProject= diffProject;
86	}
87
88	/**
89	* Get the path of the file diff.
90	* @param reverse whether the path of the before state or after state
91	* should be used
92	* @return the path of the file diff
93	*/
94	public IPath getPath(boolean reverse) {
95	if (getDiffType(reverse) == ADDITION) {
96	if (reverse)
97	return fOldPath;
98	return fNewPath;
99	}
100	if (reverse && fNewPath != null)
101	return fNewPath;
102	if (fOldPath != null)
103	return fOldPath;
104	return fNewPath;
105	}
106
107	/**
108	* Add the hunk to this file diff.
109	* @param hunk the hunk
110	*/
111	public void add(Hunk hunk) {
112	fHunks.add(hunk);
113	hunk.setParent(this);
114	}
115
116	/**
117	* Remove the hunk from this file diff
118	* @param hunk the hunk
119	*/
120	protected void remove(Hunk hunk) {
121	fHunks.remove(hunk);
122	}
123
124	/**
125	* Return the hunks associated with this file diff.
126	* @return the hunks associated with this file diff
127	*/
128	public IHunk[] getHunks() {
129	return (IHunk[]) fHunks.toArray(new IHunk[fHunks.size()]);
130	}
131
132	/**
133	* Return the number of hunks associated with this file diff.
134	* @return the number of hunks associated with this file diff
135	*/
136	public int getHunkCount() {
137	return fHunks.size();
138	}
139
140	/**
141	* Return the difference type of this file diff.
142	* @param reverse whether the patch is being reversed
143	* @return the type of this file diff
144	*/
145	public int getDiffType(boolean reverse) {
146	if (fHunks.size() == 1) {
147	boolean add = false;
148	boolean delete = false;
149	Iterator iter = fHunks.iterator();
150	while (iter.hasNext()){
151	Hunk hunk = (Hunk) iter.next();
152	int type =hunk.getHunkType(reverse);
153	if (type == ADDITION){
154	add = true;
155	} else if (type == DELETION ){
156	delete = true;
157	}
158	}
159	if (add && !delete){
160	return ADDITION;
161	} else if (!add && delete){
162	return DELETION;
163	}
164	}
165	return CHANGE;
166	}
167
168	/**
169	* Return the path of this file diff with the specified number
170	* of leading segments striped.
171	* @param strip the number of leading segments to strip from the path
172	* @param reverse whether the patch is being reversed
173	* @return the path of this file diff with the specified number
174	* of leading segments striped
175	*/
176	public IPath getStrippedPath(int strip, boolean reverse) {
177	IPath path= getPath(reverse);
178	if (strip > 0 && strip < path.segmentCount())
179	path= path.removeFirstSegments(strip);
180	return path;
181	}
182
183	/**
184	* Return the segment count of the path of this file diff.
185	* @return the segment count of the path of this file diff
186	*/
187	public int segmentCount() {
188	//Update prefix count - go through all of the diffs and find the smallest
189	//path segment contained in all diffs.
190	int length= 99;
191	if (fOldPath != null)
192	length= Math.min(length, fOldPath.segmentCount());
193	if (fNewPath != null)
194	length= Math.min(length, fNewPath.segmentCount());
195	return length;
196	}
197
198	public IFilePatchResult apply(ReaderCreator content,
199	PatchConfiguration configuration, IProgressMonitor monitor) {
200	FileDiffResult result = new FileDiffResult(this, configuration);
201	result.refresh(content, monitor);
202	return result;
203	}
204
205	public IPath getTargetPath(PatchConfiguration configuration) {
206	return getStrippedPath(configuration.getPrefixSegmentStripCount(), configuration.isReversed());
207	}
208
209	public FileDiff asRelativeDiff() {
210	if (fProject == null)
211	return this;
212	IPath adjustedOldPath = null;
213	if (fOldPath != null) {
214	adjustedOldPath = new Path(null, fProject.getName()).append(fOldPath);
215	}
216	IPath adjustedNewPath = null;
217	if (fNewPath != null) {
218	adjustedNewPath = new Path(null, fProject.getName()).append(fNewPath);
219	}
220	FileDiff diff = create(adjustedOldPath, 0, adjustedNewPath, 0);
221	for (Iterator iterator = fHunks.iterator(); iterator.hasNext();) {
222	Hunk hunk = (Hunk) iterator.next();
223	// Creating the hunk adds it to the parent diff
224	new Hunk(diff, hunk);
225	}
226	return diff;
227	}
228
229	protected FileDiff create(IPath oldPath, long oldDate, IPath newPath,
230	long newDate) {
231	return new FileDiff(oldPath, oldDate, newPath, newDate);
232	}
233
234	public void setHeader(String header) {
235	this.header = header;
236	}
237
238	public String getHeader() {
239	return header;
240	}
241
242	public long getBeforeDate() {
243	return oldDate;
244	}
245
246	public long getAfterDate() {
247	return newDate;
248	}
249
250	public void setAddedLines(int addedLines) {
251	this.addedLines = addedLines;
252	}
253
254	public void setRemovedLines(int removedLines) {
255	this.removedLines = removedLines;
256	}
257
258	public int getAddedLines() {
259	return addedLines;
260	}
261
262	public int getRemovedLines() {
263	return removedLines;
264	}
265
266	}

Lines 13-19 Link Here

(-)src/org/eclipse/compare/patch/PatchBuilder.java (-5 / +5 lines)
13	import java.util.Arrays;	13	import java.util.Arrays;
14	import java.util.Comparator;	14	import java.util.Comparator;
15		15
16	import org.eclipse.compare.internal.core.patch.FileDiff;	16	import org.eclipse.compare.internal.core.patch.FilePatch2;
17	import org.eclipse.compare.internal.core.patch.Hunk;	17	import org.eclipse.compare.internal.core.patch.Hunk;
18	import org.eclipse.core.runtime.IPath;	18	import org.eclipse.core.runtime.IPath;
19		19
Lines 90-96 Link Here
90	public static IFilePatch2 createFilePatch(IPath oldPath, long oldDate,	90	public static IFilePatch2 createFilePatch(IPath oldPath, long oldDate,
91	IPath newPath, long newDate, IHunk[] hunks) {	91	IPath newPath, long newDate, IHunk[] hunks) {
92	reorder(hunks);	92	reorder(hunks);
93	FileDiff fileDiff = new FileDiff(oldPath, oldDate, newPath, newDate);	93	FilePatch2 fileDiff = new FilePatch2(oldPath, oldDate, newPath, newDate);
94	for (int i = 0; i < hunks.length; i++) {	94	for (int i = 0; i < hunks.length; i++) {
95	fileDiff.add((Hunk) hunks[i]);	95	fileDiff.add((Hunk) hunks[i]);
96	}	96	}
Lines 152-163 Link Here
152	boolean hasLineAdditions = checkForPrefix(ADDITION_PREFIX, lines);	152	boolean hasLineAdditions = checkForPrefix(ADDITION_PREFIX, lines);
153	boolean hasLineDeletions = checkForPrefix(REMOVAL_PREFIX, lines);	153	boolean hasLineDeletions = checkForPrefix(REMOVAL_PREFIX, lines);
154	if (hasLineAdditions && !hasLineDeletions) {	154	if (hasLineAdditions && !hasLineDeletions) {
155	return FileDiff.ADDITION;	155	return FilePatch2.ADDITION;
156	} else if (!hasLineAdditions && hasLineDeletions) {	156	} else if (!hasLineAdditions && hasLineDeletions) {
157	return FileDiff.DELETION;	157	return FilePatch2.DELETION;
158	}	158	}
159	}	159	}
160	return FileDiff.CHANGE;	160	return FilePatch2.CHANGE;
161	}	161	}
162		162
163	private static int getHunkLength(String[] lines, boolean old) {	163	private static int getHunkLength(String[] lines, boolean old) {

Lines 16-24 Link Here

(-)compare/org/eclipse/compare/patch/ApplyPatchOperation.java (-6 / +6 lines)
16	import org.eclipse.compare.CompareConfiguration;	16	import org.eclipse.compare.CompareConfiguration;
17	import org.eclipse.compare.internal.ComparePreferencePage;	17	import org.eclipse.compare.internal.ComparePreferencePage;
18	import org.eclipse.compare.internal.CompareUIPlugin;	18	import org.eclipse.compare.internal.CompareUIPlugin;
19	import org.eclipse.compare.internal.core.patch.FileDiff;	19	import org.eclipse.compare.internal.core.patch.FilePatch2;
20	import org.eclipse.compare.internal.core.patch.PatchReader;	20	import org.eclipse.compare.internal.core.patch.PatchReader;
21	import org.eclipse.compare.internal.patch.FileDiffWrapper;	21	import org.eclipse.compare.internal.patch.FilePatch;
22	import org.eclipse.compare.internal.patch.PatchWizard;	22	import org.eclipse.compare.internal.patch.PatchWizard;
23	import org.eclipse.compare.internal.patch.PatchWizardDialog;	23	import org.eclipse.compare.internal.patch.PatchWizardDialog;
24	import org.eclipse.compare.internal.patch.Utilities;	24	import org.eclipse.compare.internal.patch.Utilities;
Lines 206-223 Link Here
206	BufferedReader reader = Utilities.createReader(storage);	206	BufferedReader reader = Utilities.createReader(storage);
207	try {	207	try {
208	PatchReader patchReader = new PatchReader() {	208	PatchReader patchReader = new PatchReader() {
209	protected FileDiff createFileDiff(IPath oldPath, long oldDate,	209	protected FilePatch2 createFileDiff(IPath oldPath, long oldDate,
210	IPath newPath, long newDate) {	210	IPath newPath, long newDate) {
211	return new FileDiffWrapper(oldPath, oldDate, newPath,	211	return new FilePatch(oldPath, oldDate, newPath,
212	newDate);	212	newDate);
213	}	213	}
214	};	214	};
215	patchReader.parse(reader);	215	patchReader.parse(reader);
216	FileDiff[] fileDiffs = patchReader.getAdjustedDiffs();	216	FilePatch2[] fileDiffs = patchReader.getAdjustedDiffs();
217		217
218	IFilePatch[] filePatch = new IFilePatch[fileDiffs.length];	218	IFilePatch[] filePatch = new IFilePatch[fileDiffs.length];
219	for (int i = 0; i < fileDiffs.length; i++) {	219	for (int i = 0; i < fileDiffs.length; i++) {
220	filePatch[i] = (FileDiffWrapper) fileDiffs[i];	220	filePatch[i] = (FilePatch) fileDiffs[i];
221	}	221	}
222		222
223	return filePatch;	223	return filePatch;

Lines 15-21 Link Here

(-)compare/org/eclipse/compare/internal/patch/PatchCompareEditorInput.java (-5 / +5 lines)
15	import org.eclipse.compare.*;	15	import org.eclipse.compare.*;
16	import org.eclipse.compare.internal.*;	16	import org.eclipse.compare.internal.*;
17	import org.eclipse.compare.internal.core.patch.DiffProject;	17	import org.eclipse.compare.internal.core.patch.DiffProject;
18	import org.eclipse.compare.internal.core.patch.FileDiff;	18	import org.eclipse.compare.internal.core.patch.FilePatch2;
19	import org.eclipse.compare.internal.core.patch.FileDiffResult;	19	import org.eclipse.compare.internal.core.patch.FileDiffResult;
20	import org.eclipse.compare.internal.core.patch.HunkResult;	20	import org.eclipse.compare.internal.core.patch.HunkResult;
21	import org.eclipse.compare.patch.PatchConfiguration;	21	import org.eclipse.compare.patch.PatchConfiguration;
Lines 206-212 Link Here
206	getViewer().refresh();	206	getViewer().refresh();
207	}	207	}
208		208
209	private void processDiffs(FileDiff[] diffs) {	209	private void processDiffs(FilePatch2[] diffs) {
210	for (int i = 0; i < diffs.length; i++) {	210	for (int i = 0; i < diffs.length; i++) {
211	processDiff(diffs[i], getRoot());	211	processDiff(diffs[i], getRoot());
212	}	212	}
Lines 216-230 Link Here
216	//create diffProject nodes	216	//create diffProject nodes
217	for (int i = 0; i < diffProjects.length; i++) {	217	for (int i = 0; i < diffProjects.length; i++) {
218	PatchProjectDiffNode projectNode = new PatchProjectDiffNode(getRoot(), diffProjects[i], getPatcher().getConfiguration());	218	PatchProjectDiffNode projectNode = new PatchProjectDiffNode(getRoot(), diffProjects[i], getPatcher().getConfiguration());
219	FileDiff[] diffs = diffProjects[i].getFileDiffs();	219	FilePatch2[] diffs = diffProjects[i].getFileDiffs();
220	for (int j = 0; j < diffs.length; j++) {	220	for (int j = 0; j < diffs.length; j++) {
221	FileDiff fileDiff = diffs[j];	221	FilePatch2 fileDiff = diffs[j];
222	processDiff(fileDiff, projectNode);	222	processDiff(fileDiff, projectNode);
223	}	223	}
224	}	224	}
225	}	225	}
226		226
227	private void processDiff(FileDiff diff, DiffNode parent) {	227	private void processDiff(FilePatch2 diff, DiffNode parent) {
228	FileDiffResult diffResult = getPatcher().getDiffResult(diff);	228	FileDiffResult diffResult = getPatcher().getDiffResult(diff);
229	PatchFileDiffNode node = PatchFileDiffNode.createDiffNode(parent, diffResult);	229	PatchFileDiffNode node = PatchFileDiffNode.createDiffNode(parent, diffResult);
230	HunkResult[] hunkResults = diffResult.getHunkResults();	230	HunkResult[] hunkResults = diffResult.getHunkResults();

Removed Link Here

(-)compare/org/eclipse/compare/internal/patch/FileDiffWrapper.java (-47 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.compare.internal.patch;
12
13	import org.eclipse.compare.internal.core.patch.FileDiff;
14	import org.eclipse.compare.patch.IFilePatch;
15	import org.eclipse.compare.patch.IFilePatchResult;
16	import org.eclipse.compare.patch.PatchConfiguration;
17	import org.eclipse.core.resources.IStorage;
18	import org.eclipse.core.runtime.IPath;
19	import org.eclipse.core.runtime.IProgressMonitor;
20
21	public class FileDiffWrapper extends FileDiff implements IFilePatch {
22
23	public FileDiffWrapper(IPath oldPath, long oldDate, IPath newPath,
24	long newDate) {
25	super(oldPath, oldDate, newPath, newDate);
26	}
27
28	/*
29	* (non-Javadoc)
30	*
31	* @see
32	* org.eclipse.compare.patch.IFilePatch#apply(org.eclipse.core.resources
33	* .IStorage, org.eclipse.compare.patch.PatchConfiguration,
34	* org.eclipse.core.runtime.IProgressMonitor)
35	*/
36	public IFilePatchResult apply(IStorage content,
37	PatchConfiguration configuration, IProgressMonitor monitor) {
38	return apply(content != null ? Utilities.getReaderCreator(content)
39	: null, configuration, monitor);
40	}
41
42	protected FileDiff create(IPath oldPath, long oldDate, IPath newPath,
43	long newDate) {
44	return new FileDiffWrapper(oldPath, oldDate, newPath, newDate);
45	}
46
47	}