Merge branch 'gitdbmerger'

1 files changed, 96 insertions, 62 deletions

diff --git a/git/refs/symbolic.py b/git/refs/symbolic.py
index aec68750..ddee3809 100644
--- a/git/refs/symbolic.py
+++ b/git/refs/symbolic.py
@@ -1,24 +1,26 @@
 import os
-from git.objects import Object, Commit
+import re
+
+from git.objects import (
+						Object, 
+						Commit
+						)
 from git.util import (
 					join_path, 
 					join_path_native, 
 					to_native_path_linux,
-					assure_directory_exists
+					assure_directory_exists,
+					join, 
+					dirname,
+					isdir,
+					exists,
+					isfile,
+					rename,
+					hex_to_bin,
+					LockedFD
 					)
 
-from gitdb.exc import BadObject
-from gitdb.util import (
-							join, 
-							dirname,
-							isdir,
-							exists,
-							isfile,
-							rename,
-							hex_to_bin,
-							LockedFD
-						)
-
+from git.exc import BadObject
 from log import RefLog
 
 __all__ = ["SymbolicReference"]
@@ -30,11 +32,27 @@ class SymbolicReference(object):
 	
 	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"
 	
+	re_hexsha_only = re.compile('^[0-9A-Fa-f]{40}$')
+	
+	#{ Configuration
+	# Object class to be used when instantiating objects
+	ObjectCls = Object
+	CommitCls = Commit
+	
+	# all of the following are set by the package initializer
+	HEADCls = None
+	HeadCls = None
+	RemoteReferenceCls = None
+	TagReferenceCls = None
+	ReferenceCls = None
+	#}END configuration
+	
 	def __init__(self, repo, path):
 		self.repo = repo
 		self.path = path
@@ -143,20 +161,53 @@ class SymbolicReference(object):
 			return (None, tokens[1])
 			
 		# its a commit
-		if repo.re_hexsha_only.match(tokens[0]):
+		if cls.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):
+	def _get_object_sha(self):
 		"""
 		:return:
-			The object our ref currently refers to. Refs can be cached, they will 
+			The binary sha to 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"""
+		return hex_to_bin(self.dereference_recursive(self.repo, self.path))
+	
+	def _get_object(self):
+		"""
+		:return:
+			The object our ref currently refers to."""
 		# 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)))
+		return self.ObjectCls.new_from_sha(self.repo, self._get_object_sha())
 	
+	def set_object(self, object_id, 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 reference specifier string, a SymbolicReference or an object hex sha. 
+			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_id, 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_id, logmsg)
+			
+		# set the commit on our reference
+		return self._get_reference().set_object(object_id, logmsg)
+		
 	def _get_commit(self):
 		"""
 		:return:
@@ -167,7 +218,7 @@ class SymbolicReference(object):
 			obj = obj.object
 		#END dereference tag
 		
-		if obj.type != Commit.type:
+		if obj.type != self.CommitCls.type:
 			raise TypeError("Symbolic Reference pointed to object %r, commit was required" % obj)
 		#END handle type
 		return obj
@@ -179,20 +230,20 @@ class SymbolicReference(object):
 			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
+		is_invalid_type = False
+		if isinstance(commit, self.ObjectCls):
+			is_invalid_type = commit.type != self.CommitCls.type
 		elif isinstance(commit, SymbolicReference):
-			invalid_type = commit.object.type != Commit.type
+			is_invalid_type = commit.object.type != self.CommitCls.type
 		else:
 			try:
-				invalid_type = self.repo.rev_parse(commit).type != Commit.type
+				is_invalid_type = self.repo.resolve_object(commit).type != self.CommitCls.type
 			except BadObject:
 				raise ValueError("Invalid object: %s" % commit)
 			#END handle exception
 		# END verify type
 		
-		if invalid_type:
+		if is_invalid_type:
 			raise ValueError("Need commit, got %r" % commit)
 		#END handle raise
 		
@@ -202,35 +253,9 @@ class SymbolicReference(object):
 		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")
+	object_binsha = property(_get_object_sha, set_object, doc="Return the object our ref currently refers to")
 		
 	def _get_reference(self):
 		""":return: Reference Object we point to
@@ -247,7 +272,7 @@ class SymbolicReference(object):
 		will be set which effectively detaches the refererence if it was a purely 
 		symbolic one.
 		
-		:param ref: SymbolicReference instance, Object instance or refspec string
+		:param ref: SymbolicReference instance, hexadecimal sha string 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.
@@ -263,12 +288,12 @@ class SymbolicReference(object):
 		obj = None
 		if isinstance(ref, SymbolicReference):
 			write_value = "ref: %s" % ref.path
-		elif isinstance(ref, Object):
+		elif isinstance(ref, self.ObjectCls):
 			obj = ref
 			write_value = ref.hexsha
 		elif isinstance(ref, basestring):
 			try:
-				obj = self.repo.rev_parse(ref+"^{}")	# optionally deref tags
+				obj = self.repo.resolve_object(ref+"^{}")	# optionally deref tags
 				write_value = obj.hexsha
 			except BadObject:
 				raise ValueError("Could not extract object from %s" % ref)
@@ -318,7 +343,7 @@ class SymbolicReference(object):
 			a valid object or reference."""
 		try:
 			self.object
-		except (OSError, ValueError):
+		except (OSError, ValueError, BadObject):
 			return False
 		else:
 			return True
@@ -449,7 +474,16 @@ class SymbolicReference(object):
 		# figure out target data
 		target = reference
 		if resolve:
-			target = repo.rev_parse(str(reference))
+			# could just use the resolve method, but it could be expensive
+			# so we handle most common cases ourselves
+			if isinstance(reference, cls.ObjectCls):
+				target = reference.hexsha
+			elif isinstance(reference, SymbolicReference):
+				target = reference.object.hexsha
+			else:
+				target = repo.resolve_object(str(reference))
+			#END handle resoltion
+		#END need resolution
 			
 		if not force and isfile(abs_ref_path):
 			target_data = str(target)
@@ -579,7 +613,7 @@ class SymbolicReference(object):
 	def iter_items(cls, repo, common_path = None):
 		"""Find all refs in the repository
 
-		:param repo: is the Repo
+		:param repo: is the repo
 
 		:param common_path:
 			Optional keyword argument to the path which is to be shared by all
@@ -588,12 +622,12 @@ class SymbolicReference(object):
 			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.
+			git.SymbolicReference[], each of them is guaranteed to be a *only* a symbolic
+			ref, or a derived class 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 )
+		return ( r for r in cls._iter_items(repo, common_path) if r.__class__ == cls or not r.is_detached )
 		
 	@classmethod
 	def from_path(cls, repo, path):
@@ -606,7 +640,7 @@ class SymbolicReference(object):
 		if not path:
 			raise ValueError("Cannot create Reference from %r" % path)
 		
-		for ref_type in (HEAD, Head, RemoteReference, TagReference, Reference, SymbolicReference):
+		for ref_type in (cls.HEADCls, cls.HeadCls, cls.RemoteReferenceCls, cls.TagReferenceCls, cls.ReferenceCls, cls):
 			try:
 				instance = ref_type(repo, path)
 				if instance.__class__ == SymbolicReference and instance.is_detached: