Merge branch 'submodupdate'

1 files changed, 174 insertions, 112 deletions

diff --git a/objects/submodule/root.py b/objects/submodule/root.py
index 753c6df4..36cd7209 100644
--- a/objects/submodule/root.py
+++ b/objects/submodule/root.py
@@ -1,4 +1,4 @@
-from base import Submodule
+from base import Submodule, UpdateProgress
 from util import (
 					find_first_remote_branch
 				)
@@ -7,9 +7,23 @@ import git
 
 import sys
 
-__all__ = ["RootModule"]
+__all__ = ["RootModule", "RootUpdateProgress"]
 
+
+class RootUpdateProgress(UpdateProgress):
+	"""Utility class which adds more opcodes to the UpdateProgress"""
+	REMOVE, PATHCHANGE, BRANCHCHANGE, URLCHANGE = [1 << x for x in range(UpdateProgress._num_op_codes, UpdateProgress._num_op_codes+4)]
+	_num_op_codes = UpdateProgress._num_op_codes+4
 	
+	__slots__ = tuple()
+
+BEGIN = RootUpdateProgress.BEGIN
+END = RootUpdateProgress.END
+REMOVE = RootUpdateProgress.REMOVE
+BRANCHCHANGE = RootUpdateProgress.BRANCHCHANGE
+URLCHANGE = RootUpdateProgress.URLCHANGE
+PATHCHANGE = RootUpdateProgress.PATHCHANGE
+
 class RootModule(Submodule):
 	"""A (virtual) Root of all submodules in the given repository. It can be used
 	to more easily traverse all submodules of the master repository"""
@@ -38,7 +52,8 @@ class RootModule(Submodule):
 	
 	#{ Interface 
 	
