Fixed reference tests - symbolic refs now need to be created with a git_dir() providing repository. Currently there is no separate interface for this, which might have to be added at some point just for the sake of completeness

Author: Byron

doc/source/changes.rst

@@ -2,6 +2,13 @@
 Changelog
 #########
 
+****
+NEXT
+****
+* Added interface to allow transporting git data: **TransportDBMixin**
+* Added interface to allow reference resolution: **RefParseMixin**
+* Added implementation of git datbase with support for transportation and reference resolution: **RefGitDB**
+
 *****
 0.5.2
 *****

gitdb/db/base.py

@@ -411,7 +411,10 @@ class TransportDBMixin(object):
 	nothing to send, the pack will be empty.
 	
 	The communication itself if implemented using a protocol instance which deals
-	with the actual formatting of the lines sent."""
+	with the actual formatting of the lines sent.
+	
+	As refspecs involve symbolic names for references to be handled, we require
+	RefParse functionality. How this is done is up to the actual implementation."""
 	# The following variables need to be set by the derived class
 	#{Configuration
 	protocol = None
@@ -456,3 +459,13 @@ def push(self, url, refspecs, progress=None, **kwargs):
 	#}end interface
 
 
+class RefParseMixin(object):
+	"""Interface allowing to resolve symbolic names or partial hexadecimal shas into
+	actual binary shas. The actual feature set depends on the implementation though, 
+	but should follow git-rev-parse."""
+	
+	def resolve(self, name):
+		"""Resolve the given name into a binary sha. Valid names are as defined 
+		in the rev-parse documentation http://www.kernel.org/pub/software/scm/git/docs/git-rev-parse.html"""
+		raise NotImplementedError()
+		

gitdb/db/git.py

@@ -12,20 +12,28 @@
 from pack import PackedDB
 from ref import ReferenceDB
 
-from gitdb.util import LazyMixin
+from gitdb.util import (
+						LazyMixin, 
+						normpath,
+						join,
+						dirname
+					)
 from gitdb.exc import (
 						InvalidDBRoot, 
 						BadObject, 
 						AmbiguousObjectName
 						)
 import os
 
-__all__ = ('GitDB', )
+__all__ = ('GitDB', 'RefGitDB')
 
 
 class GitDB(FileDBBase, ObjectDBW, CompoundDB):
 	"""A git-style object database, which contains all objects in the 'objects'
-	subdirectory"""
+	subdirectory.
+	:note: The type needs to be initialized on the ./objects directory to function, 
+		as it deals solely with object lookup. Use a RefGitDB type if you need
+		reference and push support."""
 	# Configuration
 	PackDBCls = PackedDB
 	LooseDBCls = LooseObjectDB
@@ -37,7 +45,7 @@ class GitDB(FileDBBase, ObjectDBW, CompoundDB):
 	alternates_dir = os.path.join('info', 'alternates')
 
 	def __init__(self, root_path):
-		"""Initialize ourselves on a git objects directory"""
+		"""Initialize ourselves on a git ./objects directory"""
 		super(GitDB, self).__init__(root_path)
 
 	def _set_cache_(self, attr):
@@ -83,3 +91,33 @@ def set_ostream(self, ostream):
 
 	#} END objectdbw interface
 
+	
+class RefGitDB(GitDB):
+	"""Git like database with support for object lookup as well as reference resolution.
+	Our rootpath is set to the actual .git directory (bare on unbare).
+	
+	The root_path will be the git objects directory. Use git_dir() to obtain the actual top-level 
+	git directory."""
+	#directories
+	objs_dir = 'objects'
+	__slots__  = "_git_dir"	# slots has no effect here, its just to keep track of used attrs
+	
+	def __init__(self, root_path):
+		"""Initialize ourselves on the .git directory, or the .git/objects directory."""
+		root_path = normpath(root_path)	# truncate trailing /
+		self._git_dir = root_path
+		if root_path.endswith(self.objs_dir):
+			self._git_dir = dirname(root_path)
+		else:
+			root_path = join(root_path, self.objs_dir)
+		#END handle directory
+		assert self._git_dir.endswith('.git'), "require initialization on a git directory, got %s" % self._git_dir
+		super(RefGitDB, self).__init__(root_path)
+	
+	
+	#{ Interface
+	def git_dir(self):
+		""":return: main git directory containing objects and references"""
+		return self._git_dir
+	
+	#} END interface

gitdb/ref/log.py

@@ -151,7 +151,7 @@ def path(cls, ref):
 			instance would be found. The path is not guaranteed to point to a valid 
 			file though.
 		:param ref: SymbolicReference instance"""
-		return join(ref.odb.root_path(), "logs", to_native_path(ref.path))
+		return join(ref.odb.git_dir(), "logs", to_native_path(ref.path))
 
 	@classmethod
 	def iter_entries(cls, stream):

gitdb/ref/symbolic.py

@@ -42,6 +42,7 @@ class SymbolicReference(object):
 	#{ 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
@@ -80,11 +81,11 @@ def name(self):
 
 	@property
 	def abspath(self):
-		return join_path_native(self.odb.root_path(), self.path)
+		return join_path_native(self.odb.git_dir(), self.path)
 
 	@classmethod
 	def _get_packed_refs_path(cls, odb):
-		return join(odb.root_path(), 'packed-refs')
+		return join(odb.git_dir(), 'packed-refs')
 
 	@classmethod
 	def _iter_packed_refs(cls, odb):
@@ -137,7 +138,7 @@ def _get_ref_info(cls, odb, ref_path):
 		point to, or None"""
 		tokens = None
 		try:
-			fp = open(join(odb.root_path(), ref_path), 'r')
+			fp = open(join(odb.git_dir(), ref_path), 'r')
 			value = fp.read().rstrip()
 			fp.close()
 			tokens = value.split(" ")
@@ -216,7 +217,7 @@ def _get_commit(self):
 			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
@@ -229,13 +230,13 @@ def set_commit(self, commit, logmsg = None):
 		:return: self"""
 		# check the type - assume the best if it is a base-string
 		is_invalid_type = False
-		if isinstance(commit, Object):
-			is_invalid_type = commit.type != Commit.type
+		if isinstance(commit, self.ObjectCls):
+			is_invalid_type = commit.type != self.CommitCls.type
 		elif isinstance(commit, SymbolicReference):
-			is_invalid_type = commit.object.type != Commit.type
+			is_invalid_type = commit.object.type != self.CommitCls.type
 		else:
 			try:
-				is_invalid_type = self.odb.rev_parse(commit).type != Commit.type
+				is_invalid_type = self.odb.rev_parse(commit).type != self.CommitCls.type
 			except BadObject:
 				raise ValueError("Invalid object: %s" % commit)
 			#END handle exception
@@ -286,7 +287,7 @@ def set_reference(self, ref, logmsg = None):
 		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):
@@ -414,7 +415,7 @@ def delete(cls, odb, path):
 			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(odb.root_path(), full_ref_path)
+		abs_path = join(odb.git_dir(), full_ref_path)
 		if exists(abs_path):
 			os.remove(abs_path)
 		else:
@@ -467,7 +468,7 @@ def _create(cls, odb, path, resolve, reference, force, logmsg=None):
 		corresponding object and a detached symbolic reference will be created
 		instead"""
 		full_ref_path = cls.to_full_path(path)
-		abs_ref_path = join(odb.root_path(), full_ref_path)
+		abs_ref_path = join(odb.git_dir(), full_ref_path)
 
 		# figure out target data
 		target = reference
@@ -539,8 +540,8 @@ def rename(self, new_path, force=False):
 		if self.path == new_path:
 			return self
 
-		new_abs_path = join(self.odb.root_path(), new_path)
-		cur_abs_path = join(self.odb.root_path(), self.path)
+		new_abs_path = join(self.odb.git_dir(), new_path)
+		cur_abs_path = join(self.odb.git_dir(), self.path)
 		if isfile(new_abs_path):
 			if not force:
 				# if they point to the same file, its not an error
@@ -570,7 +571,7 @@ def _iter_items(cls, odb, common_path = None):
 
 		# walk loose refs
 		# Currently we do not follow links 
-		for root, dirs, files in os.walk(join_path_native(odb.root_path(), common_path)):
+		for root, dirs, files in os.walk(join_path_native(odb.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:
@@ -579,7 +580,7 @@ def _iter_items(cls, odb, common_path = None):
 
 			for f in files:
 				abs_path = to_native_path_linux(join_path(root, f))
-				rela_paths.add(abs_path.replace(to_native_path_linux(odb.root_path()) + '/', ""))
+				rela_paths.add(abs_path.replace(to_native_path_linux(odb.git_dir()) + '/', ""))
 			# END for each file in root directory
 		# END for each directory to walk
 

gitdb/test/lib.py

@@ -5,7 +5,7 @@
 """Utilities used in ODB testing"""
 from gitdb import (
 	OStream, 
-	GitDB
+	RefGitDB
 	)
 from gitdb.stream import ( 
 							Sha1Writer, 
@@ -72,7 +72,7 @@ def wrapper(self, path):
 		shutil.copytree(src_dir, path)
 		target_gitdir = os.path.join(path, '.git')
 		assert os.path.isdir(target_gitdir)
-		return func(self, GitDB(target_gitdir))
+		return func(self, RefGitDB(target_gitdir))
 	#END wrapper
 	wrapper.__name__ = func.__name__
 	return with_rw_directory(wrapper)
@@ -195,7 +195,7 @@ def _assert(self):
 
 class TestBase(unittest.TestCase):
 	"""Base class for all tests"""
-	rorepo = GitDB(repo_dir())
+	rorepo = RefGitDB(repo_dir())
 
 #} END bases
 

gitdb/test/test_refs.py

@@ -19,7 +19,7 @@ class TestRefs(TestBase):
 
 	def test_from_path(self):
 		# should be able to create any reference directly
-		for ref_type in ( Reference, Head, TagReference, RemoteReference ):
+		for ref_type in (Reference, Head, TagReference, RemoteReference):
 			for name in ('rela_name', 'path/rela_name'):
 				full_path = ref_type.to_full_path(name)
 				instance = ref_type.from_path(self.rorepo, full_path)
@@ -32,25 +32,25 @@ def test_tag_base(self):
 		for tag in TagReference.list_items(self.rorepo):
 			assert "refs/tags" in tag.path
 			assert tag.name
-			assert isinstance( tag.commit, Commit )
+			assert isinstance(tag.commit, tag.CommitCls)
 			if tag.tag is not None:
-				tag_object_refs.append( tag )
+				tag_object_refs.append(tag)
 				tagobj = tag.tag
 				# have no dict
 				self.failUnlessRaises(AttributeError, setattr, tagobj, 'someattr', 1)
-				assert isinstance( tagobj, TagObject ) 
+				assert isinstance(tagobj, TagObject) 
 				assert tagobj.tag == tag.name
-				assert isinstance( tagobj.tagger, Actor )
-				assert isinstance( tagobj.tagged_date, int )
-				assert isinstance( tagobj.tagger_tz_offset, int )
+				assert isinstance(tagobj.tagger, Actor)
+				assert isinstance(tagobj.tagged_date, int)
+				assert isinstance(tagobj.tagger_tz_offset, int)
 				assert tagobj.message
 				assert tag.object == tagobj
 				# can't assign the object
 				self.failUnlessRaises(AttributeError, setattr, tag, 'object', tagobj)
 			# END if we have a tag object
 		# END for tag in repo-tags
 		assert tag_object_refs
-		assert isinstance(self.rorepo.tags['0.1.5'], TagReference)
+		assert isinstance(TagReference.list_items(self.rorepo)['0.5.0'], TagReference)
 
 	def test_tags(self):
 		# tag refs can point to tag objects or to commits

gitdb/util.py

@@ -73,6 +73,7 @@ def unpack_from(fmt, data, offset=0):
 remove = os.remove
 dirname = os.path.dirname
 basename = os.path.basename
+normpath = os.path.normpath
 join = os.path.join
 read = os.read
 write = os.write