First run in order to fix the remote handling. Cleaned up interfaces and figured out that the implementation really should be specific to the git command. This leaves the interface open for other implemntations which use a different way to provide feedback (as we do not make assumptions about the format of a feedback line)

9 files changed, 642 insertions, 630 deletions

diff --git a/git/cmd.py b/git/cmd.py
index 17734178..29d942ae 100644
--- a/git/cmd.py
+++ b/git/cmd.py
@@ -5,7 +5,10 @@
 # the BSD License: http://www.opensource.org/licenses/bsd-license.php
 
 import os, sys
-from util import LazyMixin
+from util import (
+					LazyMixin, 
+					stream_copy
+				)
 from exc import GitCommandError
 
 from subprocess import (
diff --git a/git/db/cmd/base.py b/git/db/cmd/base.py
index 393d9262..78adbc6e 100644
--- a/git/db/cmd/base.py
+++ b/git/db/cmd/base.py
@@ -14,18 +14,18 @@ from git.base import (
 from git.util import (
 							bin_to_hex, 
 							hex_to_bin,
-							RemoteProgress,
 							isfile,
 							join_path,
 							join,
 							Actor,
-							IterableList
+							IterableList,
 					)
-from git.db.interface import FetchInfo as GitdbFetchInfo
-from git.db.interface import PushInfo as GitdbPushInfo
 from git.db.interface import (
+							FetchInfo,
+							PushInfo,
 							HighLevelRepository,
-							TransportDB
+							TransportDB,
+							RemoteProgress
 							)
 from git.cmd import Git
 from git.refs import (
@@ -41,8 +41,8 @@ import os
 import sys
 
 
-__all__ = ('CmdTransportMixin', 'RemoteProgress', 'GitCommandMixin', 
-			'CmdObjectDBRMixin', 'CmdHighLevelRepository')
+__all__ = ('CmdTransportMixin', 'GitCommandMixin', 'CmdPushInfo', 'CmdFetchInfo', 
+			'CmdRemoteProgress', 'CmdObjectDBRMixin', 'CmdHighLevelRepository')
 
 
 #{ Utilities
@@ -115,13 +115,13 @@ def get_fetch_info_from_stderr(repo, proc, progress):
 	
 	assert len(fetch_info_lines) == len(fetch_head_info)
 	
-	output.extend(FetchInfo._from_line(repo, err_line, fetch_line) 
+	output.extend(CmdFetchInfo._from_line(repo, err_line, fetch_line) 
 					for err_line,fetch_line in zip(fetch_info_lines, fetch_head_info))
 	
 	finalize_process(proc)
 	return output
 
-def get_push_info(repo, proc, progress):
+def get_push_info(repo, remotename_or_url, proc, progress):
 	# read progress information from stderr
 	# we hope stdout can hold all the data, it should ...
 	# read the lines manually as it will use carriage returns between the messages
@@ -131,7 +131,7 @@ def get_push_info(repo, proc, progress):
 	output = IterableList('name')
 	for line in proc.stdout.readlines():
 		try:
-			output.append(PushInfo._from_line(repo, line))
+			output.append(CmdPushInfo._from_line(repo, remotename_or_url, line))
 		except ValueError:
 			# if an error happens, additional info is given which we cannot parse
 			pass
@@ -143,37 +143,119 @@ def get_push_info(repo, proc, progress):
 
 #} END utilities
 
-class PushInfo(GitdbPushInfo):
+class CmdRemoteProgress(RemoteProgress):
 	"""
-	Carries information about the result of a push operation of a single head::
-	
-		info = remote.push()[0]
-		info.flags			# bitflags providing more information about the result
-		info.local_ref		# Reference pointing to the local reference that was pushed
-							# It is None if the ref was deleted.
-		info.remote_ref_string # path to the remote reference located on the remote side
-		info.remote_ref # Remote Reference on the local side corresponding to 
-						# the remote_ref_string. It can be a TagReference as well.
-		info.old_commit_binsha # binary sha at which the remote_ref was standing before we pushed
-						# it to local_ref.commit. Will be None if an error was indicated
-		info.summary	# summary line providing human readable english text about the push
-		"""
-	__slots__ = ('local_ref', 'remote_ref_string', 'flags', 'old_commit_binsha', '_remote', 'summary')
+	A Remote progress implementation taking a user derived progress to call the 
+	respective methods on.
+	"""
+	__slots__ = ("_seen_ops", '_progress')
+	re_op_absolute = re.compile("(remote: )?([\w\s]+):\s+()(\d+)()(.*)")
+	re_op_relative = re.compile("(remote: )?([\w\s]+):\s+(\d+)% \((\d+)/(\d+)\)(.*)")
+	
+	def __init__(self, progress_instance = None):
+		self._seen_ops = list()
+		if progress_instance is None:
+			progress_instance = RemoteProgress()
+		#END assure proper instance
+		self._progress = progress_instance
+	
+	def _parse_progress_line(self, line):
+		"""Parse progress information from the given line as retrieved by git-push
+		or git-fetch
+		
+		Call the own update(), __call__() and line_dropped() methods according 
+		to the parsed result.
+		
+		:return: list(line, ...) list of lines that could not be processed"""
+		# handle
+		# Counting objects: 4, done. 
+		# Compressing objects:	50% (1/2)	\rCompressing objects: 100% (2/2)	\rCompressing objects: 100% (2/2), done.
+		sub_lines = line.split('\r')
+		failed_lines = list()
+		for sline in sub_lines:
+			# find esacpe characters and cut them away - regex will not work with 
+			# them as they are non-ascii. As git might expect a tty, it will send them
+			last_valid_index = None
+			for i,c in enumerate(reversed(sline)):
+				if ord(c) < 32:
+					# its a slice index
+					last_valid_index = -i-1 
+				# END character was non-ascii
+			# END for each character in sline
+			if last_valid_index is not None:
+				sline = sline[:last_valid_index]
+			# END cut away invalid part
+			sline = sline.rstrip()
+			
+			cur_count, max_count = None, None
+			match = self.re_op_relative.match(sline)
+			if match is None:
+				match = self.re_op_absolute.match(sline)
+				
+			if not match:
+				self._progress.line_dropped(sline)
+				failed_lines.append(sline)
+				continue
+			# END could not get match
+			
+			op_code = 0
+			remote, op_name, percent, cur_count, max_count, message = match.groups()
+			
+			# get operation id
+			if op_name == "Counting objects":
+				op_code |= self.COUNTING
+			elif op_name == "Compressing objects":
+				op_code |= self.COMPRESSING
+			elif op_name == "Writing objects":
+				op_code |= self.WRITING
+			else:
+				raise ValueError("Operation name %r unknown" % op_name)
+			
+			# figure out stage
+			if op_code not in self._seen_ops:
+				self._seen_ops.append(op_code)
+				op_code |= self.BEGIN
+			# END begin opcode
+			
+			if message is None:
+				message = ''
+			# END message handling
+			
+			message = message.strip()
+			done_token = ', done.'
+			if message.endswith(done_token):
+				op_code |= self.END
+				message = message[:-len(done_token)]
+			# END end message handling
+			
+			self._progress.update(op_code, cur_count, max_count, message, line)
+			self._progress(message, line)
+		# END for each sub line
+		return failed_lines
+
+
+class CmdPushInfo(PushInfo):
+	"""
+	Pure Python implementation of a PushInfo interface
+	"""
+	__slots__ = ('local_ref', 'remote_ref_string', 'flags', 'old_commit_binsha', 
+				'_remotename_or_url', 'repo', 'summary')
 	
-	_flag_map = {	'X' : GitdbPushInfo.NO_MATCH, 
-					'-' : GitdbPushInfo.DELETED, '*' : 0,
-					'+' : GitdbPushInfo.FORCED_UPDATE, 
-					' ' : GitdbPushInfo.FAST_FORWARD, 
-					'=' : GitdbPushInfo.UP_TO_DATE, 
-					'!' : GitdbPushInfo.ERROR }
+	_flag_map = {	'X' : PushInfo.NO_MATCH, 
+					'-' : PushInfo.DELETED, '*' : 0,
+					'+' : PushInfo.FORCED_UPDATE, 
+					' ' : PushInfo.FAST_FORWARD, 
+					'=' : PushInfo.UP_TO_DATE, 
+					'!' : PushInfo.ERROR }
 	
-	def __init__(self, flags, local_ref, remote_ref_string, remote, old_commit_binsha=None, 
+	def __init__(self, flags, local_ref, remote_ref_string, repo, remotename_or_url, old_commit_binsha=None, 
 					summary=''):
 		""" Initialize a new instance """
 		self.flags = flags
 		self.local_ref = local_ref
+		self.repo = repo
 		self.remote_ref_string = remote_ref_string
-		self._remote = remote
+		self._remotename_or_url = remotename_or_url
 		self.old_commit_binsha = old_commit_binsha
 		self.summary = summary
 		
@@ -185,16 +267,20 @@ class PushInfo(GitdbPushInfo):
 			to the remote_ref_string kept in this instance."""
 		# translate heads to a local remote, tags stay as they are
 		if self.remote_ref_string.startswith("refs/tags"):
-			return TagReference(self._remote.repo, self.remote_ref_string)
+			return TagReference(self.repo, self.remote_ref_string)
 		elif self.remote_ref_string.startswith("refs/heads"):
-			remote_ref = Reference(self._remote.repo, self.remote_ref_string)
-			return RemoteReference(self._remote.repo, "refs/remotes/%s/%s" % (str(self._remote), remote_ref.name))
+			remote_ref = Reference(self.repo, self.remote_ref_string)
+			if '/' in self._remotename_or_url:
+				sys.stderr.write("Cannot provide RemoteReference instance if it was created from a url instead of of a remote name: %s. Returning Reference instance instead" % sefl._remotename_or_url)
+				return remote_ref
+			#END assert correct input
+			return RemoteReference(self.repo, "refs/remotes/%s/%s" % (str(self._remotename_or_url), remote_ref.name))
 		else:
 			raise ValueError("Could not handle remote ref: %r" % self.remote_ref_string)
 		# END 
 		
 	@classmethod
-	def _from_line(cls, remote, line):
+	def _from_line(cls, repo, remotename_or_url, line):
 		"""Create a new PushInfo instance as parsed from line which is expected to be like
 			refs/heads/master:refs/heads/master 05d2687..1d0568e"""
 		control_character, from_to, summary = line.split('\t', 3)
@@ -212,7 +298,7 @@ class PushInfo(GitdbPushInfo):
 		if flags & cls.DELETED:
 			from_ref = None
 		else:
-			from_ref = Reference.from_path(remote.repo, from_ref_string)
+			from_ref = Reference.from_path(repo, from_ref_string)
 		
 		# commit handling, could be message or commit info
 		old_commit_binsha = None
@@ -237,38 +323,27 @@ class PushInfo(GitdbPushInfo):
 			if control_character == " ":
 				split_token = ".."
 			old_sha, new_sha = summary.split(' ')[0].split(split_token)
-			# have to use constructor here as the sha usually is abbreviated
-			old_commit_binsha = remote.repo.commit(old_sha)
+			old_commit_binsha = repo.resolve(old_sha)
 		# END message handling
 		
-		return PushInfo(flags, from_ref, to_ref_string, remote, old_commit_binsha, summary)
+		return cls(flags, from_ref, to_ref_string, repo, remotename_or_url, old_commit_binsha, summary)
 		
 
-class FetchInfo(GitdbFetchInfo):
+class CmdFetchInfo(FetchInfo):
 	"""
-	Carries information about the results of a fetch operation of a single head::
-	
-	 info = remote.fetch()[0]
-	 info.ref			# Symbolic Reference or RemoteReference to the changed 
-						# remote head or FETCH_HEAD
-	 info.flags			# additional flags to be & with enumeration members, 
-						# i.e. info.flags & info.REJECTED 
-						# is 0 if ref is FETCH_HEAD
-	 info.note			# additional notes given by git-fetch intended for the user
-	 info.old_commit_binsha	# if info.flags & info.FORCED_UPDATE|info.FAST_FORWARD, 
-						# field is set to the previous location of ref, otherwise None
+	Pure python implementation of a FetchInfo interface
 	"""
 	__slots__ = ('ref','old_commit_binsha', 'flags', 'note')
 	
 	#							  %c	%-*s %-*s			  -> %s		  (%s)
 	re_fetch_result = re.compile("^\s*(.) (\[?[\w\s\.]+\]?)\s+(.+) -> ([/\w_\+\.-]+)(	 \(.*\)?$)?")
 	
-	_flag_map = {	'!' : GitdbFetchInfo.ERROR, 
-					'+' : GitdbFetchInfo.FORCED_UPDATE, 
-					'-' : GitdbFetchInfo.TAG_UPDATE, 
+	_flag_map = {	'!' : FetchInfo.ERROR, 
+					'+' : FetchInfo.FORCED_UPDATE, 
+					'-' : FetchInfo.TAG_UPDATE, 
 					'*' : 0,
-					'=' : GitdbFetchInfo.HEAD_UPTODATE, 
-					' ' : GitdbFetchInfo.FAST_FORWARD } 
+					'=' : FetchInfo.HEAD_UPTODATE, 
+					' ' : FetchInfo.FAST_FORWARD } 
 	
 	def __init__(self, ref, flags, note = '', old_commit_binsha = None):
 		"""
@@ -295,7 +370,7 @@ class FetchInfo(GitdbFetchInfo):
 	@classmethod
 	def _from_line(cls, repo, line, fetch_line):
 		"""Parse information from the given line as returned by git-fetch -v
-		and return a new FetchInfo object representing this information.
+		and return a new CmdFetchInfo object representing this information.
 		
 		We can handle a line as follows
 		"%c %-*s %-*s -> %s%s"
@@ -366,7 +441,7 @@ class FetchInfo(GitdbFetchInfo):
 				split_token = '...'
 				if control_character == ' ':
 					split_token = split_token[:-1]
-				old_commit_binsha = repo.rev_parse(operation.split(split_token)[0])
+				old_commit_binsha = repo.resolve(operation.split(split_token)[0])
 			# END handle refspec
 		# END reference flag handling
 		
@@ -443,7 +518,7 @@ class CmdTransportMixin(TransportDB):
 		:param progress: RemoteProgress derived instance or None
 		:param **kwargs: Additional arguments to be passed to the git-push process"""
 		proc = self._git.push(url, refspecs, porcelain=True, as_process=True, **kwargs)
-		return get_push_info(self, proc, progress or RemoteProgress())
+		return get_push_info(self, url, proc, CmdRemoteProgress(progress))
 		
 	def pull(self, url, refspecs=None, progress=None, **kwargs):
 		"""Fetch and merge the given refspecs. 
@@ -453,7 +528,7 @@ class CmdTransportMixin(TransportDB):
 		:param refspecs: see push()
 		:param progress: see push()"""
 		proc = self._git.pull(url, refspecs, with_extended_output=True, as_process=True, v=True, **kwargs)
-		return get_fetch_info_from_stderr(self, proc, progress or RemoteProgress())
+		return get_fetch_info_from_stderr(self, proc, CmdRemoteProgress(progress))
 		
 	def fetch(self, url, refspecs=None, progress=None, **kwargs):
 		"""Fetch the latest changes
@@ -461,7 +536,7 @@ class CmdTransportMixin(TransportDB):
 		:param refspecs: see push()
 		:param progress: see push()"""
 		proc = self._git.fetch(url, refspecs, with_extended_output=True, as_process=True, v=True, **kwargs)
-		return get_fetch_info_from_stderr(self, proc, progress or RemoteProgress())
+		return get_fetch_info_from_stderr(self, proc, CmdRemoteProgress(progress))
 		
 	#} end transport db interface
 	
@@ -699,14 +774,14 @@ class CmdHighLevelRepository(HighLevelRepository):
 			All remaining keyword arguments are given to the git-clone command
 			
 		For more information, see the respective method in HighLevelRepository"""
-		return self._clone(self.git, self.git_dir, path, progress or RemoteProgress(), **kwargs)
+		return self._clone(self.git, self.git_dir, path, CmdRemoteProgress(progress), **kwargs)
 
 	@classmethod
 	def clone_from(cls, url, to_path, progress = None, **kwargs):
 		"""
 		:param kwargs: see the ``clone`` method
 		For more information, see the respective method in the HighLevelRepository"""
-		return cls._clone(cls.GitCls(os.getcwd()), url, to_path, progress or RemoteProgress(), **kwargs)
+		return cls._clone(cls.GitCls(os.getcwd()), url, to_path, CmdRemoteProgress(progress), **kwargs)
 
 	def archive(self, ostream, treeish=None, prefix=None,  **kwargs):
 		"""For all args see HighLevelRepository interface
diff --git a/git/db/interface.py b/git/db/interface.py
index a7502e85..30b0c7c1 100644
--- a/git/db/interface.py
+++ b/git/db/interface.py
@@ -238,6 +238,64 @@ class RefSpec(object):
 		return self.source is None
 		
 		
+class RemoteProgress(object):
+	"""
+	Handler providing an interface to parse progress information emitted by git-push
+	and git-fetch and to dispatch callbacks allowing subclasses to react to the progress.
+	
+	Subclasses should derive from this type.
+	"""
+	_num_op_codes = 5
+	BEGIN, END, COUNTING, COMPRESSING, WRITING =  [1 << x for x in range(_num_op_codes)]
+	STAGE_MASK = BEGIN|END
+	OP_MASK = ~STAGE_MASK
+	
+	#{ Subclass Interface
+	
+	def line_dropped(self, line):
+		"""Called whenever a line could not be understood and was therefore dropped."""
+		pass
+	
+	def update(self, op_code, cur_count, max_count=None, message='', input=''):
+		"""Called whenever the progress changes
+		
+		:param op_code:
+			Integer allowing to be compared against Operation IDs and stage IDs.
+			
+			Stage IDs are BEGIN and END. BEGIN will only be set once for each Operation 
+			ID as well as END. It may be that BEGIN and END are set at once in case only
+			one progress message was emitted due to the speed of the operation.
+			Between BEGIN and END, none of these flags will be set
+			
+			Operation IDs are all held within the OP_MASK. Only one Operation ID will 
+			be active per call.
+		:param cur_count: Current absolute count of items
+			
+		:param max_count:
+			The maximum count of items we expect. It may be None in case there is 
+			no maximum number of items or if it is (yet) unknown.
+		
+		:param message:
+			In case of the 'WRITING' operation, it contains the amount of bytes
+			transferred. It may possibly be used for other purposes as well.
+		
+		:param input:
+			The actual input string that was used to parse the information from.
+			This is usually a line from the output of git-fetch, but really
+			depends on the implementation
+		
+		You may read the contents of the current line in self._cur_line"""
+		pass
+	
+	def __call__(self, message, input=''):
+		"""Same as update, but with a simpler interface which only provides the
+		message of the operation.
+		:note: This method will be called in addition to the update method. It is 
+			up to you which one you implement"""
+		pass
+	#} END subclass interface
+	
+		
 class PushInfo(object):
 	"""A type presenting information about the result of a push operation for exactly
 	one refspec
@@ -248,7 +306,7 @@ class PushInfo(object):
 	remote_ref_string 	# path to the remote reference located on the remote side
 	remote_ref 			# Remote Reference on the local side corresponding to 
 						# the remote_ref_string. It can be a TagReference as well.
-	old_commit 			# commit at which the remote_ref was standing before we pushed
+	old_commit_binsha 	# binary sha to commit at which the remote_ref was standing before we pushed
 						# it to local_ref.commit. Will be None if an error was indicated
 	summary				# summary line providing human readable english text about the push
 	"""
@@ -269,10 +327,8 @@ class FetchInfo(object):
 					# i.e. info.flags & info.REJECTED 
 					# is 0 if ref is FETCH_HEAD
 	note				# additional notes given by the fetch-pack implementation intended for the user
-	old_commit		# if info.flags & info.FORCED_UPDATE|info.FAST_FORWARD, 
-					# field is set to the previous location of ref as hexsha or None
-					# Implementors may use their own type too, but it should decay into a
-					# string of its hexadecimal sha representation"""
+	old_commit_binsha# if info.flags & info.FORCED_UPDATE|info.FAST_FORWARD, 
+					# field is set to the previous location of ref as binary sha or None"""
 	__slots__ = tuple()
 	
 	NEW_TAG, NEW_HEAD, HEAD_UPTODATE, TAG_UPDATE, REJECTED, FORCED_UPDATE, \
diff --git a/git/db/py/base.py b/git/db/py/base.py
index a2c9a4ef..2fdbd202 100644
--- a/git/db/py/base.py
+++ b/git/db/py/base.py
@@ -18,7 +18,7 @@ from git.util import (
 		expandvars,
 		expanduser,
 		exists,
-		is_git_dir
+		is_git_dir,
 	)
 
 from git.index import IndexFile
@@ -40,7 +40,7 @@ import os
 __all__ = (	'PureObjectDBR', 'PureObjectDBW', 'PureRootPathDB', 'PureCompoundDB', 
 			'PureConfigurationMixin', 'PureRepositoryPathsMixin', 'PureAlternatesFileMixin',
 			'PureIndexDB')
-
+                                                                        
 
 class PureObjectDBR(ObjectDBR):
 	
@@ -471,3 +471,4 @@ class PureAlternatesFileMixin(object):
 	alternates = property(_get_alternates, _set_alternates, doc="Retrieve a list of alternates paths or set a list paths to be used as alternates")
 	
 	#} END interface
+	
diff --git a/git/objects/submodule/base.py b/git/objects/submodule/base.py
index e38b94f8..c1cc51aa 100644
--- a/git/objects/submodule/base.py
+++ b/git/objects/submodule/base.py
@@ -18,9 +18,10 @@ from git.util import (
 						Iterable, 
 						join_path_native, 
 						to_native_path_linux,
-						RemoteProgress
 					)
 
+from git.db.interface import RemoteProgress
+
 from git.config import SectionConstraint
 from git.exc import (
 					InvalidGitRepositoryError, 
diff --git a/git/remote.py b/git/remote.py
index f44f0150..47adedbf 100644
--- a/git/remote.py
+++ b/git/remote.py
@@ -13,15 +13,14 @@ from config import SectionConstraint
 from git.util import (
 						LazyMixin,
 						Iterable,
-						IterableList,
-						RemoteProgress
+						IterableList
 						)
 from git.db.interface import TransportDB
 from refs import RemoteReference
 
 import os
 
-__all__ = ('RemoteProgress', 'Remote')
+__all__ = ['Remote']
 
 class PushInfo(object):
 	"""Wrapper for basic PushInfo to provide the previous interface which includes
@@ -268,7 +267,7 @@ class Remote(LazyMixin, Iterable):
 			in their flags.
 			If the operation fails completely, the length of the returned IterableList will
 			be null."""
-		return self.repo.push(self.name, refspec, progress, **Kwargs)
+		return self.repo.push(self.name, refspec, progress, **kwargs)
 		
 	@property
 	def config_reader(self):
diff --git a/git/test/db/cmd/test_base.py b/git/test/db/cmd/test_base.py
index 59a6a55e..959be16b 100644
--- a/git/test/db/cmd/test_base.py
+++ b/git/test/db/cmd/test_base.py
@@ -9,6 +9,7 @@ from git.util import bin_to_hex
 from git.exc import BadObject
 
 from git.db.complex import CmdCompatibilityGitDB
+from git.db.cmd.base import *
 
 class TestBase(RepoBase):
 	RepoCls = CmdCompatibilityGitDB
@@ -25,3 +26,7 @@ class TestBase(RepoBase):
 		# fails with BadObject
 		for invalid_rev in ("0000", "bad/ref", "super bad"):
 			self.failUnlessRaises(BadObject, gdb.partial_to_complete_sha_hex, invalid_rev)
+			
+	def test_fetch_info(self):
+		self.failUnlessRaises(ValueError, CmdFetchInfo._from_line, self.rorepo, "nonsense", '')
+		self.failUnlessRaises(ValueError, CmdFetchInfo._from_line, self.rorepo, "? [up to date]      0.1.7RC    -> origin/0.1.7RC", '')
diff --git a/git/test/test_remote.py b/git/test/test_remote.py
index a7387816..8ae9fe43 100644
--- a/git/test/test_remote.py
+++ b/git/test/test_remote.py
@@ -10,9 +10,16 @@ from git.test.lib import (
 						with_rw_repo,
 						)
 from git.util import IterableList
-from git.db.cmd.base import RemoteProgress
+from git.db.interface import PushInfo, FetchInfo, RemoteProgress
 from git.remote import *
 from git.exc import GitCommandError 
+from git.refs import (
+						Reference, 
+						TagReference, 
+						RemoteReference,
+						Head,
+						SymbolicReference
+					)
 
 import tempfile
 import shutil
@@ -23,430 +30,421 @@ import random
 random.seed(0)
 
 class TestRemoteProgress(RemoteProgress):
-    __slots__ = ( "_seen_lines", "_stages_per_op", '_num_progress_messages' )
-    def __init__(self):
-        super(TestRemoteProgress, self).__init__()
-        self._seen_lines = list()
-        self._stages_per_op = dict()
-        self._num_progress_messages = 0
-        
-    def _parse_progress_line(self, line):
-        # we may remove the line later if it is dropped
-        # Keep it for debugging
-        self._seen_lines.append(line)
-        rval = super(TestRemoteProgress, self)._parse_progress_line(line)
-        assert len(line) > 1, "line %r too short" % line
-        return rval
-        
-    def line_dropped(self, line):
-        try:
-            self._seen_lines.remove(line)
-        except ValueError:
-            pass
-        
-    def update(self, op_code, cur_count, max_count=None, message=''):
-        # check each stage only comes once
-        op_id = op_code & self.OP_MASK
-        assert op_id in (self.COUNTING, self.COMPRESSING, self.WRITING)
-        
-        self._stages_per_op.setdefault(op_id, 0)
-        self._stages_per_op[ op_id ] = self._stages_per_op[ op_id ] | (op_code & self.STAGE_MASK)
-        
-        if op_code & (self.WRITING|self.END) == (self.WRITING|self.END):
-            assert message
-        # END check we get message
-        
-        self._num_progress_messages += 1
-        
-        
-    def make_assertion(self):
-        # we don't always receive messages
-        if not self._seen_lines:
-            return
-        
-        # sometimes objects are not compressed which is okay
-        assert len(self._seen_ops) in (2,3)
-        assert self._stages_per_op
-        
-        # must have seen all stages
-        for op, stages in self._stages_per_op.items():
-            assert stages & self.STAGE_MASK == self.STAGE_MASK
-        # END for each op/stage
+	__slots__ = ( "_seen_lines", "_stages_per_op", '_num_progress_messages')
+	def __init__(self):
+		super(TestRemoteProgress, self).__init__()
+		self._seen_lines = list()
+		self._stages_per_op = dict()
+		self._seen_ops = set()
+		self._num_progress_messages = 0
+		
+	def line_dropped(self, line):
+		try:
+			self._seen_lines.remove(line)
+		except ValueError:
+			pass
+		
+	def __call__(self, message, input=''):
+		pass
+		
+	def update(self, op_code, cur_count, max_count=None, message='', input=''):
+		# check each stage only comes once
+		if input:
+			self._seen_lines.append(input)
+		#END handle input
+		op_id = op_code & self.OP_MASK
+		assert op_id in (self.COUNTING, self.COMPRESSING, self.WRITING)
+		
+		self._stages_per_op.setdefault(op_id, 0)
+		self._stages_per_op[ op_id ] = self._stages_per_op[ op_id ] | (op_code & self.STAGE_MASK)
+		
+		if op_code & (self.WRITING|self.END) == (self.WRITING|self.END):
+			assert message
+		# END check we get message
+		
+		self._num_progress_messages += 1
+		
+		
+	def make_assertion(self):
+		# we don't always receive messages
+		if not self._seen_lines:
+			return
+		
+		# sometimes objects are not compressed which is okay
+		assert len(self._stages_per_op.keys()) in (2,3)
+		assert self._stages_per_op
+		
+		# must have seen all stages
+		for op, stages in self._stages_per_op.items():
+			assert stages & self.STAGE_MASK == self.STAGE_MASK
+		# END for each op/stage
 
-    def assert_received_message(self):
-        assert self._num_progress_messages
-    
+	def assert_received_message(self):
+		assert self._num_progress_messages
+	
 
 class TestRemote(TestBase):
-    
-    def _print_fetchhead(self, repo):
-        fp = open(os.path.join(repo.git_dir, "FETCH_HEAD"))
-        fp.close()
-        
-        
-    def _do_test_fetch_result(self, results, remote):
-        # self._print_fetchhead(remote.repo)
-        assert len(results) > 0 and isinstance(results[0], FetchInfo)
-        for info in results:
-            assert isinstance(info.note, basestring)
-            if isinstance(info.ref, Reference):
-                assert info.flags != 0
-            # END reference type flags handling 
-            assert isinstance(info.ref, (SymbolicReference, Reference))
-            if info.flags & (info.FORCED_UPDATE|info.FAST_FORWARD):
-                assert isinstance(info.old_commit, Commit)
-            else:
-                assert info.old_commit is None
-            # END forced update checking  
-        # END for each info
-        
-    def _do_test_push_result(self, results, remote):
-        assert len(results) > 0 and isinstance(results[0], PushInfo)
-        for info in results:
-            assert info.flags
-            assert isinstance(info.summary, basestring)
-            if info.old_commit is not None:
-                assert isinstance(info.old_commit, Commit)
-            if info.flags & info.ERROR:
-                has_one = False
-                for bitflag in (info.REJECTED, info.REMOTE_REJECTED, info.REMOTE_FAILURE):
-                    has_one |= bool(info.flags & bitflag)
-                # END for each bitflag
-                assert has_one
-            else:
-                # there must be a remote commit
-                if info.flags & info.DELETED == 0: 
-                    assert isinstance(info.local_ref, Reference)
-                else:
-                    assert info.local_ref is None
-                assert type(info.remote_ref) in (TagReference, RemoteReference)
-            # END error checking
-        # END for each info 
-        
-        
-    def _do_test_fetch_info(self, repo):
-        self.failUnlessRaises(ValueError, FetchInfo._from_line, repo, "nonsense", '')
-        self.failUnlessRaises(ValueError, FetchInfo._from_line, repo, "? [up to date]      0.1.7RC    -> origin/0.1.7RC", '')
-        
-    def _commit_random_file(self, repo):
-        #Create a file with a random name and random data and commit it to  repo.
-        # Return the commited absolute file path
-        index = repo.index
-        new_file = self._make_file(os.path.basename(tempfile.mktemp()),str(random.random()), repo)
-        index.add([new_file])
-        index.commit("Committing %s" % new_file)
-        return new_file
-        
-    def _do_test_fetch(self,remote, rw_repo, remote_repo):
-        # specialized fetch testing to de-clutter the main test
-        self._do_test_fetch_info(rw_repo)
-        
-        def fetch_and_test(remote, **kwargs):
-            progress = TestRemoteProgress()
-            kwargs['progress'] = progress
-            res = remote.fetch(**kwargs)
-            progress.make_assertion()
-            self._do_test_fetch_result(res, remote)
-            return res
-        # END fetch and check
-        
-        def get_info(res, remote, name):
-            return res["%s/%s"%(remote,name)]
-        
-        # put remote head to master as it is garantueed to exist
-        remote_repo.head.reference = remote_repo.heads.master
-        
-        res = fetch_and_test(remote)
-        # all uptodate
-        for info in res:
-            assert info.flags & info.HEAD_UPTODATE
-        
-        # rewind remote head to trigger rejection
-        # index must be false as remote is a bare repo
-        rhead = remote_repo.head
-        remote_commit = rhead.commit
-        rhead.reset("HEAD~2", index=False)
-        res = fetch_and_test(remote)
-        mkey = "%s/%s"%(remote,'master')
-        master_info = res[mkey]
-        assert master_info.flags & FetchInfo.FORCED_UPDATE and master_info.note is not None
-        
-        # normal fast forward - set head back to previous one
-        rhead.commit = remote_commit
-        res = fetch_and_test(remote)
-        assert res[mkey].flags & FetchInfo.FAST_FORWARD
-        
-        # new remote branch
-        new_remote_branch = Head.create(remote_repo, "new_branch")
-        res = fetch_and_test(remote)
-        new_branch_info = get_info(res, remote, new_remote_branch)
-        assert new_branch_info.flags & FetchInfo.NEW_HEAD
-        
-        # remote branch rename ( causes creation of a new one locally )
-        new_remote_branch.rename("other_branch_name")
-        res = fetch_and_test(remote)
-        other_branch_info = get_info(res, remote, new_remote_branch)
-        assert other_branch_info.ref.commit == new_branch_info.ref.commit
-        
-        # remove new branch
-        Head.delete(new_remote_branch.repo, new_remote_branch)
-        res = fetch_and_test(remote)
-        # deleted remote will not be fetched
-        self.failUnlessRaises(IndexError, get_info, res, remote, new_remote_branch)
-        
-        # prune stale tracking branches
-        stale_refs = remote.stale_refs
-        assert len(stale_refs) == 2 and isinstance(stale_refs[0], RemoteReference)
-        RemoteReference.delete(rw_repo, *stale_refs)
-        
-        # test single branch fetch with refspec including target remote
-        res = fetch_and_test(remote, refspec="master:refs/remotes/%s/master"%remote)
-        assert len(res) == 1 and get_info(res, remote, 'master')
-        
-        # ... with respec and no target
-        res = fetch_and_test(remote, refspec='master')
-        assert len(res) == 1
-        
-        # add new tag reference
-        rtag = TagReference.create(remote_repo, "1.0-RV_hello.there")
-        res = fetch_and_test(remote, tags=True)
-        tinfo = res[str(rtag)]
-        assert isinstance(tinfo.ref, TagReference) and tinfo.ref.commit == rtag.commit
-        assert tinfo.flags & tinfo.NEW_TAG
-        
-        # adjust tag commit
-        Reference.set_object(rtag, rhead.commit.parents[0].parents[0])
-        res = fetch_and_test(remote, tags=True)
-        tinfo = res[str(rtag)]
-        assert tinfo.commit == rtag.commit
-        assert tinfo.flags & tinfo.TAG_UPDATE
-        
-        # delete remote tag - local one will stay
-        TagReference.delete(remote_repo, rtag)
-        res = fetch_and_test(remote, tags=True)
-        self.failUnlessRaises(IndexError, get_info, res, remote, str(rtag))
-        
-        # provoke to receive actual objects to see what kind of output we have to 
-        # expect. For that we need a remote transport protocol
-        # Create a new UN-shared repo and fetch into it after we pushed a change
-        # to the shared repo
-        other_repo_dir = tempfile.mktemp("other_repo")
-        # must clone with a local path for the repo implementation not to freak out
-        # as it wants local paths only ( which I can understand )
-        other_repo = remote_repo.clone(other_repo_dir, shared=False)
-        remote_repo_url = "git://localhost%s"%remote_repo.git_dir
-        
-        # put origin to git-url
-        other_origin = other_repo.remotes.origin 
-        other_origin.config_writer.set("url", remote_repo_url)
-        # it automatically creates alternates as remote_repo is shared as well.
-        # It will use the transport though and ignore alternates when fetching
-        # assert not other_repo.alternates  # this would fail
-        
-        # assure we are in the right state
-        rw_repo.head.reset(remote.refs.master, working_tree=True)
-        try:
-            self._commit_random_file(rw_repo)
-            remote.push(rw_repo.head.reference)
-            
-            # here I would expect to see remote-information about packing 
-            # objects and so on. Unfortunately, this does not happen 
-            # if we are redirecting the output - git explicitly checks for this
-            # and only provides progress information to ttys
-            res = fetch_and_test(other_origin)
-        finally:
-            shutil.rmtree(other_repo_dir)
-        # END test and cleanup
-        
-    def _test_push_and_pull(self,remote, rw_repo, remote_repo):
-        # push our changes
-        lhead = rw_repo.head
-        lindex = rw_repo.index
-        # assure we are on master and it is checked out where the remote is
-        try:
-            lhead.reference = rw_repo.heads.master
-        except AttributeError:
-            # if the author is on a non-master branch, the clones might not have 
-            # a local master yet. We simply create it
-            lhead.reference = rw_repo.create_head('master')
-        # END master handling 
-        lhead.reset(remote.refs.master, working_tree=True)
-        
-        # push without spec should fail ( without further configuration )
-        # well, works nicely
-        # self.failUnlessRaises(GitCommandError, remote.push)
-        
-        # simple file push
-        self._commit_random_file(rw_repo)
-        progress = TestRemoteProgress()
-        res = remote.push(lhead.reference, progress)
-        assert isinstance(res, IterableList)
-        self._do_test_push_result(res, remote)
-        progress.make_assertion()
-        
-        # rejected - undo last commit
-        lhead.reset("HEAD~1")
-        res = remote.push(lhead.reference)
-        assert res[0].flags & PushInfo.ERROR 
-        assert res[0].flags & PushInfo.REJECTED
-        self._do_test_push_result(res, remote)
-        
-        # force rejected pull
-        res = remote.push('+%s' % lhead.reference)
-        assert res[0].flags & PushInfo.ERROR == 0 
-        assert res[0].flags & PushInfo.FORCED_UPDATE
-        self._do_test_push_result(res, remote)
-        
-        # invalid refspec
-        res = remote.push("hellothere")
-        assert len(res) == 0
-        
-        # push new tags 
-        progress = TestRemoteProgress()
-        to_be_updated = "my_tag.1.0RV"
-        new_tag = TagReference.create(rw_repo, to_be_updated)
-        other_tag = TagReference.create(rw_repo, "my_obj_tag.2.1aRV", message="my message")
-        res = remote.push(progress=progress, tags=True)
-        assert res[-1].flags & PushInfo.NEW_TAG
-        progress.make_assertion()
-        self._do_test_push_result(res, remote)
-        
-        # update push new tags
-        # Rejection is default
-        new_tag = TagReference.create(rw_repo, to_be_updated, ref='HEAD~1', force=True)
-        res = remote.push(tags=True)
-        self._do_test_push_result(res, remote)
-        assert res[-1].flags & PushInfo.REJECTED and res[-1].flags & PushInfo.ERROR
-        
-        # push force this tag
-        res = remote.push("+%s" % new_tag.path)
-        assert res[-1].flags & PushInfo.ERROR == 0 and res[-1].flags & PushInfo.FORCED_UPDATE
-        
-        # delete tag - have to do it using refspec
-        res = remote.push(":%s" % new_tag.path)
-        self._do_test_push_result(res, remote)
-        assert res[0].flags & PushInfo.DELETED
-        # Currently progress is not properly transferred, especially not using 
-    	# the git daemon
-        # progress.assert_received_message()
-        
-        # push new branch
-        new_head = Head.create(rw_repo, "my_new_branch")
-        progress = TestRemoteProgress()
-        res = remote.push(new_head, progress)
-        assert res[0].flags & PushInfo.NEW_HEAD
-        progress.make_assertion()
-        self._do_test_push_result(res, remote)
-        
-        # delete new branch on the remote end and locally
-        res = remote.push(":%s" % new_head.path)
-        self._do_test_push_result(res, remote)
-        Head.delete(rw_repo, new_head)
-        assert res[-1].flags & PushInfo.DELETED
-        
-        # --all
-        res = remote.push(all=True)
-        self._do_test_push_result(res, remote)
-        
-        remote.pull('master')
-        
-        # cleanup - delete created tags and branches as we are in an innerloop on 
-        # the same repository
-        TagReference.delete(rw_repo, new_tag, other_tag)
-        remote.push(":%s" % other_tag.path)
-    
-    @with_rw_and_rw_remote_repo('0.1.6')
-    def test_base(self, rw_repo, remote_repo):
-        num_remotes = 0
-        remote_set = set()
-        ran_fetch_test = False
-        
-        for remote in rw_repo.remotes:
-            num_remotes += 1
-            assert remote == remote
-            assert str(remote) != repr(remote)
-            remote_set.add(remote)
-            remote_set.add(remote)  # should already exist
-            
-            # REFS 
-            refs = remote.refs
-            assert refs
-            for ref in refs:
-                assert ref.remote_name == remote.name
-                assert ref.remote_head
-            # END for each ref
-            
-            # OPTIONS
-            # cannot use 'fetch' key anymore as it is now a method
-            for opt in ("url", ):
-                val = getattr(remote, opt)
-                reader = remote.config_reader
-                assert reader.get(opt) == val
-                assert reader.get_value(opt, None) == val
-                
-                # unable to write with a reader
-                self.failUnlessRaises(IOError, reader.set, opt, "test")
-                
-                # change value
-                writer = remote.config_writer
-                new_val = "myval"
-                writer.set(opt, new_val)
-                assert writer.get(opt) == new_val
-                writer.set(opt, val)
-                assert writer.get(opt) == val
-                del(writer)
-                assert getattr(remote, opt) == val
-            # END for each default option key 
-            
-            # RENAME 
-            other_name = "totally_other_name"
-            prev_name = remote.name
-            assert remote.rename(other_name) == remote
-            assert prev_name != remote.name
-            # multiple times
-            for time in range(2):
-                assert remote.rename(prev_name).name == prev_name
-            # END for each rename ( back to prev_name )
-            
-            # PUSH/PULL TESTING
-            self._test_push_and_pull(remote, rw_repo, remote_repo)
-            
-            # FETCH TESTING
-            # Only for remotes - local cases are the same or less complicated 
-            # as additional progress information will never be emitted
-            if remote.name == "daemon_origin":
-                self._do_test_fetch(remote, rw_repo, remote_repo)
-                ran_fetch_test = True
-            # END fetch test  
-            
-            remote.update()
-        # END for each remote
-        
-        assert ran_fetch_test
-        assert num_remotes
-        assert num_remotes == len(remote_set)
-        
-        origin = rw_repo.remote('origin')
-        assert origin == rw_repo.remotes.origin
-        
-    @with_rw_repo('HEAD', bare=True)
-    def test_creation_and_removal(self, bare_rw_repo):
-        new_name = "test_new_one"
-        arg_list = (new_name, "git@server:hello.git")
-        remote = Remote.create(bare_rw_repo, *arg_list )
-        assert remote.name == "test_new_one"
-        assert remote in bare_rw_repo.remotes
-        
-        # create same one again
-        self.failUnlessRaises(GitCommandError, Remote.create, bare_rw_repo, *arg_list)
-        
-        Remote.remove(bare_rw_repo, new_name)
-        
-        for remote in bare_rw_repo.remotes:
-            if remote.name == new_name:
-                raise AssertionError("Remote removal failed")
-            # END if deleted remote matches existing remote's name
-        # END for each remote
-        
-        
-    
+	
+	def _print_fetchhead(self, repo):
+		fp = open(os.path.join(repo.git_dir, "FETCH_HEAD"))
+		fp.close()
+		
+		
+	def _do_test_fetch_result(self, results, remote):
+		# self._print_fetchhead(remote.repo)
+		assert len(results) > 0 and isinstance(results[0], FetchInfo)
+		for info in results:
+			assert isinstance(info.note, basestring)
+			if isinstance(info.ref, Reference):
+				assert info.flags != 0
+			# END reference type flags handling 
+			assert isinstance(info.ref, (SymbolicReference, Reference))
+			if info.flags & (info.FORCED_UPDATE|info.FAST_FORWARD):
+				assert isinstance(info.old_commit_binsha, str) and len(info.old_commit_binsha) == 20
+			else:
+				assert info.old_commit_binsha is None
+			# END forced update checking  
+		# END for each info
+		
+	def _do_test_push_result(self, results, remote):
+		assert len(results) > 0 and isinstance(results[0], PushInfo)
+		for info in results:
+			assert info.flags
+			assert isinstance(info.summary, basestring)
+			if info.old_commit_binsha is not None:
+				assert isinstance(info.old_commit_binsha, str) and len(info.old_commit_binsha) == 20
+			if info.flags & info.ERROR:
+				has_one = False
+				for bitflag in (info.REJECTED, info.REMOTE_REJECTED, info.REMOTE_FAILURE):
+					has_one |= bool(info.flags & bitflag)
+				# END for each bitflag
+				assert has_one
+			else:
+				# there must be a remote commit
+				if info.flags & info.DELETED == 0: 
+					assert isinstance(info.local_ref, Reference)
+				else:
+					assert info.local_ref is None
+				assert type(info.remote_ref) in (TagReference, RemoteReference)
+			# END error checking
+		# END for each info 
+		
+	def _commit_random_file(self, repo):
+		#Create a file with a random name and random data and commit it to	repo.
+		# Return the commited absolute file path
+		index = repo.index
+		new_file = self._make_file(os.path.basename(tempfile.mktemp()),str(random.random()), repo)
+		index.add([new_file])
+		index.commit("Committing %s" % new_file)
+		return new_file
+		
+	def _do_test_fetch(self,remote, rw_repo, remote_repo):
+		def fetch_and_test(remote, **kwargs):
+			progress = TestRemoteProgress()
+			kwargs['progress'] = progress
+			res = remote.fetch(**kwargs)
+			progress.make_assertion()
+			self._do_test_fetch_result(res, remote)
+			return res
+		# END fetch and check
+		
+		def get_info(res, remote, name):
+			return res["%s/%s"%(remote,name)]
+		
+		# put remote head to master as it is garantueed to exist
+		remote_repo.head.reference = remote_repo.heads.master
+		
+		res = fetch_and_test(remote)
+		# all uptodate
+		for info in res:
+			assert info.flags & info.HEAD_UPTODATE
+		
+		# rewind remote head to trigger rejection
+		# index must be false as remote is a bare repo
+		rhead = remote_repo.head
+		remote_commit = rhead.commit
+		rhead.reset("HEAD~2", index=False)
+		res = fetch_and_test(remote)
+		mkey = "%s/%s"%(remote,'master')
+		master_info = res[mkey]
+		assert master_info.flags & FetchInfo.FORCED_UPDATE and master_info.note is not None
+		
+		# normal fast forward - set head back to previous one
+		rhead.commit = remote_commit
+		res = fetch_and_test(remote)
+		assert res[mkey].flags & FetchInfo.FAST_FORWARD
+		
+		# new remote branch
+		new_remote_branch = Head.create(remote_repo, "new_branch")
+		res = fetch_and_test(remote)
+		new_branch_info = get_info(res, remote, new_remote_branch)
+		assert new_branch_info.flags & FetchInfo.NEW_HEAD
+		
+		# remote branch rename ( causes creation of a new one locally )
+		new_remote_branch.rename("other_branch_name")
+		res = fetch_and_test(remote)
+		other_branch_info = get_info(res, remote, new_remote_branch)
+		assert other_branch_info.ref.commit == new_branch_info.ref.commit
+		
+		# remove new branch
+		Head.delete(new_remote_branch.repo, new_remote_branch)
+		res = fetch_and_test(remote)
+		# deleted remote will not be fetched
+		self.failUnlessRaises(IndexError, get_info, res, remote, new_remote_branch)
+		
+		# prune stale tracking branches
+		stale_refs = remote.stale_refs
+		assert len(stale_refs) == 2 and isinstance(stale_refs[0], RemoteReference)
+		RemoteReference.delete(rw_repo, *stale_refs)
+		
+		# test single branch fetch with refspec including target remote
+		res = fetch_and_test(remote, refspec="master:refs/remotes/%s/master"%remote)
+		assert len(res) == 1 and get_info(res, remote, 'master')
+		
+		# ... with respec and no target
+		res = fetch_and_test(remote, refspec='master')
+		assert len(res) == 1
+		
+		# add new tag reference
+		rtag = TagReference.create(remote_repo, "1.0-RV_hello.there")
+		res = fetch_and_test(remote, tags=True)
+		tinfo = res[str(rtag)]
+		assert isinstance(tinfo.ref, TagReference) and tinfo.ref.commit == rtag.commit
+		assert tinfo.flags & tinfo.NEW_TAG
+		
+		# adjust tag commit
+		Reference.set_object(rtag, rhead.commit.parents[0].parents[0])
+		res = fetch_and_test(remote, tags=True)
+		tinfo = res[str(rtag)]
+		assert tinfo.commit == rtag.commit
+		assert tinfo.flags & tinfo.TAG_UPDATE
+		
+		# delete remote tag - local one will stay
+		TagReference.delete(remote_repo, rtag)
+		res = fetch_and_test(remote, tags=True)
+		self.failUnlessRaises(IndexError, get_info, res, remote, str(rtag))
+		
+		# provoke to receive actual objects to see what kind of output we have to 
+		# expect. For that we need a remote transport protocol
+		# Create a new UN-shared repo and fetch into it after we pushed a change
+		# to the shared repo
+		other_repo_dir = tempfile.mktemp("other_repo")
+		# must clone with a local path for the repo implementation not to freak out
+		# as it wants local paths only ( which I can understand )
+		other_repo = remote_repo.clone(other_repo_dir, shared=False)
+		remote_repo_url = "git://localhost%s"%remote_repo.git_dir
+		
+		# put origin to git-url
+		other_origin = other_repo.remotes.origin 
+		other_origin.config_writer.set("url", remote_repo_url)
+		# it automatically creates alternates as remote_repo is shared as well.
+		# It will use the transport though and ignore alternates when fetching
+		# assert not other_repo.alternates	# this would fail
+		
+		# assure we are in the right state
+		rw_repo.head.reset(remote.refs.master, working_tree=True)
+		try:
+			self._commit_random_file(rw_repo)
+			remote.push(rw_repo.head.reference)
+			
+			# here I would expect to see remote-information about packing 
+			# objects and so on. Unfortunately, this does not happen 
+			# if we are redirecting the output - git explicitly checks for this
+			# and only provides progress information to ttys
+			res = fetch_and_test(other_origin)
+		finally:
+			shutil.rmtree(other_repo_dir)
+		# END test and cleanup
+		
+	def _test_push_and_pull(self,remote, rw_repo, remote_repo):
+		# push our changes
+		lhead = rw_repo.head
+		lindex = rw_repo.index
+		# assure we are on master and it is checked out where the remote is
+		try:
+			lhead.reference = rw_repo.heads.master
+		except AttributeError:
+			# if the author is on a non-master branch, the clones might not have 
+			# a local master yet. We simply create it
+			lhead.reference = rw_repo.create_head('master')
+		# END master handling 
+		lhead.reset(remote.refs.master, working_tree=True)
+		
+		# push without spec should fail ( without further configuration )
+		# well, works nicely
+		# self.failUnlessRaises(GitCommandError, remote.push)
+		
+		# simple file push
+		self._commit_random_file(rw_repo)
+		progress = TestRemoteProgress()
+		res = remote.push(lhead.reference, progress)
+		assert isinstance(res, IterableList)
+		self._do_test_push_result(res, remote)
+		progress.make_assertion()
+		
+		# rejected - undo last commit
+		lhead.reset("HEAD~1")
+		res = remote.push(lhead.reference)
+		assert res[0].flags & PushInfo.ERROR 
+		assert res[0].flags & PushInfo.REJECTED
+		self._do_test_push_result(res, remote)
+		
+		# force rejected pull
+		res = remote.push('+%s' % lhead.reference)
+		assert res[0].flags & PushInfo.ERROR == 0 
+		assert res[0].flags & PushInfo.FORCED_UPDATE
+		self._do_test_push_result(res, remote)
+		
+		# invalid refspec
+		res = remote.push("hellothere")
+		assert len(res) == 0
+		
+		# push new tags 
+		progress = TestRemoteProgress()
+		to_be_updated = "my_tag.1.0RV"
+		new_tag = TagReference.create(rw_repo, to_be_updated)
+		other_tag = TagReference.create(rw_repo, "my_obj_tag.2.1aRV", message="my message")
+		res = remote.push(progress=progress, tags=True)
+		assert res[-1].flags & PushInfo.NEW_TAG
+		progress.make_assertion()
+		self._do_test_push_result(res, remote)
+		
+		# update push new tags
+		# Rejection is default
+		new_tag = TagReference.create(rw_repo, to_be_updated, ref='HEAD~1', force=True)
+		res = remote.push(tags=True)
+		self._do_test_push_result(res, remote)
+		assert res[-1].flags & PushInfo.REJECTED and res[-1].flags & PushInfo.ERROR
+		
+		# push force this tag
+		res = remote.push("+%s" % new_tag.path)
+		assert res[-1].flags & PushInfo.ERROR == 0 and res[-1].flags & PushInfo.FORCED_UPDATE
+		
+		# delete tag - have to do it using refspec
+		res = remote.push(":%s" % new_tag.path)
+		self._do_test_push_result(res, remote)
+		assert res[0].flags & PushInfo.DELETED
+		# Currently progress is not properly transferred, especially not using 
+		# the git daemon
+		# progress.assert_received_message()
+		
+		# push new branch
+		new_head = Head.create(rw_repo, "my_new_branch")
+		progress = TestRemoteProgress()
+		res = remote.push(new_head, progress)
+		assert res[0].flags & PushInfo.NEW_HEAD
+		progress.make_assertion()
+		self._do_test_push_result(res, remote)
+		
+		# delete new branch on the remote end and locally
+		res = remote.push(":%s" % new_head.path)
+		self._do_test_push_result(res, remote)
+		Head.delete(rw_repo, new_head)
+		assert res[-1].flags & PushInfo.DELETED
+		
+		# --all
+		res = remote.push(all=True)
+		self._do_test_push_result(res, remote)
+		
+		remote.pull('master')
+		
+		# cleanup - delete created tags and branches as we are in an innerloop on 
+		# the same repository
+		TagReference.delete(rw_repo, new_tag, other_tag)
+		remote.push(":%s" % other_tag.path)
+	
+	@with_rw_and_rw_remote_repo('0.1.6')
+	def test_base(self, rw_repo, remote_repo):
+		num_remotes = 0
+		remote_set = set()
+		ran_fetch_test = False
+		
+		for remote in rw_repo.remotes:
+			num_remotes += 1
+			assert remote == remote
+			assert str(remote) != repr(remote)
+			remote_set.add(remote)
+			remote_set.add(remote)	# should already exist
+			
+			# REFS 
+			refs = remote.refs
+			assert refs
+			for ref in refs:
+				assert ref.remote_name == remote.name
+				assert ref.remote_head
+			# END for each ref
+			
+			# OPTIONS
+			# cannot use 'fetch' key anymore as it is now a method
+			for opt in ("url", ):
+				val = getattr(remote, opt)
+				reader = remote.config_reader
+				assert reader.get(opt) == val
+				assert reader.get_value(opt, None) == val
+				
+				# unable to write with a reader
+				self.failUnlessRaises(IOError, reader.set, opt, "test")
+				
+				# change value
+				writer = remote.config_writer
+				new_val = "myval"
+				writer.set(opt, new_val)
+				assert writer.get(opt) == new_val
+				writer.set(opt, val)
+				assert writer.get(opt) == val
+				del(writer)
+				assert getattr(remote, opt) == val
+			# END for each default option key 
+			
+			# RENAME 
+			other_name = "totally_other_name"
+			prev_name = remote.name
+			assert remote.rename(other_name) == remote
+			assert prev_name != remote.name
+			# multiple times
+			for time in range(2):
+				assert remote.rename(prev_name).name == prev_name
+			# END for each rename ( back to prev_name )
+			
+			# PUSH/PULL TESTING
+			self._test_push_and_pull(remote, rw_repo, remote_repo)
+			
+			# FETCH TESTING
+			# Only for remotes - local cases are the same or less complicated 
+			# as additional progress information will never be emitted
+			if remote.name == "daemon_origin":
+				self._do_test_fetch(remote, rw_repo, remote_repo)
+				ran_fetch_test = True
+			# END fetch test  
+			
+			remote.update()
+		# END for each remote
+		
+		assert ran_fetch_test
+		assert num_remotes
+		assert num_remotes == len(remote_set)
+		
+		origin = rw_repo.remote('origin')
+		assert origin == rw_repo.remotes.origin
+		
+	@with_rw_repo('HEAD', bare=True)
+	def test_creation_and_removal(self, bare_rw_repo):
+		new_name = "test_new_one"
+		arg_list = (new_name, "git@server:hello.git")
+		remote = Remote.create(bare_rw_repo, *arg_list )
+		assert remote.name == "test_new_one"
+		assert remote in bare_rw_repo.remotes
+		
+		# create same one again
+		self.failUnlessRaises(GitCommandError, Remote.create, bare_rw_repo, *arg_list)
+		
+		Remote.remove(bare_rw_repo, new_name)
+		
+		for remote in bare_rw_repo.remotes:
+			if remote.name == new_name:
+				raise AssertionError("Remote removal failed")
+			# END if deleted remote matches existing remote's name
+		# END for each remote
+		
+		
+	
diff --git a/git/util.py b/git/util.py
index 1ef1fca1..6009e158 100644
--- a/git/util.py
+++ b/git/util.py
@@ -17,7 +17,7 @@ import tempfile
 __all__ = ( "stream_copy", "join_path", "to_native_path_windows", "to_native_path_linux", 
 			"join_path_native", "Stats", "IndexFileSHA1Writer", "Iterable", "IterableList", 
 			"BlockingLockFile", "LockFile", 'Actor', 'get_user_id', 'assure_directory_exists',
-			'RemoteProgress', 'RepoAliasMixin', 'LockedFD', 'LazyMixin' )
+			'RepoAliasMixin', 'LockedFD', 'LazyMixin' )
 
 from cStringIO import StringIO
 
@@ -754,132 +754,6 @@ class IterableList(list):
 
 #{ Classes
 
-class RemoteProgress(object):
-	"""
-	Handler providing an interface to parse progress information emitted by git-push
-	and git-fetch and to dispatch callbacks allowing subclasses to react to the progress.
-	"""
-	_num_op_codes = 5
-	BEGIN, END, COUNTING, COMPRESSING, WRITING =  [1 << x for x in range(_num_op_codes)]
-	STAGE_MASK = BEGIN|END
-	OP_MASK = ~STAGE_MASK
-	
-	__slots__ = ("_cur_line", "_seen_ops")
-	re_op_absolute = re.compile("(remote: )?([\w\s]+):\s+()(\d+)()(.*)")
-	re_op_relative = re.compile("(remote: )?([\w\s]+):\s+(\d+)% \((\d+)/(\d+)\)(.*)")
-	
-	def __init__(self):
-		self._seen_ops = list()
-	
-	def _parse_progress_line(self, line):
-		"""Parse progress information from the given line as retrieved by git-push
-		or git-fetch
-		
-		:return: list(line, ...) list of lines that could not be processed"""
-		# handle
-		# Counting objects: 4, done. 
-		# Compressing objects:	50% (1/2)	\rCompressing objects: 100% (2/2)	\rCompressing objects: 100% (2/2), done.
-		self._cur_line = line
-		sub_lines = line.split('\r')
-		failed_lines = list()
-		for sline in sub_lines:
-			# find esacpe characters and cut them away - regex will not work with 
-			# them as they are non-ascii. As git might expect a tty, it will send them
-			last_valid_index = None
-			for i,c in enumerate(reversed(sline)):
-				if ord(c) < 32:
-					# its a slice index
-					last_valid_index = -i-1 
-				# END character was non-ascii
-			# END for each character in sline
-			if last_valid_index is not None:
-				sline = sline[:last_valid_index]
-			# END cut away invalid part
-			sline = sline.rstrip()
-			
-			cur_count, max_count = None, None
-			match = self.re_op_relative.match(sline)
-			if match is None:
-				match = self.re_op_absolute.match(sline)
-				
-			if not match:
-				self.line_dropped(sline)
-				failed_lines.append(sline)
-				continue
-			# END could not get match
-			
-			op_code = 0
-			remote, op_name, percent, cur_count, max_count, message = match.groups()
-			
-			# get operation id
-			if op_name == "Counting objects":
-				op_code |= self.COUNTING
-			elif op_name == "Compressing objects":
-				op_code |= self.COMPRESSING
-			elif op_name == "Writing objects":
-				op_code |= self.WRITING
-			else:
-				raise ValueError("Operation name %r unknown" % op_name)
-			
-			# figure out stage
-			if op_code not in self._seen_ops:
-				self._seen_ops.append(op_code)
-				op_code |= self.BEGIN
-			# END begin opcode
-			
-			if message is None:
-				message = ''
-			# END message handling
-			
-			message = message.strip()
-			done_token = ', done.'
-			if message.endswith(done_token):
-				op_code |= self.END
-				message = message[:-len(done_token)]
-			# END end message handling
-			
-			self.update(op_code, cur_count, max_count, message)
-			self(message)
-		# END for each sub line
-		return failed_lines
-	
-	def line_dropped(self, line):
-		"""Called whenever a line could not be understood and was therefore dropped."""
-		pass
-	
-	def update(self, op_code, cur_count, max_count=None, message=''):
-		"""Called whenever the progress changes
-		
-		:param op_code:
-			Integer allowing to be compared against Operation IDs and stage IDs.
-			
-			Stage IDs are BEGIN and END. BEGIN will only be set once for each Operation 
-			ID as well as END. It may be that BEGIN and END are set at once in case only
-			one progress message was emitted due to the speed of the operation.
-			Between BEGIN and END, none of these flags will be set
-			
-			Operation IDs are all held within the OP_MASK. Only one Operation ID will 
-			be active per call.
-		:param cur_count: Current absolute count of items
-			
-		:param max_count:
-			The maximum count of items we expect. It may be None in case there is 
-			no maximum number of items or if it is (yet) unknown.
-		
-		:param message:
-			In case of the 'WRITING' operation, it contains the amount of bytes
-			transferred. It may possibly be used for other purposes as well.
-		
-		You may read the contents of the current line in self._cur_line"""
-		pass
-	
-	def __call__(self, message):
-		"""Same as update, but with a simpler interface which only provides the
-		message of the operation
-		:note: This method will be called in addition to the update method. It is 
-			up to you which one you implement"""
-		pass
-
 class RepoAliasMixin(object):
 	"""Simple utility providing a repo-property which resolves to the 'odb' attribute
 	of the actual type. This is for api compatability only, as the types previously