Removed all parts of the reference implementation which doesn't require the git command. everything else was moved to GitDB. None of the tests is yet expected to run, although git-python should have less trouble getting the tests back up running than GitDB. plenty of code needs to be de-duplicated though in case of the tests, which will be some work

13 files changed, 86 insertions, 1473 deletions

diff --git a/doc/source/changes.rst b/doc/source/changes.rst
index 58700907..f6151968 100644
--- a/doc/source/changes.rst
+++ b/doc/source/changes.rst
@@ -5,7 +5,8 @@ Changelog
 NEXT
 ====
 * ### Interface Changes ###
- * None yet
+ * SymbolicReference
+  * object_binsha property added
 * Blob Type
  * Added mode constants to ease the manual creation of blobs
 
diff --git a/git/db.py b/git/db.py
index 1e04f073..5ec7148e 100644
--- a/git/db.py
+++ b/git/db.py
@@ -50,11 +50,11 @@ class PushInfo(GitdbPushInfo):
 		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 # commit at which the remote_ref was standing before we pushed
+		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', '_remote', 'summary')
+	__slots__ = ('local_ref', 'remote_ref_string', 'flags', 'old_commit_binsha', '_remote', 'summary')
 	
 	_flag_map = {	'X' : GitdbPushInfo.NO_MATCH, 
 					'-' : GitdbPushInfo.DELETED, '*' : 0,
@@ -63,14 +63,14 @@ class PushInfo(GitdbPushInfo):
 					'=' : GitdbPushInfo.UP_TO_DATE, 
 					'!' : GitdbPushInfo.ERROR }
 	