-	def update(self, previous_commit=None, recursive=True, force_remove=False, init=True, to_latest_revision=False):
+	def update(self, previous_commit=None, recursive=True, force_remove=False, init=True, 
+					to_latest_revision=False, progress=None, dry_run=False):
 		"""Update the submodules of this repository to the current HEAD commit.
 		This method behaves smartly by determining changes of the path of a submodules
 		repository, next to changes to the to-be-checked-out commit or the branch to be 
@@ -57,15 +72,26 @@ class RootModule(Submodule):
 		:param init: If we encounter a new module which would need to be initialized, then do it.
 		:param to_latest_revision: If True, instead of checking out the revision pointed to 
 			by this submodule's sha, the checked out tracking branch will be merged with the 
-			newest remote branch fetched from the repository's origin"""
+			newest remote branch fetched from the repository's origin
+		:param progress: RootUpdateProgress instance or None if no progress should be sent
+		:param dry_run: if True, operations will not actually be performed. Progress messages
+			will change accordingly to indicate the WOULD DO state of the operation."""
 		if self.repo.bare:
 			raise InvalidGitRepositoryError("Cannot update submodules in bare repositories")
 		# END handle bare
 		
+		if progress is None:
+			progress = RootUpdateProgress()
+		#END assure progress is set
+		
+		prefix = ''
+		if dry_run:
+			prefix = 'DRY-RUN: '
+		
 		repo = self.repo
 		
-		# HANDLE COMMITS
-		##################
+		# SETUP BASE COMMIT
+		###################
 		cur_commit = repo.head.commit
 		if previous_commit is None:
 			try:
@@ -89,28 +115,51 @@ class RootModule(Submodule):
 		
 		# HANDLE REMOVALS
 		###################
-		for rsm in (spsms - ssms):
+		rrsm = (spsms - ssms)
+		len_rrsm = len(rrsm)
+		for i, rsm in enumerate(rrsm):
+			op = REMOVE
+			if i == 0:
+				op |= BEGIN
+			#END handle begin
+			
 			# fake it into thinking its at the current commit to allow deletion
 			# of previous module. Trigger the cache to be updated before that
-			#rsm.url
+			progress.update(op, i, len_rrsm, prefix+"Removing submodule %r at %s" % (rsm.name, rsm.abspath))
 			rsm._parent_commit = repo.head.commit
-			rsm.remove(configuration=False, module=True, force=force_remove)
+			if not dry_run:
+				rsm.remove(configuration=False, module=True, force=force_remove)
+			#END handle dry-run
+			
+			if i == len_rrsm-1:
+				op |= END
+			#END handle end
+			progress.update(op, i, len_rrsm, prefix+"Done removing submodule %r" % rsm.name)
 		# END for each removed submodule
 		
 		# HANDLE PATH RENAMES
 		#####################
 		# url changes + branch changes
-		for csm in (spsms & ssms):
+		csms = (spsms & ssms)
+		len_csms = len(csms)
+		for i, csm in enumerate(csms):
 			psm = psms[csm.name]
 			sm = sms[csm.name]
 			
+			#PATH CHANGES
+			##############
 			if sm.path != psm.path and psm.module_exists():
+				progress.update(BEGIN|PATHCHANGE, i, len_csms, prefix+"Moving repository of submodule %r from %s to %s" % (sm.name, psm.abspath, sm.abspath))  
 				# move the module to the new path
-				psm.move(sm.path, module=True, configuration=False)
+				if not dry_run:
+					psm.move(sm.path, module=True, configuration=False)
+				#END handle dry_run
+				progress.update(END|PATHCHANGE, i, len_csms, prefix+"Done moving repository of submodule %r" % sm.name)
 			# END handle path changes
 			
 			if sm.module_exists():
-				# handle url change
+				# HANDLE URL CHANGE
+				###################
 				if sm.url != psm.url:
 					# Add the new remote, remove the old one
 					# This way, if the url just changes, the commits will not 
@@ -121,111 +170,119 @@ class RootModule(Submodule):
 					
 					# don't do anything if we already have the url we search in place
 					if len([r for r in rmts if r.url == sm.url]) == 0:
+						progress.update(BEGIN|URLCHANGE, i, len_csms, prefix+"Changing url of submodule %r from %s to %s" % (sm.name, psm.url, sm.url))
 						
-						
-						assert nn not in [r.name for r in rmts]
-						smr = smm.create_remote(nn, sm.url)
-						smr.fetch()
-						
-						# If we have a tracking branch, it should be available
-						# in the new remote as well.
-						if len([r for r in smr.refs if r.remote_head == sm.branch_name]) == 0:
-							raise ValueError("Submodule branch named %r was not available in new submodule remote at %r" % (sm.branch_name, sm.url))
-						# END head is not detached
-						
-						# now delete the changed one
-						rmt_for_deletion = None
-						for remote in rmts:
-							if remote.url == psm.url:
-								rmt_for_deletion = remote
-								break
-							# END if urls match
-						# END for each remote
-						
-						# if we didn't find a matching remote, but have exactly one, 
-						# we can safely use this one
-						if rmt_for_deletion is None:
-							if len(rmts) == 1:
-								rmt_for_deletion = rmts[0]
-							else:
-								# if we have not found any remote with the original url
-								# we may not have a name. This is a special case, 
-								# and its okay to fail here
-								# Alternatively we could just generate a unique name and leave all
-								# existing ones in place
-								raise InvalidGitRepositoryError("Couldn't find original remote-repo at url %r" % psm.url)
-							#END handle one single remote
-						# END handle check we found a remote
-						
-						orig_name = rmt_for_deletion.name
-						smm.delete_remote(rmt_for_deletion)
-						# NOTE: Currently we leave tags from the deleted remotes
-						# as well as separate tracking branches in the possibly totally 
-						# changed repository ( someone could have changed the url to 
-						# another project ). At some point, one might want to clean
-						# it up, but the danger is high to remove stuff the user
-						# has added explicitly
-						
-						# rename the new remote back to what it was
-						smr.rename(orig_name)
-						
-						# early on, we verified that the our current tracking branch
-						# exists in the remote. Now we have to assure that the 
-						# sha we point to is still contained in the new remote
-						# tracking branch.
-						smsha = sm.binsha
-						found = False
-						rref = smr.refs[self.branch_name]
-						for c in rref.commit.traverse():
-							if c.binsha == smsha:
-								found = True
-								break
-							# END traverse all commits in search for sha
-						# END for each commit
-						
-						if not found:
-							# adjust our internal binsha to use the one of the remote
-							# this way, it will be checked out in the next step
-							# This will change the submodule relative to us, so 
-							# the user will be able to commit the change easily
-							print >> sys.stderr, "WARNING: Current sha %s was not contained in the tracking branch at the new remote, setting it the the remote's tracking branch" % sm.hexsha
-							sm.binsha = rref.commit.binsha
-						#END reset binsha
-						
-						#NOTE: All checkout is performed by the base implementation of update
-						
+						if not dry_run:
+							assert nn not in [r.name for r in rmts]
+							smr = smm.create_remote(nn, sm.url)
+							smr.fetch(progress=progress)
+							
+							# If we have a tracking branch, it should be available
+							# in the new remote as well.
+							if len([r for r in smr.refs if r.remote_head == sm.branch_name]) == 0:
+								raise ValueError("Submodule branch named %r was not available in new submodule remote at %r" % (sm.branch_name, sm.url))
+							# END head is not detached
+							
+							# now delete the changed one
+							rmt_for_deletion = None
+							for remote in rmts:
+								if remote.url == psm.url:
+									rmt_for_deletion = remote
+									break
+								# END if urls match
+							# END for each remote
+							
+							# if we didn't find a matching remote, but have exactly one, 
+							# we can safely use this one
+							if rmt_for_deletion is None:
+								if len(rmts) == 1:
+									rmt_for_deletion = rmts[0]
+								else:
+									# if we have not found any remote with the original url
+									# we may not have a name. This is a special case, 
+									# and its okay to fail here
+									# Alternatively we could just generate a unique name and leave all
+									# existing ones in place
+									raise InvalidGitRepositoryError("Couldn't find original remote-repo at url %r" % psm.url)
+								#END handle one single remote
+							# END handle check we found a remote
+							
+							orig_name = rmt_for_deletion.name
+							smm.delete_remote(rmt_for_deletion)
+							# NOTE: Currently we leave tags from the deleted remotes
+							# as well as separate tracking branches in the possibly totally 
+							# changed repository ( someone could have changed the url to 
+							# another project ). At some point, one might want to clean
+							# it up, but the danger is high to remove stuff the user
+							# has added explicitly
+							
+							# rename the new remote back to what it was
+							smr.rename(orig_name)
+							
+							# early on, we verified that the our current tracking branch
+							# exists in the remote. Now we have to assure that the 
+							# sha we point to is still contained in the new remote
+							# tracking branch.
+							smsha = sm.binsha
+							found = False
+							rref = smr.refs[self.branch_name]
+							for c in rref.commit.traverse():
+								if c.binsha == smsha:
+									found = True
+									break
+								# END traverse all commits in search for sha
+							# END for each commit
+							
+							if not found:
+								# adjust our internal binsha to use the one of the remote
+								# this way, it will be checked out in the next step
+								# This will change the submodule relative to us, so 
+								# the user will be able to commit the change easily
+								print >> sys.stderr, "WARNING: Current sha %s was not contained in the tracking branch at the new remote, setting it the the remote's tracking branch" % sm.hexsha
+								sm.binsha = rref.commit.binsha
+							#END reset binsha
+							
+							#NOTE: All checkout is performed by the base implementation of update
+						#END handle dry_run
+						progress.update(END|URLCHANGE, i, len_csms, prefix+"Done adjusting url of submodule %r" % (sm.name))
 					# END skip remote handling if new url already exists in module
 				# END handle url
 				
+				# HANDLE PATH CHANGES
+				#####################
 				if sm.branch_path != psm.branch_path:
 					# finally, create a new tracking branch which tracks the 
 					# new remote branch
-					smm = sm.module()
-					smmr = smm.remotes
-					try:
-						tbr = git.Head.create(smm, sm.branch_name, logmsg='branch: Created from HEAD')
-					except OSError:
-						# ... or reuse the existing one
-						tbr = git.Head(smm, sm.branch_path)
-					#END assure tracking branch exists
-					
-					tbr.set_tracking_branch(find_first_remote_branch(smmr, sm.branch_name))
-					# figure out whether the previous tracking branch contains
-					# new commits compared to the other one, if not we can 
-					# delete it.
-					try:
-						tbr = find_first_remote_branch(smmr, psm.branch_name)
-						if len(smm.git.cherry(tbr, psm.branch)) == 0:
-							psm.branch.delete(smm, psm.branch)
-						#END delete original tracking branch if there are no changes
-					except InvalidGitRepositoryError:
-						# ignore it if the previous branch couldn't be found in the
-						# current remotes, this just means we can't handle it
-						pass
-					# END exception handling
-					
-					#NOTE: All checkout is done in the base implementation of update
+					progress.update(BEGIN|BRANCHCHANGE, i, len_csms, prefix+"Changing branch of submodule %r from %s to %s" % (sm.name, psm.branch_path, sm.branch_path))
+					if not dry_run:
+						smm = sm.module()
+						smmr = smm.remotes
+						try:
+							tbr = git.Head.create(smm, sm.branch_name, logmsg='branch: Created from HEAD')
+						except OSError:
+							# ... or reuse the existing one
+							tbr = git.Head(smm, sm.branch_path)
+						#END assure tracking branch exists
+						
+						tbr.set_tracking_branch(find_first_remote_branch(smmr, sm.branch_name))
+						# figure out whether the previous tracking branch contains
+						# new commits compared to the other one, if not we can 
+						# delete it.
+						try:
+							tbr = find_first_remote_branch(smmr, psm.branch_name)
+							if len(smm.git.cherry(tbr, psm.branch)) == 0:
+								psm.branch.delete(smm, psm.branch)
+							#END delete original tracking branch if there are no changes
+						except InvalidGitRepositoryError:
+							# ignore it if the previous branch couldn't be found in the
+							# current remotes, this just means we can't handle it
+							pass
+						# END exception handling
+						
+						#NOTE: All checkout is done in the base implementation of update
+					#END handle dry_run
 					
+					progress.update(END|BRANCHCHANGE, i, len_csms, prefix+"Done changing branch of submodule %r" % sm.name)
 				#END handle branch
 			#END handle 
 		# END for each common submodule 
@@ -234,15 +291,20 @@ class RootModule(Submodule):
 		######################################
 		for sm in sms:
 			# update the submodule using the default method
-			sm.update(recursive=False, init=init, to_latest_revision=to_latest_revision)
+			sm.update(recursive=False, init=init, to_latest_revision=to_latest_revision, 
+						progress=progress, dry_run=dry_run)
 			
 			# update recursively depth first - question is which inconsitent 
 			# state will be better in case it fails somewhere. Defective branch
 			# or defective depth. The RootSubmodule type will never process itself, 
 			# which was done in the previous expression
 			if recursive:
-				type(self)(sm.module()).update(recursive=True, force_remove=force_remove, 
-											init=init, to_latest_revision=to_latest_revision)
+				# the module would exist by now if we are not in dry_run mode
+				if sm.module_exists():
+					type(self)(sm.module()).update(	recursive=True, force_remove=force_remove, 
+													init=init, to_latest_revision=to_latest_revision,
+													progress=progress, dry_run=dry_run)
+				#END handle dry_run
 			#END handle recursive
 		# END for each submodule to update