Implemented dry_run mode including tests for RootModule.update and Submodule

1 files changed, 124 insertions, 111 deletions

diff --git a/objects/submodule/root.py b/objects/submodule/root.py
index 49fb1417..36cd7209 100644
--- a/objects/submodule/root.py
+++ b/objects/submodule/root.py
@@ -7,7 +7,7 @@ import git
 
 import sys
 
-__all__ = ["RootModule"]
+__all__ = ["RootModule", "RootUpdateProgress"]
 
 
 class RootUpdateProgress(UpdateProgress):
@@ -84,6 +84,10 @@ class RootModule(Submodule):
 			progress = RootUpdateProgress()
 		#END assure progress is set
 		
+		prefix = ''
+		if dry_run:
+			prefix = 'DRY-RUN: '
+		
 		repo = self.repo
 		
 		# SETUP BASE COMMIT
@@ -121,14 +125,16 @@ class RootModule(Submodule):
 			
 			# fake it into thinking its at the current commit to allow deletion
 			# of previous module. Trigger the cache to be updated before that
-			progress.update(op, i, len_rrsm, "Removing submodule %s at %s" % (rsm.name, rsm.abspath))
+			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, "Done removing submodule %s" % rsm.name)
+			progress.update(op, i, len_rrsm, prefix+"Done removing submodule %r" % rsm.name)
 		# END for each removed submodule
 		
 		# HANDLE PATH RENAMES
@@ -143,18 +149,18 @@ class RootModule(Submodule):
 			#PATH CHANGES
 			##############
 			if sm.path != psm.path and psm.module_exists():
-				progress.update(BEGIN|PATHCHANGE, i, len_csms, "Moving submodule's %s repository from %s to %s" % (sm.name, psm.abspath, sm.abspath))  
+				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)
-				progress.update(END|PATHCHANGE, i, len_csms, "Done moving repository of submodule %s" % sm.name)
+				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
 				###################
 				if sm.url != psm.url:
-					progress.update(BEGIN|URLCHANGE, i, len_csms, "Changing url of submodule %s from %s to %s" % (sm.name, psm.url, sm.url))
-					
 					# Add the new remote, remove the old one
 					# This way, if the url just changes, the commits will not 
 					# have to be re-retrieved
@@ -164,79 +170,81 @@ 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(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
-						
-						progress.update(END|URLCHANGE, i, len_csms, "Done adjusting url of submodule %s" % (sm.name))
+						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
 				
@@ -245,34 +253,36 @@ class RootModule(Submodule):
 				if sm.branch_path != psm.branch_path:
 					# finally, create a new tracking branch which tracks the 
 					# new remote branch
-					progress.update(BEGIN|BRANCHCHANGE, i, len_csms, "Changing branch of submodule %s from %s to %s" % (sm.name, psm.branch_path, sm.branch_path))
-					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, "Done changing branch of submodule %s" % sm.name)
+					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 
@@ -289,9 +299,12 @@ class RootModule(Submodule):
 			# 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,
-												progress=progress, dry_run=dry_run)
+				# 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