-	def __init__(self, flags, local_ref, remote_ref_string, remote, old_commit=None, 
+	def __init__(self, flags, local_ref, remote_ref_string, remote, old_commit_binsha=None, 
 					summary=''):
 		""" Initialize a new instance """
 		self.flags = flags
 		self.local_ref = local_ref
 		self.remote_ref_string = remote_ref_string
 		self._remote = remote
-		self.old_commit = old_commit
+		self.old_commit_binsha = old_commit_binsha
 		self.summary = summary
 		
 	@property
@@ -111,7 +111,7 @@ class PushInfo(GitdbPushInfo):
 			from_ref = Reference.from_path(remote.repo, from_ref_string)
 		
 		# commit handling, could be message or commit info
-		old_commit = None
+		old_commit_binsha = None
 		if summary.startswith('['):
 			if "[rejected]" in summary:
 				flags |= cls.REJECTED
@@ -134,10 +134,10 @@ class PushInfo(GitdbPushInfo):
 				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 = remote.repo.commit(old_sha)
+			old_commit_binsha = remote.repo.commit(old_sha)
 		# END message handling
 		
-		return PushInfo(flags, from_ref, to_ref_string, remote, old_commit, summary)
+		return PushInfo(flags, from_ref, to_ref_string, remote, old_commit_binsha, summary)
 		
 
 class FetchInfo(GitdbFetchInfo):
@@ -151,10 +151,10 @@ class FetchInfo(GitdbFetchInfo):
 						# 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	# if info.flags & info.FORCED_UPDATE|info.FAST_FORWARD, 
+	 info.old_commit_binsha	# if info.flags & info.FORCED_UPDATE|info.FAST_FORWARD, 
 						# field is set to the previous location of ref, otherwise None
 	"""
-	__slots__ = ('ref','old_commit', 'flags', 'note')
+	__slots__ = ('ref','old_commit_binsha', 'flags', 'note')
 	
 	#							  %c	%-*s %-*s			  -> %s		  (%s)
 	re_fetch_result = re.compile("^\s*(.) (\[?[\w\s\.]+\]?)\s+(.+) -> ([/\w_\+\.-]+)(	 \(.*\)?$)?")
@@ -166,14 +166,14 @@ class FetchInfo(GitdbFetchInfo):
 					'=' : GitdbFetchInfo.HEAD_UPTODATE, 
 					' ' : GitdbFetchInfo.FAST_FORWARD } 
 	
-	def __init__(self, ref, flags, note = '', old_commit = None):
+	def __init__(self, ref, flags, note = '', old_commit_binsha = None):
 		"""
 		Initialize a new instance
 		"""
 		self.ref = ref
 		self.flags = flags
 		self.note = note
-		self.old_commit = old_commit
+		self.old_commit_binsha = old_commit_binsha
 		
 	def __str__(self):
 		return self.name
@@ -250,7 +250,7 @@ class FetchInfo(GitdbFetchInfo):
 		# END control char exception hanlding 
 		
 		# parse operation string for more info - makes no sense for symbolic refs
-		old_commit = None
+		old_commit_binsha = None
 		if isinstance(remote_local_ref, Reference):
 			if 'rejected' in operation:
 				flags |= cls.REJECTED
@@ -262,11 +262,11 @@ class FetchInfo(GitdbFetchInfo):
 				split_token = '...'
 				if control_character == ' ':
 					split_token = split_token[:-1]
-				old_commit = repo.rev_parse(operation.split(split_token)[0])
+				old_commit_binsha = repo.rev_parse(operation.split(split_token)[0])
 			# END handle refspec
 		# END reference flag handling
 		
-		return cls(remote_local_ref, flags, note, old_commit)
+		return cls(remote_local_ref, flags, note, old_commit_binsha)
 		
 
 class GitCmdObjectDB(LooseObjectDB, TransportDBMixin):
diff --git a/git/ext/gitdb b/git/ext/gitdb
-Subproject 86388c55fb7852ce9c8a2db9ee45ca2b3a126f6
+Subproject 7c4d3d6b000930134019515c83c10b140330d31
diff --git a/git/refs/__init__.py b/git/refs/__init__.py
index fc8ce644..2130a087 100644
--- a/git/refs/__init__.py
+++ b/git/refs/__init__.py
@@ -8,13 +8,13 @@ from remote import *
 
 # name fixes
 import head
-head.RemoteReference = RemoteReference
+head.Head.RemoteReferenceCls = RemoteReference
 del(head)
 
 
 import symbolic
-for item in (HEAD, Head, RemoteReference, TagReference, Reference, SymbolicReference):
-	setattr(symbolic, item.__name__, item)
+for item in (HEAD, Head, RemoteReference, TagReference, Reference):
+	setattr(symbolic.SymbolicReference, item.__name__+'Cls', item)
 del(symbolic)
 
 
diff --git a/git/refs/head.py b/git/refs/head.py
index d8729434..dec03551 100644
--- a/git/refs/head.py
+++ b/git/refs/head.py
@@ -1,33 +1,15 @@
-from symbolic import SymbolicReference
-from reference import Reference
-
-from git.config import SectionConstraint
-
-from git.util import join_path
 
+from gitdb.ref.head import HEAD as GitDB_HEAD
+from gitdb.ref.head import Head as GitDB_Head
 from git.exc import GitCommandError
+from git.util import RepoAliasMixin
 
 __all__ = ["HEAD", "Head"]
 
-
 	
-class HEAD(SymbolicReference):
-	"""Special case of a Symbolic Reference as it represents the repository's 
-	HEAD reference."""
-	_HEAD_NAME = 'HEAD'
-	_ORIG_HEAD_NAME = 'ORIG_HEAD'
+class HEAD(GitDB_HEAD, RepoAliasMixin):
+	"""Provides additional functionality using the git command"""
 	__slots__ = tuple()
-	
-	def __init__(self, repo, path=_HEAD_NAME):
-		if path != self._HEAD_NAME:
-			raise ValueError("HEAD instance must point to %r, got %r" % (self._HEAD_NAME, path))
-		super(HEAD, self).__init__(repo, path)
-	
-	def orig_head(self):
-		"""
-		:return: SymbolicReference pointing at the ORIG_HEAD, which is maintained 
-			to contain the previous value of HEAD"""
-		return SymbolicReference(self.repo, self._ORIG_HEAD_NAME)
 		
 	def reset(self, commit='HEAD', index=True, working_tree = False, 
 				paths=None, **kwargs):
@@ -91,8 +73,10 @@ class HEAD(SymbolicReference):
 		return self
 	
 
-class Head(Reference):
-	"""A Head is a named reference to a Commit. Every Head instance contains a name
+class Head(GitDB_Head, RepoAliasMixin):
+	"""The GitPyhton Head implementation provides more git-command based features
+	
+	A Head is a named reference to a Commit. Every Head instance contains a name
 	and a Commit object.
 
 	Examples::
@@ -108,6 +92,8 @@ class Head(Reference):
 
 		>>> head.commit.hexsha
 		'1c09f116cbc2cb4100fb6935bb162daa4723f455'"""
+	__slots__ = tuple()
+	
 	_common_path_default = "refs/heads"
 	k_config_remote = "remote"
 	k_config_remote_ref = "merge"			# branch to merge from remote
@@ -125,47 +111,7 @@ class Head(Reference):
 			flag = "-D"
 		repo.git.branch(flag, *heads)
 		
-	def set_tracking_branch(self, remote_reference):
-		"""
-		Configure this branch to track the given remote reference. This will alter
-			this branch's configuration accordingly.
-		
-		:param remote_reference: The remote reference to track or None to untrack 
-			any references
-		:return: self"""
-		if remote_reference is not None and not isinstance(remote_reference, RemoteReference):
-			raise ValueError("Incorrect parameter type: %r" % remote_reference)
-		# END handle type
-		
-		writer = self.config_writer()
-		if remote_reference is None:
-			writer.remove_option(self.k_config_remote)
-			writer.remove_option(self.k_config_remote_ref)
-			if len(writer.options()) == 0:
-				writer.remove_section()
-			# END handle remove section
-		else:
-			writer.set_value(self.k_config_remote, remote_reference.remote_name)
-			writer.set_value(self.k_config_remote_ref, Head.to_full_path(remote_reference.remote_head))
-		# END handle ref value
-		
-		return self
-		
 		
-	def tracking_branch(self):
-		"""
-		:return: The remote_reference we are tracking, or None if we are 
-			not a tracking branch"""
-		reader = self.config_reader()
-		if reader.has_option(self.k_config_remote) and reader.has_option(self.k_config_remote_ref):
-			ref = Head(self.repo, Head.to_full_path(reader.get_value(self.k_config_remote_ref)))
-			remote_refpath = RemoteReference.to_full_path(join_path(reader.get_value(self.k_config_remote), ref.name))
-			return RemoteReference(self.repo, remote_refpath)
-		# END handle have tracking branch
-		
-		# we are not a tracking branch
-		return None
-	
 	def rename(self, new_path, force=False):
 		"""Rename self to a new path
 		
@@ -217,30 +163,4 @@ class Head(Reference):
 		
 		self.repo.git.checkout(self, **kwargs)
 		return self.repo.active_branch
-		
-	#{ Configruation
-	
-	def _config_parser(self, read_only):
-		if read_only:
-			parser = self.repo.config_reader()
-		else:
-			parser = self.repo.config_writer()
-		# END handle parser instance
-		
-		return SectionConstraint(parser, 'branch "%s"' % self.name)
-	
-	def config_reader(self):
-		"""
-		:return: A configuration parser instance constrained to only read 
-			this instance's values"""
-		return self._config_parser(read_only=True)
-		
-	def config_writer(self):
-		"""
-		:return: A configuration writer instance with read-and write acccess
-			to options of this head"""
-		return self._config_parser(read_only=False)
-	
-	#} END configuration
-		
 
diff --git a/git/refs/log.py b/git/refs/log.py
index f49c07fd..c67c0714 100644
--- a/git/refs/log.py
+++ b/git/refs/log.py
@@ -1,282 +1,6 @@
-from git.util import (
-						join_path,
-						Actor,
-						LockedFD,
-						LockFile,
-						assure_directory_exists,
-						to_native_path,
-					)
-
-from gitdb.util import (
-						bin_to_hex,
-						join,
-						file_contents_ro_filepath,
-					)
-
-from git.objects.util import (
-								parse_date,
-								Serializable, 
-								utctz_to_altz,
-								altz_to_utctz_str,
-							)
-
-import time
-import os
-import re
-
+from gitdb.ref.log import (
+							RefLog,
+							RefLogEntry
+						)
 __all__ = ["RefLog", "RefLogEntry"]
 
-
-class RefLogEntry(tuple):
-	"""Named tuple allowing easy access to the revlog data fields"""
-	_fmt = "%s %s %s <%s> %i %s\t%s\n"
-	_re_hexsha_only = re.compile('^[0-9A-Fa-f]{40}$')
-	__slots__ = tuple()
-	
-	def __repr__(self):
-		"""Representation of ourselves in git reflog format"""
-		act = self.actor
-		time = self.time
-		return self._fmt % (self.oldhexsha, self.newhexsha, act.name, act.email, 
-							time[0], altz_to_utctz_str(time[1]), self.message)
-	
-	@property
-	def oldhexsha(self):
-		"""The hexsha to the commit the ref pointed to before the change""" 
-		return self[0]
-		
-	@property
-	def newhexsha(self):
-		"""The hexsha to the commit the ref now points to, after the change"""
-		return self[1]
-		
-	@property
-	def actor(self):
-		"""Actor instance, providing access"""
-		return self[2]
-		
-	@property
-	def time(self):
-		"""time as tuple:
-		
-		* [0] = int(time)
-		* [1] = int(timezone_offset) in time.altzone format """
-		return self[3]
-		
-	@property
-	def message(self):
-		"""Message describing the operation that acted on the reference"""
-		return self[4]
-	
-	@classmethod
-	def new(self, oldhexsha, newhexsha, actor, time, tz_offset, message):
-		""":return: New instance of a RefLogEntry"""
-		if not isinstance(actor, Actor):
-			raise ValueError("Need actor instance, got %s" % actor)
-		# END check types 
-		return RefLogEntry((oldhexsha, newhexsha, actor, (time, tz_offset), message))
-		
-	@classmethod
-	def from_line(cls, line):
-		""":return: New RefLogEntry instance from the given revlog line.
-		:param line: line without trailing newline
-		:raise ValueError: If line could not be parsed"""
-		try:
-			info, msg = line.split('\t', 2)
-		except ValueError:
-			raise ValueError("line is missing tab separator")
-		#END handle first plit
-		oldhexsha = info[:40]
-		newhexsha = info[41:81]
-		for hexsha in (oldhexsha, newhexsha):
-			if not cls._re_hexsha_only.match(hexsha):
-				raise ValueError("Invalid hexsha: %s" % hexsha)
-			# END if hexsha re doesn't match
-		#END for each hexsha
-		
-		email_end = info.find('>', 82)
-		if email_end == -1:
-			raise ValueError("Missing token: >")
-		#END handle missing end brace
-		
-		actor = Actor._from_string(info[82:email_end+1])
-		time, tz_offset = parse_date(info[email_end+2:])
-		
-		return RefLogEntry((oldhexsha, newhexsha, actor, (time, tz_offset), msg))
-		
-
-class RefLog(list, Serializable):
-	"""A reflog contains reflog entries, each of which defines a certain state
-	of the head in question. Custom query methods allow to retrieve log entries 
-	by date or by other criteria.
-	
-	Reflog entries are orded, the first added entry is first in the list, the last
-	entry, i.e. the last change of the head or reference, is last in the list."""
-	
-	__slots__ = ('_path', )
-	
-	def __new__(cls, filepath=None):
-		inst = super(RefLog, cls).__new__(cls)
-		return inst
-		
-	def __init__(self, filepath=None):
-		"""Initialize this instance with an optional filepath, from which we will
-		initialize our data. The path is also used to write changes back using 
-		the write() method"""
-		self._path = filepath
-		if filepath is not None:
-			self._read_from_file()
-		# END handle filepath
-	
-	def _read_from_file(self):
-		fmap = file_contents_ro_filepath(self._path, stream=False, allow_mmap=True)
-		try:
-			self._deserialize(fmap)
-		finally:
-			fmap.close()
-		#END handle closing of handle
-	
-	#{ Interface
-	
-	@classmethod
-	def from_file(cls, filepath):
-		"""
-		:return: a new RefLog instance containing all entries from the reflog 
-			at the given filepath
-		:param filepath: path to reflog 
-		:raise ValueError: If the file could not be read or was corrupted in some way"""
-		return cls(filepath)
-	
-	@classmethod
-	def path(cls, ref):
-		"""
-		:return: string to absolute path at which the reflog of the given ref 
-			instance would be found. The path is not guaranteed to point to a valid 
-			file though.
-		:param ref: SymbolicReference instance"""
-		return join(ref.repo.git_dir, "logs", to_native_path(ref.path))
-		
-	@classmethod
-	def iter_entries(cls, stream):
-		"""
-		:return: Iterator yielding RefLogEntry instances, one for each line read 
-			sfrom the given stream.
-		:param stream: file-like object containing the revlog in its native format
-			or basestring instance pointing to a file to read"""
-		new_entry = RefLogEntry.from_line
-		if isinstance(stream, basestring):
-			stream = file_contents_ro_filepath(stream)
-		#END handle stream type
-		while True:
-			line = stream.readline()
-			if not line:
-				return
-			yield new_entry(line.strip())
-		#END endless loop
-		
-	@classmethod
-	def entry_at(cls, filepath, index):
-		""":return: RefLogEntry at the given index
-		:param filepath: full path to the index file from which to read the entry
-		:param index: python list compatible index, i.e. it may be negative to 
-			specifiy an entry counted from the end of the list
-			
-		:raise IndexError: If the entry didn't exist
-		
-		.. note:: This method is faster as it only parses the entry at index, skipping
-			all other lines. Nonetheless, the whole file has to be read if 
-			the index is negative
-		"""
-		fp = open(filepath, 'rb')
-		if index < 0:
-			return RefLogEntry.from_line(fp.readlines()[index].strip())
-		else:
-			# read until index is reached
-			for i in xrange(index+1):
-				line = fp.readline()
-				if not line:
-					break
-				#END abort on eof
-			#END handle runup
-			
-			if i != index or not line:
-				raise IndexError
-			#END handle exception
-			
-			return RefLogEntry.from_line(line.strip())
-		#END handle index
-	
-	def to_file(self, filepath):
-		"""Write the contents of the reflog instance to a file at the given filepath.
-		:param filepath: path to file, parent directories are assumed to exist"""
-		lfd = LockedFD(filepath)
-		assure_directory_exists(filepath, is_file=True)
-		
-		fp = lfd.open(write=True, stream=True)
-		try:
-			self._serialize(fp)
-			lfd.commit()
-		except:
-			# on failure it rolls back automatically, but we make it clear
-			lfd.rollback()
-			raise
-		#END handle change
-		
-	@classmethod
-	def append_entry(cls, config_reader, filepath, oldbinsha, newbinsha, message):
-		"""Append a new log entry to the revlog at filepath.
-		
-		:param config_reader: configuration reader of the repository - used to obtain
-			user information. May be None
-		:param filepath: full path to the log file
-		:param oldbinsha: binary sha of the previous commit
-		:param newbinsha: binary sha of the current commit
-		:param message: message describing the change to the reference
-		:param write: If True, the changes will be written right away. Otherwise
-			the change will not be written
-		:return: RefLogEntry objects which was appended to the log
-		:note: As we are append-only, concurrent access is not a problem as we 
-			do not interfere with readers."""
-		if len(oldbinsha) != 20 or len(newbinsha) != 20:
-			raise ValueError("Shas need to be given in binary format")
-		#END handle sha type
-		assure_directory_exists(filepath, is_file=True)
-		entry = RefLogEntry((bin_to_hex(oldbinsha), bin_to_hex(newbinsha), Actor.committer(config_reader), (int(time.time()), time.altzone), message))
-		
-		lf = LockFile(filepath)
-		lf._obtain_lock_or_raise()
-		
-		fd = open(filepath, 'a')
-		try:
-			fd.write(repr(entry))
-		finally:
-			fd.close()
-			lf._release_lock()
-		#END handle write operation
-		
-		return entry
-		
-	def write(self):
-		"""Write this instance's data to the file we are originating from
-		:return: self"""
-		if self._path is None:
-			raise ValueError("Instance was not initialized with a path, use to_file(...) instead")
-		#END assert path
-		self.to_file(self._path)
-		return self
-	
-	#} END interface
-	
-	#{ Serializable Interface
-	def _serialize(self, stream):
-		lm1 = len(self) - 1
-		write = stream.write
-		
-		# write all entries
-		for e in self:
-			write(repr(e))
-		#END for each entry
-	
-	def _deserialize(self, stream):
-		self.extend(self.iter_entries(stream))
-	#} END serializable interface
diff --git a/git/refs/reference.py b/git/refs/reference.py
index 1a745ee9..135277e6 100644
--- a/git/refs/reference.py
+++ b/git/refs/reference.py
@@ -1,84 +1,8 @@
-from symbolic import SymbolicReference
-import os
-from git.objects import Object
-from git.util import (
-					LazyMixin, 
-					Iterable, 
-					)
-
-from gitdb.util import (
-							isfile,
-							hex_to_bin
-						)
 
+from gitdb.ref.reference import Reference as GitDB_Reference
+from git.util import RepoAliasMixin
 __all__ = ["Reference"]
 
-
-class Reference(SymbolicReference, LazyMixin, Iterable):
-	"""Represents a named reference to any object. Subclasses may apply restrictions though, 
-	i.e. Heads can only point to commits."""
+class Reference(GitDB_Reference, RepoAliasMixin):
 	__slots__ = tuple()
-	_points_to_commits_only = False
-	_resolve_ref_on_create = True
-	_common_path_default = "refs"
-	
-	def __init__(self, repo, path):
-		"""Initialize this instance
-		:param repo: Our parent repository
-		
-		:param path:
-			Path relative to the .git/ directory pointing to the ref in question, i.e.
-			refs/heads/master"""
-		if not path.startswith(self._common_path_default+'/'):
-			raise ValueError("Cannot instantiate %r from path %s" % ( self.__class__.__name__, path ))
-		super(Reference, self).__init__(repo, path)
-		
-
-	def __str__(self):
-		return self.name
-
-	def set_object(self, object, logmsg = None):
-		"""Special version which checks if the head-log needs an update as well"""
-		oldbinsha = None
-		if logmsg is not None:
-			head = self.repo.head
-			if not head.is_detached and head.ref == self:
-				oldbinsha = self.commit.binsha
-			#END handle commit retrieval
-		#END handle message is set
-		
-		super(Reference, self).set_object(object, logmsg)
-		
-		if oldbinsha is not None:
-			# /* from refs.c in git-source
-			# * Special hack: If a branch is updated directly and HEAD
-			# * points to it (may happen on the remote side of a push
-			# * for example) then logically the HEAD reflog should be
-			# * updated too.
-			# * A generic solution implies reverse symref information,
-			# * but finding all symrefs pointing to the given branch
-			# * would be rather costly for this rare event (the direct
-			# * update of a branch) to be worth it.  So let's cheat and
-			# * check with HEAD only which should cover 99% of all usage
-			# * scenarios (even 100% of the default ones).
-			# */
-			self.repo.head.log_append(oldbinsha, logmsg)
-		#END check if the head
-
-	# NOTE: Don't have to overwrite properties as the will only work without a the log
-
-	@property
-	def name(self):
-		""":return: (shortest) Name of this reference - it may contain path components"""
-		# first two path tokens are can be removed as they are 
-		# refs/heads or refs/tags or refs/remotes
-		tokens = self.path.split('/')
-		if len(tokens) < 3:
-			return self.path		   # could be refs/HEAD
-		return '/'.join(tokens[2:])
-	
-	@classmethod
-	def iter_items(cls, repo, common_path = None):
-		"""Equivalent to SymbolicReference.iter_items, but will return non-detached
-		references as well."""
-		return cls._iter_items(repo, common_path)
+	pass
diff --git a/git/refs/remote.py b/git/refs/remote.py
index b7b07d4b..ae6f626d 100644
--- a/git/refs/remote.py
+++ b/git/refs/remote.py
@@ -1,46 +1,15 @@
-from head import Head
-from git.util import join_path
-from gitdb.util import join
-
 import os
-
+from gitdb.ref.remote import RemoteReference as GitDB_RemoteReference
+from git.util import RepoAliasMixin
 
 __all__ = ["RemoteReference"]
 
 	
-class RemoteReference(Head):
+class RemoteReference(GitDB_RemoteReference, RepoAliasMixin):
 	"""Represents a reference pointing to a remote head."""
-	_common_path_default = "refs/remotes"
-	
+	__slots__ = tuple()
 	
 	@classmethod
-	def iter_items(cls, repo, common_path = None, remote=None):
-		"""Iterate remote references, and if given, constrain them to the given remote"""
-		common_path = common_path or cls._common_path_default
-		if remote is not None:
-			common_path = join_path(common_path, str(remote))
-		# END handle remote constraint
-		return super(RemoteReference, cls).iter_items(repo, common_path)
-	
-	@property
-	def remote_name(self):
-		"""
-		:return:
-			Name of the remote we are a reference of, such as 'origin' for a reference
-			named 'origin/master'"""
-		tokens = self.path.split('/')
-		# /refs/remotes/<remote name>/<branch_name>
-		return tokens[2]
-		
-	@property
-	def remote_head(self):
-		""":return: Name of the remote head itself, i.e. master.
-		:note: The returned name is usually not qualified enough to uniquely identify
-			a branch"""
-		tokens = self.path.split('/')
-		return '/'.join(tokens[3:])
-		
-	@classmethod
 	def delete(cls, repo, *refs, **kwargs):
 		"""Delete the given remote references.
 		:note:
@@ -56,8 +25,3 @@ class RemoteReference(Head):
 			except OSError:
 				pass
 		# END for each ref
-		
-	@classmethod
-	def create(cls, *args, **kwargs):
-		"""Used to disable this method"""
-		raise TypeError("Cannot explicitly create remote references")
diff --git a/git/refs/symbolic.py b/git/refs/symbolic.py
index aec68750..9232c49c 100644
--- a/git/refs/symbolic.py
+++ b/git/refs/symbolic.py
@@ -1,619 +1,7 @@
-import os
-from git.objects import Object, Commit
-from git.util import (
-					join_path, 
-					join_path_native, 
-					to_native_path_linux,
-					assure_directory_exists
-					)
-
-from gitdb.exc import BadObject
-from gitdb.util import (
-							join, 
-							dirname,
-							isdir,
-							exists,
-							isfile,
-							rename,
-							hex_to_bin,
-							LockedFD
-						)
-
-from log import RefLog
-
+from gitdb.ref.symbolic import SymbolicReference as GitDB_SymbolicReference
+from git.util import RepoAliasMixin
 __all__ = ["SymbolicReference"]
 
-class SymbolicReference(object):
-	"""Represents a special case of a reference such that this reference is symbolic.
-	It does not point to a specific commit, but to another Head, which itself 
-	specifies a commit.
-	
-	A typical example for a symbolic reference is HEAD."""
-	__slots__ = ("repo", "path")
-	_resolve_ref_on_create = False
-	_points_to_commits_only = True
-	_common_path_default = ""
-	_id_attribute_ = "name"
-	
-	def __init__(self, repo, path):
-		self.repo = repo
-		self.path = path
-		
-	def __str__(self):
-		return self.path
-		
-	def __repr__(self):
-		return '<git.%s "%s">' % (self.__class__.__name__, self.path)
-		
-	def __eq__(self, other):
-		return self.path == other.path
-		
-	def __ne__(self, other):
-		return not ( self == other )
-		
-	def __hash__(self):
-		return hash(self.path)
-		
-	@property
-	def name(self):
-		"""
-		:return:
-			In case of symbolic references, the shortest assumable name 
-			is the path itself."""
-		return self.path
-	
-	@property
-	def abspath(self):
-		return join_path_native(self.repo.git_dir, self.path)
-		
-	@classmethod
-	def _get_packed_refs_path(cls, repo):
-		return join(repo.git_dir, 'packed-refs')
-		
-	@classmethod
-	def _iter_packed_refs(cls, repo):
-		"""Returns an iterator yielding pairs of sha1/path pairs for the corresponding refs.
-		:note: The packed refs file will be kept open as long as we iterate"""
-		try:
-			fp = open(cls._get_packed_refs_path(repo), 'r')
-			for line in fp:
-				line = line.strip()
-				if not line:
-					continue
-				if line.startswith('#'):
-					if line.startswith('# pack-refs with:') and not line.endswith('peeled'):
-						raise TypeError("PackingType of packed-Refs not understood: %r" % line)
-					# END abort if we do not understand the packing scheme
-					continue
-				# END parse comment
-				
-				# skip dereferenced tag object entries - previous line was actual
-				# tag reference for it
-				if line[0] == '^':
-					continue
-				
-				yield tuple(line.split(' ', 1))
-			# END for each line
-		except (OSError,IOError):
-			raise StopIteration
-		# END no packed-refs file handling 
-		# NOTE: Had try-finally block around here to close the fp, 
-		# but some python version woudn't allow yields within that.
-		# I believe files are closing themselves on destruction, so it is 
-		# alright.
-		
-	@classmethod
-	def dereference_recursive(cls, repo, ref_path):
-		"""
-		:return: hexsha stored in the reference at the given ref_path, recursively dereferencing all
-			intermediate references as required
-		:param repo: the repository containing the reference at ref_path"""
-		while True:
-			hexsha, ref_path = cls._get_ref_info(repo, ref_path)
-			if hexsha is not None:
-				return hexsha
-		# END recursive dereferencing
-		
-	@classmethod
-	def _get_ref_info(cls, repo, ref_path):
-		"""Return: (sha, target_ref_path) if available, the sha the file at 
-		rela_path points to, or None. target_ref_path is the reference we 
-		point to, or None"""
-		tokens = None
-		try:
-			fp = open(join(repo.git_dir, ref_path), 'r')
-			value = fp.read().rstrip()
-			fp.close()
-			tokens = value.split(" ")
-		except (OSError,IOError):
-			# Probably we are just packed, find our entry in the packed refs file
-			# NOTE: We are not a symbolic ref if we are in a packed file, as these
-			# are excluded explictly
-			for sha, path in cls._iter_packed_refs(repo):
-				if path != ref_path: continue
-				tokens = (sha, path)
-				break
-			# END for each packed ref
-		# END handle packed refs
-		if tokens is None:
-			raise ValueError("Reference at %r does not exist" % ref_path)
-		
-		# is it a reference ?
-		if tokens[0] == 'ref:':
-			return (None, tokens[1])
-			
-		# its a commit
-		if repo.re_hexsha_only.match(tokens[0]):
-			return (tokens[0], None)
-			
-		raise ValueError("Failed to parse reference information from %r" % ref_path)
-	
-	def _get_object(self):
-		"""
-		:return:
-			The object our ref currently refers to. Refs can be cached, they will 
-			always point to the actual object as it gets re-created on each query"""
-		# have to be dynamic here as we may be a tag which can point to anything
-		# Our path will be resolved to the hexsha which will be used accordingly
-		return Object.new_from_sha(self.repo, hex_to_bin(self.dereference_recursive(self.repo, self.path)))
-	
-	def _get_commit(self):
-		"""
-		:return:
-			Commit object we point to, works for detached and non-detached 
-			SymbolicReferences. The symbolic reference will be dereferenced recursively."""
-		obj = self._get_object()
-		if obj.type == 'tag':
-			obj = obj.object
-		#END dereference tag
-		
-		if obj.type != Commit.type:
-			raise TypeError("Symbolic Reference pointed to object %r, commit was required" % obj)
-		#END handle type
-		return obj
-		
-	def set_commit(self, commit, logmsg = None):
-		"""As set_object, but restricts the type of object to be a Commit
-		
-		:raise ValueError: If commit is not a Commit object or doesn't point to 
-			a commit
-		:return: self"""
-		# check the type - assume the best if it is a base-string
-		invalid_type = False
-		if isinstance(commit, Object):
-			invalid_type = commit.type != Commit.type
-		elif isinstance(commit, SymbolicReference):
-			invalid_type = commit.object.type != Commit.type
-		else:
-			try:
-				invalid_type = self.repo.rev_parse(commit).type != Commit.type
-			except BadObject:
-				raise ValueError("Invalid object: %s" % commit)
-			#END handle exception
-		# END verify type
-		
-		if invalid_type:
-			raise ValueError("Need commit, got %r" % commit)
-		#END handle raise
-		
-		# we leave strings to the rev-parse method below
-		self.set_object(commit, logmsg)
-		
-		return self
-		
-	
-	def set_object(self, object, logmsg = None):
-		"""Set the object we point to, possibly dereference our symbolic reference first.
-		If the reference does not exist, it will be created
-		
-		:param object: a refspec, a SymbolicReference or an Object instance. SymbolicReferences
-			will be dereferenced beforehand to obtain the object they point to
-		:param logmsg: If not None, the message will be used in the reflog entry to be 
-			written. Otherwise the reflog is not altered
-		:note: plain SymbolicReferences may not actually point to objects by convention
-		:return: self"""
-		if isinstance(object, SymbolicReference):
-			object = object.object
-		#END resolve references
-		
-		is_detached = True
-		try:
-			is_detached = self.is_detached
-		except ValueError:
-			pass
-		# END handle non-existing ones
-		
-		if is_detached:
-			return self.set_reference(object, logmsg)
-			
-		# set the commit on our reference
-		return self._get_reference().set_object(object, logmsg)
-	
-	commit = property(_get_commit, set_commit, doc="Query or set commits directly")
-	object = property(_get_object, set_object, doc="Return the object our ref currently refers to")
-		
-	def _get_reference(self):
-		""":return: Reference Object we point to
-		:raise TypeError: If this symbolic reference is detached, hence it doesn't point
-			to a reference, but to a commit"""
-		sha, target_ref_path = self._get_ref_info(self.repo, self.path)
-		if target_ref_path is None:
-			raise TypeError("%s is a detached symbolic reference as it points to %r" % (self, sha))
-		return self.from_path(self.repo, target_ref_path)
-		
-	def set_reference(self, ref, logmsg = None):
-		"""Set ourselves to the given ref. It will stay a symbol if the ref is a Reference.
-		Otherwise an Object, given as Object instance or refspec, is assumed and if valid, 
-		will be set which effectively detaches the refererence if it was a purely 
-		symbolic one.
-		
-		:param ref: SymbolicReference instance, Object instance or refspec string
-			Only if the ref is a SymbolicRef instance, we will point to it. Everthiny
-			else is dereferenced to obtain the actual object.
-		:param logmsg: If set to a string, the message will be used in the reflog.
-			Otherwise, a reflog entry is not written for the changed reference.
-			The previous commit of the entry will be the commit we point to now.
-			
-			See also: log_append()
-		
-		:return: self
-		:note: This symbolic reference will not be dereferenced. For that, see 
-			``set_object(...)``"""
-		write_value = None
-		obj = None
-		if isinstance(ref, SymbolicReference):
-			write_value = "ref: %s" % ref.path
-		elif isinstance(ref, Object):
-			obj = ref
-			write_value = ref.hexsha
-		elif isinstance(ref, basestring):
-			try:
-				obj = self.repo.rev_parse(ref+"^{}")	# optionally deref tags
-				write_value = obj.hexsha
-			except BadObject:
-				raise ValueError("Could not extract object from %s" % ref)
-			# END end try string
-		else:
-			raise ValueError("Unrecognized Value: %r" % ref)
-		# END try commit attribute
-		
-		# typecheck
-		if obj is not None and self._points_to_commits_only and obj.type != Commit.type:
-			raise TypeError("Require commit, got %r" % obj)
-		#END verify type
-		
-		oldbinsha = None
-		if logmsg is not None:
-			try:
-				oldbinsha = self.commit.binsha
-			except ValueError:
-				oldbinsha = Commit.NULL_BIN_SHA
-			#END handle non-existing
-		#END retrieve old hexsha
-		
-		fpath = self.abspath
-		assure_directory_exists(fpath, is_file=True)
-		
-		lfd = LockedFD(fpath)
-		fd = lfd.open(write=True, stream=True)
-		fd.write(write_value)
-		lfd.commit()
-		
-		# Adjust the reflog
-		if logmsg is not None:
-			self.log_append(oldbinsha, logmsg)
-		#END handle reflog
-		
-		return self
-		
-
-	# aliased reference
-	reference = property(_get_reference, set_reference, doc="Returns the Reference we point to")
-	ref = reference
-	
-	def is_valid(self):
-		"""
-		:return:
-			True if the reference is valid, hence it can be read and points to 
-			a valid object or reference."""
-		try:
-			self.object
-		except (OSError, ValueError):
-			return False
-		else:
-			return True
-		
-	@property
-	def is_detached(self):
-		"""
-		:return:
-			True if we are a detached reference, hence we point to a specific commit
-			instead to another reference"""
-		try:
-			self.ref
-			return False
-		except TypeError:
-			return True
-	
-	def log(self):
-		"""
-		:return: RefLog for this reference. Its last entry reflects the latest change
-			applied to this reference
-			
-		.. note:: As the log is parsed every time, its recommended to cache it for use
-			instead of calling this method repeatedly. It should be considered read-only."""
-		return RefLog.from_file(RefLog.path(self))
-		
-	def log_append(self, oldbinsha, message, newbinsha=None):
-		"""Append a logentry to the logfile of this ref
-		
-		:param oldbinsha: binary sha this ref used to point to
-		:param message: A message describing the change
-		:param newbinsha: The sha the ref points to now. If None, our current commit sha
-			will be used
-		:return: added RefLogEntry instance"""
-		return RefLog.append_entry(self.repo.config_reader(), RefLog.path(self), oldbinsha, 
-									(newbinsha is None and self.commit.binsha) or newbinsha, 
-									message) 
-
-	def log_entry(self, index):
-		""":return: RefLogEntry at the given index
-		:param index: python list compatible positive or negative index
-		
-		.. note:: This method must read part of the reflog during execution, hence 
-			it should be used sparringly, or only if you need just one index.
-			In that case, it will be faster than the ``log()`` method"""
-		return RefLog.entry_at(RefLog.path(self), index)
-
-	@classmethod
-	def to_full_path(cls, path):
-		"""
-		:return: string with a full repository-relative path which can be used to initialize 
-			a Reference instance, for instance by using ``Reference.from_path``"""
-		if isinstance(path, SymbolicReference):
-			path = path.path
-		full_ref_path = path
-		if not cls._common_path_default:
-			return full_ref_path
-		if not path.startswith(cls._common_path_default+"/"):
-			full_ref_path = '%s/%s' % (cls._common_path_default, path)
-		return full_ref_path
-	
-	@classmethod
-	def delete(cls, repo, path):
-		"""Delete the reference at the given path
-		
-		:param repo:
-			Repository to delete the reference from
-		
-		:param path:
-			Short or full path pointing to the reference, i.e. refs/myreference
-			or just "myreference", hence 'refs/' is implied.
-			Alternatively the symbolic reference to be deleted"""
-		full_ref_path = cls.to_full_path(path)
-		abs_path = join(repo.git_dir, full_ref_path)
-		if exists(abs_path):
-			os.remove(abs_path)
-		else:
-			# check packed refs
-			pack_file_path = cls._get_packed_refs_path(repo)
-			try:
-				reader = open(pack_file_path)
-			except (OSError,IOError):
-				pass # it didnt exist at all
-			else:
-				new_lines = list()
-				made_change = False
-				dropped_last_line = False
-				for line in reader:
-					# keep line if it is a comment or if the ref to delete is not 
-					# in the line
-					# If we deleted the last line and this one is a tag-reference object, 
-					# we drop it as well
-					if ( line.startswith('#') or full_ref_path not in line ) and \
-						( not dropped_last_line or dropped_last_line and not line.startswith('^') ):
-						new_lines.append(line)
-						dropped_last_line = False
-						continue
-					# END skip comments and lines without our path
-					
-					# drop this line
-					made_change = True
-					dropped_last_line = True
-				# END for each line in packed refs
-				reader.close()
-				
-				# write the new lines
-				if made_change:
-					open(pack_file_path, 'w').writelines(new_lines)
-			# END open exception handling
-		# END handle deletion
-		
-		# delete the reflog
-		reflog_path = RefLog.path(cls(repo, full_ref_path))
-		if os.path.isfile(reflog_path):
-			os.remove(reflog_path)
-		#END remove reflog
-		
-			
-	@classmethod
-	def _create(cls, repo, path, resolve, reference, force, logmsg=None):
-		"""internal method used to create a new symbolic reference.
-		If resolve is False, the reference will be taken as is, creating 
-		a proper symbolic reference. Otherwise it will be resolved to the 
-		corresponding object and a detached symbolic reference will be created
-		instead"""
-		full_ref_path = cls.to_full_path(path)
-		abs_ref_path = join(repo.git_dir, full_ref_path)
-		
-		# figure out target data
-		target = reference
-		if resolve:
-			target = repo.rev_parse(str(reference))
-			
-		if not force and isfile(abs_ref_path):
-			target_data = str(target)
-			if isinstance(target, SymbolicReference):
-				target_data = target.path
-			if not resolve:
-				target_data = "ref: " + target_data
-			existing_data = open(abs_ref_path, 'rb').read().strip() 
-			if existing_data != target_data:
-				raise OSError("Reference at %r does already exist, pointing to %r, requested was %r" % (full_ref_path, existing_data, target_data))
-		# END no force handling
-		
-		ref = cls(repo, full_ref_path)
-		ref.set_reference(target, logmsg)
-		return ref
-		
-	@classmethod
-	def create(cls, repo, path, reference='HEAD', force=False, logmsg=None):
-		"""Create a new symbolic reference, hence a reference pointing to another reference.
-		
-		:param repo:
-			Repository to create the reference in 
-			
-		:param path:
-			full path at which the new symbolic reference is supposed to be 
-			created at, i.e. "NEW_HEAD" or "symrefs/my_new_symref"
-			
-		:param reference:
-			The reference to which the new symbolic reference should point to.
-			If it is a commit'ish, the symbolic ref will be detached.
-		
-		:param force:
-			if True, force creation even if a symbolic reference with that name already exists.
-			Raise OSError otherwise
-			
-		:param logmsg:
-			If not None, the message to append to the reflog. Otherwise no reflog
-			entry is written.
-			
-		:return: Newly created symbolic Reference
-			
-		:raise OSError:
-			If a (Symbolic)Reference with the same name but different contents
-			already exists.
-		
-		:note: This does not alter the current HEAD, index or Working Tree"""
-		return cls._create(repo, path, cls._resolve_ref_on_create, reference, force, logmsg)
-	
-	def rename(self, new_path, force=False):
-		"""Rename self to a new path
-		
-		:param new_path:
-			Either a simple name or a full path, i.e. new_name or features/new_name.
-			The prefix refs/ is implied for references and will be set as needed.
-			In case this is a symbolic ref, there is no implied prefix
-			
-		:param force:
-			If True, the rename will succeed even if a head with the target name
-			already exists. It will be overwritten in that case
-			
-		:return: self
-		:raise OSError: In case a file at path but a different contents already exists """
-		new_path = self.to_full_path(new_path)
-		if self.path == new_path:
-			return self
-		
-		new_abs_path = join(self.repo.git_dir, new_path)
-		cur_abs_path = join(self.repo.git_dir, self.path)
-		if isfile(new_abs_path):
-			if not force:
-				# if they point to the same file, its not an error
-				if open(new_abs_path,'rb').read().strip() != open(cur_abs_path,'rb').read().strip():
-					raise OSError("File at path %r already exists" % new_abs_path)
-				# else: we could remove ourselves and use the otherone, but 
-				# but clarity we just continue as usual
-			# END not force handling
-			os.remove(new_abs_path)
-		# END handle existing target file
-		
-		dname = dirname(new_abs_path)
-		if not isdir(dname):
-			os.makedirs(dname)
-		# END create directory
-		
-		rename(cur_abs_path, new_abs_path)
-		self.path = new_path
-		
-		return self
-		
-	@classmethod
-	def _iter_items(cls, repo, common_path = None):
-		if common_path is None:
-			common_path = cls._common_path_default
-		rela_paths = set()
-		
-		# walk loose refs
-		# Currently we do not follow links 
-		for root, dirs, files in os.walk(join_path_native(repo.git_dir, common_path)):
-			if 'refs/' not in root: # skip non-refs subfolders
-				refs_id = [ i for i,d in enumerate(dirs) if d == 'refs' ]
-				if refs_id:
-					dirs[0:] = ['refs']
-			# END prune non-refs folders
-			
-			for f in files:
-				abs_path = to_native_path_linux(join_path(root, f))
-				rela_paths.add(abs_path.replace(to_native_path_linux(repo.git_dir) + '/', ""))
-			# END for each file in root directory
-		# END for each directory to walk
-		
-		# read packed refs
-		for sha, rela_path in cls._iter_packed_refs(repo):
-			if rela_path.startswith(common_path):
-				rela_paths.add(rela_path)
-			# END relative path matches common path
-		# END packed refs reading
-		
-		# return paths in sorted order
-		for path in sorted(rela_paths):
-			try:
-				yield cls.from_path(repo, path)
-			except ValueError:
-				continue
-		# END for each sorted relative refpath
-		
-	@classmethod
-	def iter_items(cls, repo, common_path = None):
-		"""Find all refs in the repository
-
-		:param repo: is the Repo
-
-		:param common_path:
-			Optional keyword argument to the path which is to be shared by all
-			returned Ref objects.
-			Defaults to class specific portion if None assuring that only 
-			refs suitable for the actual class are returned.
-
-		:return:
-			git.SymbolicReference[], each of them is guaranteed to be a symbolic
-			ref which is not detached.
-			
-			List is lexigraphically sorted
-			The returned objects represent actual subclasses, such as Head or TagReference"""
-		return ( r for r in cls._iter_items(repo, common_path) if r.__class__ == SymbolicReference or not r.is_detached )
-		
-	@classmethod
-	def from_path(cls, repo, path):
-		"""
-		:param path: full .git-directory-relative path name to the Reference to instantiate
-		:note: use to_full_path() if you only have a partial path of a known Reference Type
-		:return:
-			Instance of type Reference, Head, or Tag
-			depending on the given path"""
-		if not path:
-			raise ValueError("Cannot create Reference from %r" % path)
-		
-		for ref_type in (HEAD, Head, RemoteReference, TagReference, Reference, SymbolicReference):
-			try:
-				instance = ref_type(repo, path)
-				if instance.__class__ == SymbolicReference and instance.is_detached:
-					raise ValueError("SymbolRef was detached, we drop it")
-				return instance
-			except ValueError:
-				pass
-			# END exception handling
-		# END for each type to try
-		raise ValueError("Could not find reference type suitable to handle path %r" % path)
+class SymbolicReference(GitDB_SymbolicReference, RepoAliasMixin):
+	__slots__ = tuple()
+	pass
diff --git a/git/refs/tag.py b/git/refs/tag.py
index c09d814d..8ba9ba84 100644
--- a/git/refs/tag.py
+++ b/git/refs/tag.py
@@ -1,51 +1,11 @@
-from reference import Reference
+from gitdb.ref.tag import TagReference as GitDB_TagReference
+from git.util import RepoAliasMixin
 
 __all__ = ["TagReference", "Tag"]
 
-
-	
-class TagReference(Reference):
-	"""Class representing a lightweight tag reference which either points to a commit 
-	,a tag object or any other object. In the latter case additional information, 
-	like the signature or the tag-creator, is available.
-	
-	This tag object will always point to a commit object, but may carray additional
-	information in a tag object::
-	
-	 tagref = TagReference.list_items(repo)[0]
-	 print tagref.commit.message
-	 if tagref.tag is not None:
-		print tagref.tag.message"""
-	
+class TagReference(GitDB_TagReference, GitDB_TagReference):
 	__slots__ = tuple()
-	_common_path_default = "refs/tags"
 	
-	@property
-	def commit(self):
-		""":return: Commit object the tag ref points to"""
-		obj = self.object
-		if obj.type == "commit":
-			return obj
-		elif obj.type == "tag":
-			# it is a tag object which carries the commit as an object - we can point to anything
-			return obj.object
-		else:
-			raise ValueError( "Tag %s points to a Blob or Tree - have never seen that before" % self )	
-
-	@property
-	def tag(self):
-		"""
-		:return: Tag object this tag ref points to or None in case 
-			we are a light weight tag"""
-		obj = self.object
-		if obj.type == "tag":
-			return obj
-		return None
-		
-	# make object read-only
-	# It should be reasonably hard to adjust an existing tag
-	object = property(Reference._get_object)
-		
 	@classmethod
 	def create(cls, repo, path, ref='HEAD', message=None, force=False, **kwargs):
 		"""Create a new tag reference.
@@ -85,7 +45,5 @@ class TagReference(Reference):
 		"""Delete the given existing tag or tags"""
 		repo.git.tag("-d", *tags)
 		
-		
-		
 # provide an alias
 Tag = TagReference
diff --git a/git/remote.py b/git/remote.py
index ae61dc72..6f295869 100644
--- a/git/remote.py
+++ b/git/remote.py
@@ -23,6 +23,18 @@ import os
 
 __all__ = ('RemoteProgress', 'Remote')
 
+class PushInfo(object):
+	"""Wrapper for basic PushInfo to provide the previous interface which includes
+	resolved objects instead of plain shas
+	
+	old_commit	# object for the corresponding old_commit_sha"""
+	
+	
+	
+class FetchInfo(object):
+	"""Wrapper to restore the previous interface, resolving objects and wrapping 
+	references"""
+
 
 class Remote(LazyMixin, Iterable):
 	"""Provides easy read and write access to a git remote.
diff --git a/git/test/lib/helper.py b/git/test/lib/helper.py
index 76aaaa38..ad30d4c4 100644
--- a/git/test/lib/helper.py
+++ b/git/test/lib/helper.py
@@ -12,6 +12,8 @@ import tempfile
 import shutil
 import cStringIO
 
+from gitdb.test.lib import maketemp 
+
 GIT_REPO = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
 
 __all__ = (
@@ -52,13 +54,6 @@ class StringProcessAdapter(object):
 
 #{ Decorators 
 
-def _mktemp(*args):
-	"""Wrapper around default tempfile.mktemp to fix an osx issue"""
-	tdir = tempfile.mktemp(*args)
-	if sys.platform == 'darwin':
-		tdir = '/private' + tdir
-	return tdir
-
 def _rmtree_onerror(osremove, fullpath, exec_info):
 	"""
 	Handle the case on windows that read-only files cannot be deleted by 
@@ -87,7 +82,7 @@ def with_rw_repo(working_tree_ref, bare=False):
 			if bare:
 				prefix = ''
 			#END handle prefix
-			repo_dir = _mktemp("%sbare_%s" % (prefix, func.__name__))
+			repo_dir = maketemp("%sbare_%s" % (prefix, func.__name__))
 			rw_repo = self.rorepo.clone(repo_dir, shared=True, bare=bare, n=True)
 			
 			rw_repo.head.commit = rw_repo.commit(working_tree_ref)
@@ -143,8 +138,8 @@ def with_rw_and_rw_remote_repo(working_tree_ref):
 	assert isinstance(working_tree_ref, basestring), "Decorator requires ref name for working tree checkout"
 	def argument_passer(func):
 		def remote_repo_creator(self):
-			remote_repo_dir = _mktemp("remote_repo_%s" % func.__name__)
-			repo_dir = _mktemp("remote_clone_non_bare_repo")
+			remote_repo_dir = maketemp("remote_repo_%s" % func.__name__)
+			repo_dir = maketemp("remote_clone_non_bare_repo")
 			
 			rw_remote_repo = self.rorepo.clone(remote_repo_dir, shared=True, bare=True)
 			rw_repo = rw_remote_repo.clone(repo_dir, shared=True, bare=False, n=True)		# recursive alternates info ?
diff --git a/git/util.py b/git/util.py
index b979e147..ec1ece1e 100644
--- a/git/util.py
+++ b/git/util.py
@@ -17,13 +17,22 @@ from gitdb.util import (
 							file_contents_ro, 
 							LazyMixin, 
 							to_hex_sha, 
-							to_bin_sha
+							to_bin_sha,
+							join_path, 
+							join_path_native,
+							to_native_path_linux,
+							to_native_path_windows,
+							assure_directory_exists,
+							LockFile,
+							BlockingLockFile,
+							Actor,
+							Iterable
 						)
 
 __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')
+			'RemoteProgress', 'RepoAliasMixin')
 
 #{ Utility Methods
 
