Attachment 79484 Details for Bug 199846 – Patch #1

[patch] Patch #1

patch_199846_20071001_3.txt (text/plain), 16.37 KB, created by Tomasz Zarna

on 2007-10-01 10:47:26 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Tomasz Zarna

Created: 2007-10-01 10:47:26 EDT

Size: 16.37 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.compare
>Index: compare/org/eclipse/compare/internal/patch/FileDiffResult.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.compare/compare/org/eclipse/compare/internal/patch/FileDiffResult.java,v
>retrieving revision 1.11
>diff -u -r1.11 FileDiffResult.java
>--- compare/org/eclipse/compare/internal/patch/FileDiffResult.java	16 May 2007 18:17:07 -0000	1.11
>+++ compare/org/eclipse/compare/internal/patch/FileDiffResult.java	1 Oct 2007 13:55:24 -0000
>@@ -31,7 +31,7 @@
> 	private List fBeforeLines, fAfterLines;
> 	private final PatchConfiguration configuration;
> 	private String charset;
>-	private int fuzz;
>+	private int fFuzz;
> 	
> 	public FileDiffResult(FileDiff diff, PatchConfiguration configuration) {
> 		super();
>@@ -146,7 +146,7 @@
> 		fBeforeLines = new ArrayList();
> 		fBeforeLines.addAll(lines);
> 		if (getConfiguration().getFuzz() == -1) {
>-			fuzz = calculateFuzz(fBeforeLines, monitor);
>+			fFuzz = calculateFuzz(fBeforeLines, monitor);
> 		}
> 		int shift= 0;
> 		Hunk[] hunks = fDiff.getHunks();
>@@ -208,8 +208,7 @@
> 	public int calculateFuzz(List lines, IProgressMonitor monitor) {
> 		if (monitor == null)
> 			monitor = new NullProgressMonitor();
>-		fBeforeLines = new ArrayList();
>-		fBeforeLines.addAll(lines);
>+		fBeforeLines = new ArrayList(lines);
> 		// TODO: What about deletions?
> 		if (fDiff.getDiffType(getConfiguration().isReversed()) == Differencer.ADDITION) {
> 			// Additions don't need to adjust the fuzz factor
>@@ -217,7 +216,7 @@
> 			return -1;
> 		}
> 		int shift= 0;
>-		int fuzz1 = 0;
>+		int highestFuzz = 0; // the maximum fuzz factor for all hunks
> 		String name = getTargetPath() != null ? getTargetPath().lastSegment() : ""; //$NON-NLS-1$
> 		Hunk[] hunks = fDiff.getHunks();
> 		for (int j = 0; j < hunks.length; j++) {
>@@ -225,16 +224,21 @@
> 			monitor.subTask(NLS.bind(PatchMessages.PreviewPatchPage_GuessFuzzProgress_format, new String[] {name, Integer.toString(j + 1)}));
> 			HunkResult result = getHunkResult(h);
> 			result.setShift(shift);
>-			int f= result.calculateFuzz(lines, monitor);
>-			if (f >= 0) {
>-				shift = result.getShift();
>-			}
>-			if (f>fuzz1)
>-				fuzz1= f;
>+			int fuzz = result.calculateFuzz(lines, monitor);
>+			/*
>+			 * TODO (tzarna): I believe this is not needed anymore as the
>+			 * calculateFuzz does what it's supposed to, instead of calculate
>+			 * shifting
>+			 */
>+			// if (fuzz >= 0) {
>+			// shift = result.getShift();
>+			// }
>+			if (fuzz > highestFuzz)
>+				highestFuzz = fuzz;
> 			monitor.worked(1);
> 		}
> 		fAfterLines = lines;
>-		return fuzz1;
>+		return highestFuzz;
> 	}
> 	
> 	public IPath getTargetPath() {
>@@ -330,7 +334,7 @@
> 	public int getFuzz() {
> 		int cf = configuration.getFuzz();
> 		if (cf == -1) {
>-			return fuzz;
>+			return fFuzz;
> 		}
> 		return cf;
> 	}
>Index: compare/org/eclipse/compare/internal/patch/HunkResult.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.compare/compare/org/eclipse/compare/internal/patch/HunkResult.java,v
>retrieving revision 1.7
>diff -u -r1.7 HunkResult.java
>--- compare/org/eclipse/compare/internal/patch/HunkResult.java	16 Mar 2007 19:53:10 -0000	1.7
>+++ compare/org/eclipse/compare/internal/patch/HunkResult.java	1 Oct 2007 13:55:24 -0000
>@@ -41,36 +41,39 @@
> 	/**
> 	 * Try to apply the specified hunk to the given lines.
> 	 * If the hunk cannot be applied at the original position
>-	 * the methods tries fuzz lines before and after.
>+	 * the method tries shift lines up and down.
> 	 * @param lines the lines to be patched
> 	 * @return whether the hunk could be applied
> 	 */
> 	public boolean patch(List lines) {
> 		fMatches = false;
> 		PatchConfiguration configuration = getConfiguration();
>+		int fuzz = fDiffResult.getFuzz();// configuration.getFuzz();
> 		if (isEnabled(configuration)) {
>-			if (fHunk.tryPatch(configuration, lines, fShift)) {
>-				fShift+= fHunk.doPatch(configuration, lines, fShift);
>+			if (fHunk.tryPatch(configuration, lines, fShift, fuzz)) {
>+				// it's a perfect match, no adjustment is needed
>+				fShift += fHunk.doPatch(configuration, lines, fShift);
> 				fMatches = true;
> 			} else {
> 				boolean found= false;
> 				int oldShift= fShift;
> 				
>-				for (int i= 1; i <= fDiffResult.getFuzz(); i++) {
>-					if (fHunk.tryPatch(configuration, lines, fShift-i)) {
>+				int start = fHunk.getStart(configuration.isReversed());
>+				for (int i = 1; i <= start; i++) {
>+					if (fHunk.tryPatch(configuration, lines, fShift - i, fuzz)) {
> 						if (isAdjustShift())
>-							fShift-= i;
>-						found= true;
>+							fShift -= i;
>+						found = true;
> 						break;
> 					}
> 				}
> 				
>-				if (! found) {
>-					for (int i= 1; i <= fDiffResult.getFuzz(); i++) {
>-						if (fHunk.tryPatch(configuration, lines, fShift+i)) {
>+				if (!found) {
>+					for (int i = 1; i <= lines.size()-start/* fDiffResult.getFuzz()*/; i++) {
>+						if (fHunk.tryPatch(configuration, lines, fShift + i, fuzz)) {
> 							if (isAdjustShift())
>-								fShift+= i;
>-							found= true;
>+								fShift += i;
>+							found = true;
> 							break;
> 						}
> 					}
>@@ -95,54 +98,71 @@
> 	}
> 
> 	/**
>-	 * Calculate the fuzz factor that will allow the most hunks to be matched.
>-	 * @param lines the lines of the target file
>-	 * @param monitor a progress monitor
>+	 * Calculate the fuzz that will allow the most hunks to be matched. Even
>+	 * though we're interested only in the value of the fuzz, the shifting is
>+	 * done anyway.
>+	 * 
>+	 * @param lines
>+	 *            the lines of the target file
>+	 * @param monitor
>+	 *            a progress monitor
> 	 * @return the fuzz factor or -1 if the hunk could not be matched
> 	 */
> 	public int calculateFuzz(List lines, IProgressMonitor monitor) {
>-		
>-		fMatches= false;
>-		int fuzz = 0;
>+		fMatches = false;
>+		// int shift = 0; // we're not interested in the shift value right now
> 		PatchConfiguration configuration = getConfiguration();
>-		if (fHunk.tryPatch(configuration, lines, fShift)) {
>-			fShift+= fHunk.doPatch(configuration, lines, fShift);
>-			fMatches = true;
>-		} else {
>-			int hugeFuzz= lines.size();	// the maximum we need for this file
>-			fuzz= -1;	// not found
>+		int fuzz = 0;
>+		// TODO (tzarna): the default maximum fuzz factor is 2
>+		for (; fuzz <= 2; fuzz++) {
>+			// try to apply using lines coordinates from the patch
>+			if (fHunk.tryPatch(configuration, lines, fShift, fuzz)) {
>+				// it's a perfect match, no adjustment is needed
>+				fShift += fHunk.doPatch(configuration, lines, fShift);
>+				fMatches = true;
>+				break;
>+			}
>+			//TODO (tzarna): hugeShift it to much, lines to the beg/end of a 
>+			// file would be enough the maximum shift we can use for this file
>+			int hugeShift = lines.size(); 
>+			// shift = -1; // not found
> 			
>-			for (int i= 1; i <= hugeFuzz; i++) {
>+			// shift up 
>+			for (int i = 1; i <= hugeShift; i++) {
> 				if (monitor.isCanceled()) {
> 					throw new OperationCanceledException();
> 				}
>-				if (fHunk.tryPatch(configuration, lines, fShift-i)) {
>-					fuzz= i;
>+				if (fHunk.tryPatch(configuration, lines, fShift - i, fuzz)) {
>+					// shift = i;
> 					if (isAdjustShift())
>-						fShift-= i;
>-					fMatches= true;
>+						fShift -= i;
>+					fMatches = true;
> 					break;
> 				}
> 			}
>-			
>-			if (! fMatches) {
>-				for (int i= 1; i <= hugeFuzz; i++) {
>+
>+			// shift down
>+			if (!fMatches) {
>+				for (int i = 1; i <= hugeShift; i++) {
> 					if (monitor.isCanceled()) {
> 						throw new OperationCanceledException();
> 					}
>-					if (fHunk.tryPatch(configuration, lines, fShift+i)) {
>-						fuzz= i;
>+					if (fHunk.tryPatch(configuration, lines, fShift + i, fuzz)) {
>+						// shift = i;
> 						if (isAdjustShift())
>-							fShift+= i;
>-						fMatches= true;
>+							fShift += i;
>+						fMatches = true;
> 						break;
> 					}
> 				}
> 			}
>-			
>-			if (fMatches)
>-				fShift+= fHunk.doPatch(configuration, lines, fShift);
>+
>+			if (fMatches) {
>+				fShift += fHunk.doPatch(configuration, lines, fShift);
>+				break;
>+			}
> 		}
>+		// TODO (tzarna): return -1 if the hunk could not be matched?
> 		return fuzz;
> 	}
> 
>Index: compare/org/eclipse/compare/internal/patch/Hunk.java
>===================================================================
>RCS file: /cvsroot/eclipse/org.eclipse.compare/compare/org/eclipse/compare/internal/patch/Hunk.java,v
>retrieving revision 1.22
>diff -u -r1.22 Hunk.java
>--- compare/org/eclipse/compare/internal/patch/Hunk.java	5 Sep 2007 15:26:47 -0000	1.22
>+++ compare/org/eclipse/compare/internal/patch/Hunk.java	1 Oct 2007 13:55:24 -0000
>@@ -10,6 +10,7 @@
>  *******************************************************************************/
> package org.eclipse.compare.internal.patch;
> 
>+import java.util.ArrayList;
> import java.util.List;
> 
> import org.eclipse.compare.patch.PatchConfiguration;
>@@ -167,50 +168,135 @@
> 	 * The parameter shift is added to the line numbers given
> 	 * in the hunk.
> 	 */
>-	public boolean tryPatch(PatchConfiguration configuration, List lines, int shift) {
>+	public boolean tryPatch(PatchConfiguration configuration, List lines, int shift, int fuzz) {
> 		boolean reverse = configuration.isReversed();
>-		int pos= getStart(reverse) + shift;
>-		int deleteMatches= 0;
>+		int pos = getStart(reverse) + shift;
>+		int deleteMatches = 0;
>+		List contextLines = new ArrayList();
>+		boolean contextLinesMatched = true;
> 		for (int i= 0; i < fLines.length; i++) {
>-			String s= fLines[i];
>+			String s = fLines[i];
> 			Assert.isTrue(s.length() > 0);
>-			String line= s.substring(1);
>-			char controlChar= s.charAt(0);
>+			String line = s.substring(1);
>+			char controlChar = s.charAt(0);
>+			
> 			if (controlChar == ' ') {	// context lines
>-				while (true) {
>-					if (pos < 0 || pos >= lines.size())
>-						return false;
>-					if (linesMatch(configuration, line, (String) lines.get(pos))) {
>-						pos++;
>-						break;
>-					}
>+				
>+				if (pos < 0 || pos >= lines.size()) // out of the file
> 					return false;
>-				}
>+				contextLines.add(line);
>+				if (linesMatch(configuration, line, (String) lines.get(pos))) {
>+					pos++;
>+					continue;
>+				} else if (fuzz > 0) {
>+					// doesn't match, use the fuzz factor
>+					contextLinesMatched = false;
>+					pos++;
>+					continue;
>+				} 
>+				return false;
> 			} else if (isDeletedDelimeter(controlChar, reverse)) {
> 				// deleted lines
>-				while (true) {
>-					if (pos < 0 || pos >= lines.size())
>-						return false;
>-					if (linesMatch(configuration, line, (String) lines.get(pos))) {
>-						deleteMatches++;
>-						pos++;
>-						break;
>+				
>+				// use the fuzz factor if needed
>+				// TODO (tzarna): extract method
>+				if (!contextLinesMatched && fuzz > 0 && contextLines.size() > fuzz) {
>+					// three lines of context is typically the default
>+					if (contextLines.size() > 3) {
>+						// two "groups" of context lines -- both preceding and following
>+						if (contextLines.size() % 2 == 0) {
>+							// if the number of context lines is even treat the
>+							// first half part as following and the second one
>+							// as preceding...
>+							List followingContextLines = new ArrayList(contextLines.subList(0, contextLines.size() / 2 - 1));
>+							if (!checkFollowingContextLines(configuration, lines, fuzz, pos, followingContextLines))
>+								return false;
>+							List precedingContextLines = new ArrayList(contextLines.subList(contextLines.size() / 2 - 1, contextLines.size()));
>+							if (!checkPrecedingContextLines(configuration, lines, fuzz, pos, precedingContextLines))
>+								return false;
>+						} else {
>+							// ... otherwise, if the number is odd give them two
>+							// tries (e.g. for 5 context lines try both 2+3 and
>+							// 3+2)
>+							List followingContextLines = new ArrayList(contextLines.subList(0, contextLines.size() / 2));
>+							List precedingContextLines = new ArrayList(contextLines.subList(contextLines.size() / 2, contextLines.size()));
>+							if (checkPrecedingContextLines(configuration, lines, fuzz, pos, precedingContextLines) 
>+									&& checkFollowingContextLines(configuration, lines, fuzz, pos - contextLines.size() / 2 - 1, followingContextLines)) {
>+								// to omit the check of following of the context lines at the end of this method
>+								contextLinesMatched = true; 
>+								break;
>+							}
>+							// else give it another try
>+							precedingContextLines = new ArrayList(contextLines.subList(0, contextLines.size() / 2 + 1));
>+							if (!checkPrecedingContextLines(configuration, lines, fuzz, pos, precedingContextLines))
>+								return false;
>+							followingContextLines = new ArrayList(contextLines.subList(contextLines.size() / 2 + 1, contextLines.size()));
>+							if (!checkFollowingContextLines(configuration, lines, fuzz, pos, followingContextLines))
>+								return false;
>+						}
>+					} else {
>+							//ignore from the beginning
>+							if (!checkPrecedingContextLines(configuration, lines,
>+									fuzz, pos, contextLines)) return false;
> 					}
>-					
>-					// We must remove all lines at once, return false if this
>-					// fails. In other words, all lines considered for deletion
>-					// must be found one by one.
>-
>-					// if (deleteMatches <= 0)
>-						return false;
>-					// pos++;
>+				} 
>+				// else if there is less or equal context line to the fuzz
>+				// factor we ignore them all and treat as matching
>+				
>+				contextLines.clear();
>+				
>+				if (pos < 0 || pos >= lines.size()) // out of the file
>+					return false;
>+				if (linesMatch(configuration, line, (String) lines.get(pos))) {
>+					deleteMatches++;
>+					pos++;
>+					continue; // line matched, continue with the next one
> 				}
>+
>+				// We must remove all lines at once, return false if this
>+				// fails. In other words, all lines considered for deletion
>+				// must be found one by one.
>+
>+				// if (deleteMatches <= 0)
>+				return false;
>+				// pos++;
> 			} else if (isAddedDelimeter(controlChar, reverse)) {
> 				// added lines
> 				// we don't have to do anything for a 'try'
>+				contextLines.clear();
> 			} else
> 				Assert.isTrue(false, "tryPatch: unknown control character: " + controlChar); //$NON-NLS-1$
> 		}
>+		if (!contextLinesMatched && fuzz > 0 && contextLines.size() > fuzz)
>+			if (!checkFollowingContextLines(configuration, lines, fuzz, pos,
>+					contextLines))
>+				return false;
>+		return true;
>+	}
>+
>+	private boolean checkPrecedingContextLines(
>+			PatchConfiguration configuration, List lines, int fuzz, int pos,
>+			List contextLines) {
>+		// ignore from the beginning
>+		for (int j = fuzz; j < contextLines.size(); j++) {
>+			if (!linesMatch(configuration, (String) contextLines.get(j),
>+					(String) lines.get(pos - contextLines.size() + j)))
>+				return false;
>+		}
>+		return true;
>+	}
>+	
>+	private boolean checkFollowingContextLines(
>+			PatchConfiguration configuration, List lines, int fuzz, int pos,
>+			List contextLines) {
>+		if (!contextLines.isEmpty()) {
>+			// ignore from the end
>+			for (int j = 0; j < contextLines.size() - fuzz; j++) {
>+				if (!linesMatch(configuration, (String) contextLines.get(j),
>+						(String) lines.get(pos - contextLines.size() + j)))
>+					return false;
>+			}
>+		}
> 		return true;
> 	}
> 	
>@@ -243,15 +329,22 @@
> 			Assert.isTrue(s.length() > 0);
> 			String line= s.substring(1);
> 			char controlChar= s.charAt(0);
>+			// TODO (tzarna): don't process context lines as they are already
>+			// checked by the tryPatch method (with fuzz factor) or add the fuzz
>+			// factor processing here too
> 			if (controlChar == ' ') {	// context lines
>-				while (true) {
> 					Assert.isTrue(pos < lines.size(), "doPatch: inconsistency in context"); //$NON-NLS-1$
>-					if (linesMatch(configuration, line, (String) lines.get(pos))) {
>-						pos++;
>-						break;
>-					}
>+//					if (linesMatch(configuration, line, (String) lines.get(pos))) {
>+//						pos++;
>+//						break;
>+//					}else if (fuzz > 0) {
>+//						// doesn't match, use the fuzz factor
>+//						fuzz--;
>+//						pos++;
>+//						break;
>+//					}
> 					pos++;
>-				}
>+//				}
> 			} else if (isDeletedDelimeter(controlChar, reverse)) {
> 				// deleted lines				
> 				while (true) {
>@@ -259,6 +352,7 @@
> 					if (linesMatch(configuration, line, (String) lines.get(pos))) {
> 						break;
> 					}
>+					// TODO (tzarna): does it ever happen?
> 					pos++;
> 				}
> 				lines.remove(pos);

Actions: View | Diff

Attachments on bug 199846: 79481 | 79484 | 80217 | 80218