From c0ef65b43688b1a4615a1e7332f6215f9a8abb19 Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Wed, 23 Jun 2010 00:28:36 +0200
Subject: Implemented simple tree merging and a simple test, more elaborate
 testing is in progress

---
 lib/git/index/fun.py | 86 +++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 78 insertions(+), 8 deletions(-)

(limited to 'lib/git/index')

diff --git a/lib/git/index/fun.py b/lib/git/index/fun.py
index 962e139a..79fcfddb 100644
--- a/lib/git/index/fun.py
+++ b/lib/git/index/fun.py
@@ -5,11 +5,13 @@ more versatile
 from stat import S_IFDIR
 from cStringIO import StringIO
 
+from git.utils import IndexFileSHA1Writer
 from git.errors import UnmergedEntriesError
-from git.objects.fun import tree_to_stream
-from git.utils import (
-							IndexFileSHA1Writer, 
-						)
+from git.objects.fun import (
+								tree_to_stream,
+								traverse_tree_recursive,
+								traverse_trees_recursive
+							)
 
 from typ import (
 					BaseIndexEntry,
@@ -196,7 +198,7 @@ def write_tree_from_cache(entries, odb, sl, si=0):
 	return (istream.binsha, tree_items)
 	
 def _tree_entry_to_baseindexentry(tree_entry, stage):
-	return BaseIndexEntry(tree_entry[1], tree_entry[0], stage <<CE_STAGESHIFT, tree_entry[2])
+	return BaseIndexEntry((tree_entry[1], tree_entry[0], stage <<CE_STAGESHIFT, tree_entry[2]))
 	
 def aggressive_tree_merge(odb, tree_shas):
 	"""
@@ -204,13 +206,81 @@ def aggressive_tree_merge(odb, tree_shas):
 		trees. All valid entries are on stage 0, whereas the conflicting ones are left 
 		on stage 1, 2 or 3, whereas stage 1 corresponds to the common ancestor tree, 
 		2 to our tree and 3 to 'their' tree.
-	:param tree_shas: 1, 2 or 3 trees as identified by their shas"""
+	:param tree_shas: 1, 2 or 3 trees as identified by their shas
+		If 1 or two, the entries will effectively correspond to the last given tree
+		If 3 are given, a 3 way merge is performed"""
 	out = list()
 	out_append = out.append
-	if len(tree_shas) == 1:
-		for entry in traverse_tree_recursive(odb, tree_shas[0]):
+	
+	# one and two way is the same for us, as we don't have to handle an existing
+	# index, instrea
+	if len(tree_shas) in (1,2):
+		for entry in traverse_tree_recursive(odb, tree_shas[-1], ''):
 			out_append(_tree_entry_to_baseindexentry(entry, 0))
 		# END for each entry
+	elif len(tree_shas) == 3:
+		for base, ours, theirs in traverse_trees_recursive(odb, tree_shas, ''):
+			if base is not None:
+				# base version exists
+				if ours is not None:
+					# ours exists
+					if theirs is not None:
+						# it exists in all branches, if it was changed in both
+						# its a conflict, otherwise we take the changed version
+						# This should be the most common branch, so it comes first
+						if( base[0] != ours[0] and base[0] != theirs[0] and ours[0] != theirs[0] ) or \
+							( base[1] != ours[1] and base[1] != theirs[1] and ourse[1] != theirs[1] ):
+							# changed by both
+							out_append(_tree_entry_to_baseindexentry(base, 1))
+							out_append(_tree_entry_to_baseindexentry(ours, 2))
+							out_append(_tree_entry_to_baseindexentry(theirs, 3))
+						elif base[0] != ours[0] or base[1] != ours[1]:
+							# only we changed it
+							out_append(_tree_entry_to_baseindexentry(ours, 0))
+						else:
+							# either nobody changed it, or they did. In either
+							# case, use theirs
+							out_append(_tree_entry_to_baseindexentry(theirs, 0))
+						# END handle modification 
+					else:
+						
+						if ours[0] != base[0] or ours[1] != base[1]:
+							# they deleted it, we changed it, conflict 
+							out_append(_tree_entry_to_baseindexentry(base, 1))
+							out_append(_tree_entry_to_baseindexentry(ours, 2))
+							out_append(_tree_entry_to_baseindexentry(theirs, 3))
+						# else:
+						#	we didn't change it, ignore
+						#	pass
+						# END handle our change
+					# END handle theirs
+				else:
+					if theirs is None:
+						# deleted in both, its fine - its out
+						pass
+					else:
+						if theirs[0] != base[0] or theirs[1] != base[1]:
+							# deleted in ours, changed theirs, conflict
+							out_append(_tree_entry_to_baseindexentry(base, 1))
+							out_append(_tree_entry_to_baseindexentry(ours, 2))
+							out_append(_tree_entry_to_baseindexentry(theirs, 3))
+						# END theirs changed
+						#else:
+						# 	theirs didnt change
+						#	pass
+					# END handle theirs
+				# END handle ours
+			else:
+				# all three can't be None
+				if ours is None:
+					# added in their branch
+					out_append(_tree_entry_to_baseindexentry(theirs, 0))
+				elif theirs is None:
+					# added in our branch
+					out_append(_tree_entry_to_baseindexentry(ours, 0))
+				# END hanle heads
+			# END handle base exists
+		# END for each entries tuple
 	else:
 		raise ValueError("Cannot handle %i trees at once" % len(tree_shas))
 	# END handle tree shas
-- 
cgit v1.2.3