@@ -41,54 +50,7 @@ def stream_copy(source, destination, chunk_size=512*1024):
 			break
 	# END reading output stream
 	return br
-
-def join_path(a, *p):
-	"""Join path tokens together similar to os.path.join, but always use 
-	'/' instead of possibly '\' on windows."""
-	path = a
-	for b in p:
-		if b.startswith('/'):
-			path += b[1:]
-		elif path == '' or path.endswith('/'):
-			path +=	 b
-		else:
-			path += '/' + b
-	return path
-	
-def to_native_path_windows(path):
-	return path.replace('/','\\')
-	
-def to_native_path_linux(path):
-	return path.replace('\\','/')
-
-if sys.platform.startswith('win'):
-	to_native_path = to_native_path_windows
-else:
-	# no need for any work on linux
-	def to_native_path_linux(path):
-		return path
-	to_native_path = to_native_path_linux
-
-def join_path_native(a, *p):
-	"""
-	As join path, but makes sure an OS native path is returned. This is only 
-		needed to play it safe on my dear windows and to assure nice paths that only 
-		use '\'"""
-	return to_native_path(join_path(a, *p))
 	
-def assure_directory_exists(path, is_file=False):
-	"""Assure that the directory pointed to by path exists.
-	
-	:param is_file: If True, path is assumed to be a file and handled correctly.
-		Otherwise it must be a directory
-	:return: True if the directory was created, False if it already existed"""
-	if is_file:
-		path = os.path.dirname(path)
-	#END handle file 
-	if not os.path.isdir(path):
-		os.makedirs(path)
-		return True
-	return False
 	
 def get_user_id():
 	""":return: string identifying the currently active system user as name@node
@@ -230,107 +192,16 @@ class RemoteProgress(object):
 			up to you which one you implement"""
 		pass
 
