jhg: src/org/tmatesoft/hg/internal/BlameHelper.java comparison

comparison src/org/tmatesoft/hg/internal/BlameHelper.java @ 678:8625cba0a5a8

Towards better blame of merge revisions: refactor merge handling strategy

author	Artem Tikhomirov <tikhomirov.artem@gmail.com>
date	Fri, 19 Jul 2013 15:36:29 +0200
parents	cce0387c6041
children	58a6900f845d

comparison

equal deleted inserted replaced

-:1c49c0cee540
+:8625cba0a5a8
 			EqualBlocksCollector p2MergeCommon = new EqualBlocksCollector();
 			pg.findMatchingBlocks(p2MergeCommon);
 			//
 			pg.init(p1Lines);
 			BlameBlockInspector bbi = new BlameBlockInspector(targetFile, fileRevIndex, insp, p1ClogIndex, csetRevIndex);
-			bbi.setMergeParent2(p2MergeCommon, p2ClogIndex);
+			bbi.setMergeParent2(new MergeStrategy1(p2MergeCommon.matches), p2ClogIndex);
 			pg.findMatchingBlocks(bbi);
 			bbi.checkErrors();
 		} else if (fileParentClogRevs[0] == fileParentClogRevs[1]) {
 			// may be equal iff both are unset
 			assert fileParentClogRevs[0] == NO_REVISION;
 	private static class BlameBlockInspector extends DiffHelper.DeltaInspector<LineSequence> {
 		private final HgBlameInspector insp;
 		private final int csetOrigin;
 		private final int csetTarget;
-		private EqualBlocksCollector p2MergeCommon;
+		private MergeResolutionStrategy p2MergeCommon;
 		private int csetMergeParent;
-		private IntSliceSeq mergeRanges;
 		private final AnnotateRev annotatedRevision;
 		private HgCallbackTargetException error;
 		public BlameBlockInspector(HgDataFile df, int fileRevIndex, HgBlameInspector inspector, int originCset, int targetCset) {
 			assert inspector != null;
 			annotatedRevision.set(df, fileRevIndex);
 			csetOrigin = originCset;
 			csetTarget = targetCset;
 		}
-		public void setMergeParent2(EqualBlocksCollector p2Merge, int parentCset2) {
+		public void setMergeParent2(MergeResolutionStrategy p2MergeStrategy, int parentCset2) {
-			p2MergeCommon = p2Merge;
+			p2MergeCommon = p2MergeStrategy;
 			csetMergeParent = parentCset2;
-			mergeRanges = new IntSliceSeq(3, 10, 10);
 		}
 		@Override
 		public void begin(LineSequence s1, LineSequence s2) {
 			super.begin(s1, s2);
 			if (shallStop()) {
 				return;
 			}
 			try {
 				if (p2MergeCommon != null) {
-					mergeRanges.clear();
+					IntSliceSeq mergeRanges = p2MergeCommon.combineAndMarkRangesWithSource(s2From, s2To - s2From, csetOrigin, csetMergeParent);
-					p2MergeCommon.combineAndMarkRangesWithTarget(s2From, s2To - s2From, csetOrigin, csetMergeParent, mergeRanges);
 					/*
 					 * Usecases, how it USED TO BE initially:
 					 * 3 lines changed to 10 lines. range of 10 lines breaks down to 2 from p2, 3 from p1, and 5 from p2.
 					 * We report: 2 lines changed to 2(p2), then 1 line changed with 3(p1) and 5 lines added from p2.
 							block.setOriginAndTarget(rangeOrigin, csetTarget);
 							insp.changed(block);
 							s1ConsumedLines += s1LinesToBorrow;
 							s1Start += s1LinesToBorrow;
 						} else {
-							int blockInsPoint = rangeOrigin != csetMergeParent ? s1Start : p2MergeCommon.reverseMapLine(rangeStart);
+							int blockInsPoint = rangeOrigin != csetMergeParent ? s1Start : p2MergeCommon.getLineInP2(rangeStart);
 							ChangeBlockImpl block = getAddBlock(rangeStart, rangeLen, blockInsPoint);
 							block.setOriginAndTarget(rangeOrigin, csetTarget);
 							insp.added(block);
 						}
 					}
 			if (shallStop()) {
 				return;
 			}
 			try {
 				if (p2MergeCommon != null) {
-					mergeRanges.clear();
+					IntSliceSeq mergeRanges = p2MergeCommon.combineAndMarkRangesWithSource(s2From, s2To - s2From, csetOrigin, csetMergeParent);
-					p2MergeCommon.combineAndMarkRangesWithTarget(s2From, s2To - s2From, csetOrigin, csetMergeParent, mergeRanges);
 					int insPoint = s1InsertPoint; // track changes to insertion point
 					for (IntTuple mergeRange : mergeRanges) {
 						int rangeOrigin = mergeRange.at(0);
 						int rangeStart = mergeRange.at(1);
 						int rangeLen = mergeRange.at(2);
+						// XXX likely need somewhat similar to the code above:
+						// int blockInsPoint = rangeOrigin != csetMergeParent ? s1Start : p2MergeCommon.reverseMapLine(rangeStart);
+						//
 						ChangeBlockImpl block = getAddBlock(rangeStart, rangeLen, insPoint);
 						block.setOriginAndTarget(rangeOrigin, csetTarget);
 						insp.added(block);
 						// indicate insPoint moved down number of lines we just reported
 						insPoint += rangeLen;
 		public byte[] asArray() {
 			return contentBlock.seq.data(from, from + length);
 		}
 	}
+	interface MergeResolutionStrategy {
+		/**
+		 * breaks region [start..start+length) into ranges according to deduced (or simply guessed)
+		 * matching of these lines to lines in source1 and source2
+		 * @return list of tuples (source, start, length), where source is one of the identifiers supplied
+		 */
+		public IntSliceSeq combineAndMarkRangesWithSource(int start, int length, int source1, int source2);
+		public int getLineInP2(int mergeLine);
+	}
 	private static class EqualBlocksCollector implements DiffHelper.MatchInspector<LineSequence> {
 		private final RangePairSeq matches = new RangePairSeq();
 		public void begin(LineSequence s1, LineSequence s2) {
 		}
 		public void match(int startSeq1, int startSeq2, int matchLength) {
 			matches.add(startSeq1, startSeq2, matchLength);
 		}
 		public void end() {
-		}
-		public int reverseMapLine(int ln) {
-			return matches.reverseMapLine(ln);
 		}
 		public void intersectWithTarget(int start, int length, IntVector result) {
 			int s = start;
 			for (int l = start, x = start + length; l < x; l++) {
 				result.add(s);
 				result.add((start + length) - s);
 			}
 		}
+	}
+	private static class MergeStrategy1 implements MergeResolutionStrategy {
+		// equal ranges in p2 and merged revision
+		private final RangePairSeq matches;
+		private final IntSliceSeq mergeRanges;
+		public MergeStrategy1(RangePairSeq p2EqualToM) {
+			matches = p2EqualToM;
+			mergeRanges = new IntSliceSeq(3, 10, 10);
+		}
 		/*
 		 * intersects [start..start+length) with ranges of target lines, and based on the intersection
 		 * breaks initial range into smaller ranges and records them into result, with marker to indicate
 		 * whether the range is from initial range (markerSource) or is a result of the intersection with target
 		 * (markerTarget)
 		 */
-		public void combineAndMarkRangesWithTarget(int start, int length, int markerSource, int markerTarget, IntSliceSeq result) {
+		public IntSliceSeq combineAndMarkRangesWithSource(int start, int length, int markerSource, int markerTarget) {
-			assert result.sliceSize() == 3;
+			mergeRanges.clear();
+			assert mergeRanges.sliceSize() == 3;
 			int sourceStart = start, targetStart = start, sourceEnd = start + length;
 			for (int l = sourceStart; l < sourceEnd; l++) {
 				if (matches.includesTargetLine(l)) {
 					// l is from target
 					if (sourceStart < l) {
 						// few lines from source range were not in the target, report them
-						result.add(markerSource, sourceStart, l - sourceStart);
+						mergeRanges.add(markerSource, sourceStart, l - sourceStart);
 					}
 					// indicate the earliest line from source range to use
 					sourceStart = l + 1;
 				} else {
 					// l is not in target
 					if (targetStart < l) {
 						// report lines from target range
-						result.add(markerTarget, targetStart, l - targetStart);
+						mergeRanges.add(markerTarget, targetStart, l - targetStart);
 					}
 					// next line *may* be from target
 					targetStart = l + 1;
 				}
 			}
 			// if source range end with line from target, sourceStart would be == sourceEnd, and we need to add range with markerTarget
 			// if source range doesn't end with target line, targetStart == sourceEnd, while sourceStart < sourceEnd
 			if (sourceStart < sourceEnd) {
 				assert targetStart == sourceEnd;
 				// something left from the source range
-				result.add(markerSource, sourceStart, sourceEnd - sourceStart);
+				mergeRanges.add(markerSource, sourceStart, sourceEnd - sourceStart);
 			} else if (targetStart < sourceEnd) {
 				assert sourceStart == sourceEnd;
-				result.add(markerTarget, targetStart, sourceEnd - targetStart);
+				mergeRanges.add(markerTarget, targetStart, sourceEnd - targetStart);
 			}
+			return mergeRanges;
+		}
+		public int getLineInP2(int mergeLine) {
+			return matches.reverseMapLine(mergeLine);
 		}
 	}
 	private static class AnnotateRev implements RevisionDescriptor {
 		public ContentBlock origin, target;
 		bc.intersectWithTarget(7, 10, r);
 		for (int i = 0; i < r.size(); i+=2) {
 			System.out.printf("[%d..%d) ", r.get(i), r.get(i) + r.get(i+1));
 		}
 		System.out.println();
-		IntSliceSeq mr = new IntSliceSeq(3);
+		MergeStrategy1 ms = new MergeStrategy1(bc.matches);
-		bc.combineAndMarkRangesWithTarget(0, 16, 508, 514, mr);
+		IntSliceSeq mr = ms.combineAndMarkRangesWithSource(0, 16, 508, 514);
 		for (IntTuple t : mr) {
 			System.out.printf("%d:[%d..%d)  ", t.at(0), t.at(1), t.at(1) + t.at(2));
 		}
 	}
 }

Mercurial > jhg

comparison src/org/tmatesoft/hg/internal/BlameHelper.java @ 678:8625cba0a5a8