-
-class Actor(object):
-	"""Actors hold information about a person acting on the repository. They 
-	can be committers and authors or anything with a name and an email as 
-	mentioned in the git log entries."""
-	# PRECOMPILED REGEX
-	name_only_regex = re.compile( r'<(.+)>' )
-	name_email_regex = re.compile( r'(.*) <(.+?)>' )
-	
-	# ENVIRONMENT VARIABLES
-	# read when creating new commits
-	env_author_name = "GIT_AUTHOR_NAME"
-	env_author_email = "GIT_AUTHOR_EMAIL"
-	env_committer_name = "GIT_COMMITTER_NAME"
-	env_committer_email = "GIT_COMMITTER_EMAIL"
-	
-	# CONFIGURATION KEYS
-	conf_name = 'name'
-	conf_email = 'email'
+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
+	held repository instances, now they hold odb instances instead"""
+	__slots__ = tuple()
 	
-	__slots__ = ('name', 'email')
+	@property
+	def repo(self):
+		return self.odb
 	
-	def __init__(self, name, email):
-		self.name = name
-		self.email = email
-
-	def __eq__(self, other):
-		return self.name == other.name and self.email == other.email
-		
-	def __ne__(self, other):
-		return not (self == other)
-		
-	def __hash__(self):
-		return hash((self.name, self.email))
-
-	def __str__(self):
-		return self.name
-
-	def __repr__(self):
-		return '<git.Actor "%s <%s>">' % (self.name, self.email)
-
-	@classmethod
-	def _from_string(cls, string):
-		"""Create an Actor from a string.
-		:param string: is the string, which is expected to be in regular git format
-
-				John Doe <jdoe@example.com>
-				
-		:return: Actor """
-		m = cls.name_email_regex.search(string)
-		if m:
-			name, email = m.groups()
-			return Actor(name, email)
-		else:
-			m = cls.name_only_regex.search(string)
-			if m:
-				return Actor(m.group(1), None)
-			else:
-				# assume best and use the whole string as name
-				return Actor(string, None)
-			# END special case name
-		# END handle name/email matching
-		
-	@classmethod
-	def _main_actor(cls, env_name, env_email, config_reader=None):
-		actor = Actor('', '')
-		default_email = get_user_id()
-		default_name = default_email.split('@')[0]
-		
-		for attr, evar, cvar, default in (('name', env_name, cls.conf_name, default_name), 
-										('email', env_email, cls.conf_email, default_email)):
-			try:
-				setattr(actor, attr, os.environ[evar])
-			except KeyError:
-				if config_reader is not None:
-					setattr(actor, attr, config_reader.get_value('user', cvar, default))
-				#END config-reader handling
-				if not getattr(actor, attr):
-					setattr(actor, attr, default)
-			#END handle name
-		#END for each item to retrieve
-		return actor
-		
-		
-	@classmethod
-	def committer(cls, config_reader=None):
-		"""
-		:return: Actor instance corresponding to the configured committer. It behaves
-			similar to the git implementation, such that the environment will override 
-			configuration values of config_reader. If no value is set at all, it will be
-			generated
-		:param config_reader: ConfigReader to use to retrieve the values from in case
-			they are not set in the environment"""
-		return cls._main_actor(cls.env_committer_name, cls.env_committer_email, config_reader)
-		
-	@classmethod
-	def author(cls, config_reader=None):
-		"""Same as committer(), but defines the main author. It may be specified in the environment, 
-		but defaults to the committer"""
-		return cls._main_actor(cls.env_author_name, cls.env_author_email, config_reader)
-		
 
 class Stats(object):
 	"""
@@ -415,123 +286,6 @@ class IndexFileSHA1Writer(object):
 		return self.f.tell()
 
 
-class LockFile(object):
-	"""Provides methods to obtain, check for, and release a file based lock which 
-	should be used to handle concurrent access to the same file.
-	
-	As we are a utility class to be derived from, we only use protected methods.
-	
-	Locks will automatically be released on destruction"""
-	__slots__ = ("_file_path", "_owns_lock")
-	
-	def __init__(self, file_path):
-		self._file_path = file_path
-		self._owns_lock = False
-	
-	def __del__(self):
-		self._release_lock()
-	
-	def _lock_file_path(self):
-		""":return: Path to lockfile"""
-		return "%s.lock" % (self._file_path)
-	
-	def _has_lock(self):
-		""":return: True if we have a lock and if the lockfile still exists
-		:raise AssertionError: if our lock-file does not exist"""
-		if not self._owns_lock:
-			return False
-		
-		return True
-		
-	def _obtain_lock_or_raise(self):
-		"""Create a lock file as flag for other instances, mark our instance as lock-holder
-		
-		:raise IOError: if a lock was already present or a lock file could not be written"""
-		if self._has_lock():
-			return 
-		lock_file = self._lock_file_path()
-		if os.path.isfile(lock_file):
-			raise IOError("Lock for file %r did already exist, delete %r in case the lock is illegal" % (self._file_path, lock_file))
-			
-		try:
-			fd = os.open(lock_file, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0)
-			os.close(fd)
-		except OSError,e:
-			raise IOError(str(e))
-		
-		self._owns_lock = True
-		
-	def _obtain_lock(self):
-		"""The default implementation will raise if a lock cannot be obtained.
-		Subclasses may override this method to provide a different implementation"""
-		return self._obtain_lock_or_raise()
-		
-	def _release_lock(self):
-		"""Release our lock if we have one"""
-		if not self._has_lock():
-			return
-			
-		# if someone removed our file beforhand, lets just flag this issue
-		# instead of failing, to make it more usable.
-		lfp = self._lock_file_path()
-		try:
-			# on bloody windows, the file needs write permissions to be removable.
-			# Why ... 
-			if os.name == 'nt':
-				os.chmod(lfp, 0777)
-			# END handle win32
-			os.remove(lfp)
-		except OSError:
-			pass
-		self._owns_lock = False
-
-
-class BlockingLockFile(LockFile):
-	"""The lock file will block until a lock could be obtained, or fail after 
-	a specified timeout.
-	
-	:note: If the directory containing the lock was removed, an exception will 
-		be raised during the blocking period, preventing hangs as the lock 
-		can never be obtained."""
-	__slots__ = ("_check_interval", "_max_block_time")
-	def __init__(self, file_path, check_interval_s=0.3, max_block_time_s=sys.maxint):
-		"""Configure the instance
-		
-		:parm check_interval_s:
-			Period of time to sleep until the lock is checked the next time.
-			By default, it waits a nearly unlimited time
-		
-		:parm max_block_time_s: Maximum amount of seconds we may lock"""
-		super(BlockingLockFile, self).__init__(file_path)
-		self._check_interval = check_interval_s
-		self._max_block_time = max_block_time_s
-		
-	def _obtain_lock(self):
-		"""This method blocks until it obtained the lock, or raises IOError if 
-		it ran out of time or if the parent directory was not available anymore.
-		If this method returns, you are guranteed to own the lock"""
-		starttime = time.time()
-		maxtime = starttime + float(self._max_block_time)
-		while True:
-			try:
-				super(BlockingLockFile, self)._obtain_lock()
-			except IOError:
-				# synity check: if the directory leading to the lockfile is not
-				# readable anymore, raise an execption
-				curtime = time.time()
-				if not os.path.isdir(os.path.dirname(self._lock_file_path())):
-					msg = "Directory containing the lockfile %r was not readable anymore after waiting %g seconds" % (self._lock_file_path(), curtime - starttime)
-					raise IOError(msg)
-				# END handle missing directory
-				
-				if curtime >= maxtime:
-					msg = "Waited %g seconds for lock at %r" % ( maxtime - starttime, self._lock_file_path())
-					raise IOError(msg)
-				# END abort if we wait too long
-				time.sleep(self._check_interval)
-			else:
-				break
-		# END endless loop
 	
 
 class IterableList(list):
@@ -579,31 +333,4 @@ class IterableList(list):
 			raise IndexError( "No item found with id %r" % (self._prefix + index) )
 			
 
-class Iterable(object):
-	"""Defines an interface for iterable items which is to assure a uniform 
-	way to retrieve and iterate items within the git repository"""
-	__slots__ = tuple()
-	_id_attribute_ = "attribute that most suitably identifies your instance"
-	
-	@classmethod
-	def list_items(cls, repo, *args, **kwargs):
-		"""
-		Find all items of this type - subclasses can specify args and kwargs differently.
-		If no args are given, subclasses are obliged to return all items if no additional 
-		arguments arg given.
-		
-		:note: Favor the iter_items method as it will
-		
-		:return:list(Item,...) list of item instances"""
-		out_list = IterableList( cls._id_attribute_ )
-		out_list.extend(cls.iter_items(repo, *args, **kwargs))
-		return out_list
-		
-		
-	@classmethod
-	def iter_items(cls, repo, *args, **kwargs):
-		"""For more information about the arguments, see list_items
-		:return:  iterator yielding Items"""
-		raise NotImplementedError("To be implemented by Subclass")
-		
 #} END classes