Fixed ref test up to the point where there is an issue resolving objects in the database for some reason.

Author: Byron

gitdb/object/base.py

@@ -7,6 +7,7 @@
 from gitdb.util import (
 							hex_to_bin,
 							bin_to_hex,
+							dirname,
 							basename, 
 							LazyMixin, 
 							join_path_native, 
@@ -65,15 +66,15 @@ def new_from_sha(cls, odb, sha1):
 			# the NULL binsha is always the root commit
 			return get_object_type_by_name('commit')(odb, sha1)
 		#END handle special case
-		oinfo = odb.odb.info(sha1)
+		oinfo = odb.info(sha1)
 		inst = get_object_type_by_name(oinfo.type)(odb, oinfo.binsha)
 		inst.size = oinfo.size
 		return inst 
 
 	def _set_cache_(self, attr):
 		"""Retrieve object information"""
 		if attr	 == "size":
-			oinfo = self.odb.odb.info(self.binsha)
+			oinfo = self.odb.info(self.binsha)
 			self.size = oinfo.size
 			# assert oinfo.type == self.type, _assertion_msg_format % (self.binsha, oinfo.type, self.type)
 		else:
@@ -108,13 +109,13 @@ def hexsha(self):
 	def data_stream(self):
 		""" :return:  File Object compatible stream to the uncompressed raw data of the object
 		:note: returned streams must be read in order"""
-		return self.odb.odb.stream(self.binsha)
+		return self.odb.stream(self.binsha)
 
 	def stream_data(self, ostream):
 		"""Writes our data directly to the given output stream
 		:param ostream: File object compatible stream object.
 		:return: self"""
-		istream = self.odb.odb.stream(self.binsha)
+		istream = self.odb.stream(self.binsha)
 		stream_copy(istream, ostream)
 		return self
 
@@ -129,7 +130,7 @@ class IndexObject(Object):
 
 	def __init__(self, odb, binsha, mode=None, path=None):
 		"""Initialize a newly instanced IndexObject
-		:param odb: is the Repo we are located in
+		:param odb: is the object database we are located in
 		:param binsha: 20 byte sha1
 		:param mode: is the stat compatible file mode as int, use the stat module
 			to evaluate the infomration
@@ -172,5 +173,6 @@ def abspath(self):
 			.path field which is a path relative to the git repository ).
 			
 			The returned path will be native to the system and contains '\' on windows. """
-		return join_path_native(self.odb.working_tree_dir, self.path)
+		assert False, "Only works if repository is not bare - provide this check in an interface"
+		return join_path_native(dirname(self.odb.root_path()), self.path)
 

gitdb/ref/head.py

@@ -14,16 +14,16 @@ class HEAD(SymbolicReference):
 	_ORIG_HEAD_NAME = 'ORIG_HEAD'
 	__slots__ = tuple()
 
-	def __init__(self, repo, path=_HEAD_NAME):
+	def __init__(self, odb, 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)
+		super(HEAD, self).__init__(odb, 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)
+		return SymbolicReference(self.odb, self._ORIG_HEAD_NAME)
 
 
 class Head(Reference):
@@ -69,9 +69,9 @@ def tracking_branch(self):
 			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)))
+			ref = Head(self.odb, Head.to_full_path(reader.get_value(self.k_config_remote_ref)))
 			remote_refpath = self.RemoteReferenceCls.to_full_path(join_path(reader.get_value(self.k_config_remote), ref.name))
-			return self.RemoteReferenceCls(self.repo, remote_refpath)
+			return self.RemoteReferenceCls(self.odb, remote_refpath)
 		# END handle have tracking branch
 
 		# we are not a tracking branch
@@ -82,9 +82,9 @@ def tracking_branch(self):
 
 	def _config_parser(self, read_only):
 		if read_only:
-			parser = self.repo.config_reader()
+			parser = self.odb.config_reader()
 		else:
-			parser = self.repo.config_writer()
+			parser = self.odb.config_writer()
 		# END handle parser instance
 
 		return SectionConstraint(parser, 'branch "%s"' % self.name)

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.repo.git_dir, "logs", to_native_path(ref.path))
+		return join(ref.odb.root_path(), "logs", to_native_path(ref.path))
 
 	@classmethod
 	def iter_entries(cls, stream):

gitdb/ref/symbolic.py

@@ -80,11 +80,11 @@ def name(self):
 
 	@property
 	def abspath(self):
-		return join_path_native(self.odb.git_dir, self.path)
+		return join_path_native(self.odb.root_path(), self.path)
 
 	@classmethod
 	def _get_packed_refs_path(cls, odb):
-		return join(odb.git_dir, 'packed-refs')
+		return join(odb.root_path(), 'packed-refs')
 
 	@classmethod
 	def _iter_packed_refs(cls, odb):
@@ -137,7 +137,7 @@ def _get_ref_info(cls, odb, ref_path):
 		point to, or None"""
 		tokens = None
 		try:
-			fp = open(join(odb.git_dir, ref_path), 'r')
+			fp = open(join(odb.root_path(), ref_path), 'r')
 			value = fp.read().rstrip()
 			fp.close()
 			tokens = value.split(" ")
@@ -159,7 +159,7 @@ def _get_ref_info(cls, odb, ref_path):
 			return (None, tokens[1])
 
 		# its a commit
-		if 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)
@@ -177,7 +177,7 @@ def _get_object(self):
 			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 self.ObjectCls.new_from_sha(self._get_object_sha())
+		return self.ObjectCls.new_from_sha(self.odb, self._get_object_sha())
 
 	def set_object(self, object_id, logmsg = None):
 		"""Set the object we point to, possibly dereference our symbolic reference first.
@@ -341,7 +341,7 @@ def is_valid(self):
 			a valid object or reference."""
 		try:
 			self.object
-		except (OSError, ValueError):
+		except (OSError, ValueError, BadObject):
 			return False
 		else:
 			return True
@@ -414,7 +414,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.git_dir, full_ref_path)
+		abs_path = join(odb.root_path(), full_ref_path)
 		if exists(abs_path):
 			os.remove(abs_path)
 		else:
@@ -467,7 +467,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.git_dir, full_ref_path)
+		abs_ref_path = join(odb.root_path(), full_ref_path)
 
 		# figure out target data
 		target = reference
@@ -539,8 +539,8 @@ def rename(self, new_path, force=False):
 		if self.path == new_path:
 			return self
 
-		new_abs_path = join(self.odb.git_dir, new_path)
-		cur_abs_path = join(self.odb.git_dir, self.path)
+		new_abs_path = join(self.odb.root_path(), new_path)
+		cur_abs_path = join(self.odb.root_path(), self.path)
 		if isfile(new_abs_path):
 			if not force:
 				# if they point to the same file, its not an error
@@ -570,7 +570,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.git_dir, common_path)):
+		for root, dirs, files in os.walk(join_path_native(odb.root_path(), 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 +579,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.git_dir) + '/', ""))
+				rela_paths.add(abs_path.replace(to_native_path_linux(odb.root_path()) + '/', ""))
 			# END for each file in root directory
 		# END for each directory to walk
 
@@ -611,8 +611,8 @@ def iter_items(cls, odb, common_path = None):
 			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"""

gitdb/test/lib.py

@@ -66,11 +66,13 @@ def with_rw_repo(func):
 	that should exist
 	Wrapped function obtains a git repository """
 	def wrapper(self, path):
-		src_dir = os.path.dirname(os.path.dirname(__file__))
+		src_dir = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
 		assert(os.path.isdir(path))
-		os.rmdir(path)		# created by wrapper
+		os.rmdir(path)		# created by wrapper, but must not exist for copy operation
 		shutil.copytree(src_dir, path)
-		return func(self, GitDB(os.path.join(path, '.git')))
+		target_gitdir = os.path.join(path, '.git')
+		assert os.path.isdir(target_gitdir)
+		return func(self, GitDB(target_gitdir))
 	#END wrapper
 	wrapper.__name__ = func.__name__
 	return with_rw_directory(wrapper)

gitdb/test/test_refs.py

@@ -13,6 +13,7 @@
 
 from itertools import chain
 import os
+from nose import SkipTest
 
 class TestRefs(TestBase):
 
@@ -28,7 +29,7 @@ def test_from_path(self):
 
 	def test_tag_base(self):
 		tag_object_refs = list()
-		for tag in self.rorepo.tags:
+		for tag in TagReference.list_items(self.rorepo):
 			assert "refs/tags" in tag.path
 			assert tag.name
 			assert isinstance( tag.commit, Commit )
@@ -55,9 +56,9 @@ def test_tags(self):
 		# tag refs can point to tag objects or to commits
 		s = set()
 		ref_count = 0
-		for ref in chain(self.rorepo.tags, self.rorepo.heads):
+		for ref in chain(TagReference.list_items(self.rorepo), Head.list_items(self.rorepo)):
 			ref_count += 1
-			assert isinstance(ref, ref.Reference)
+			assert isinstance(ref, Reference)
 			assert str(ref) == ref.name
 			assert repr(ref)
 			assert ref == ref
@@ -69,7 +70,7 @@ def test_tags(self):
 
 	@with_rw_repo
 	def test_heads(self, rw_repo):
-		for head in rw_repo.heads:
+		for head in Head.iter_items(rw_repo):
 			assert head.name
 			assert head.path
 			assert "refs/heads" in head.path
@@ -97,7 +98,7 @@ def test_heads(self, rw_repo):
 		# END for each head
 
 		# verify REFLOG gets altered
-		head = rw_repo.head
+		head = HEAD(rw_repo)
 		cur_head = head.ref
 		cur_commit = cur_head.commit
 		pcommit = cur_head.commit.parents[0].parents[0]
@@ -140,22 +141,24 @@ def test_heads(self, rw_repo):
 
 	def test_refs(self):
 		types_found = set()
-		for ref in self.rorepo.refs:
+		for ref in Reference.list_items(self.rorepo):
 			types_found.add(type(ref))
 		assert len(types_found) >= 3 
 
 	def test_is_valid(self):
 		assert Reference(self.rorepo, 'refs/doesnt/exist').is_valid() == False
-		assert self.rorepo.head.is_valid()
-		assert self.rorepo.head.reference.is_valid()
+		assert HEAD(self.rorepo).is_valid()
+		assert HEAD(self.rorepo).reference.is_valid()
 		assert SymbolicReference(self.rorepo, 'hellothere').is_valid() == False
 
 	def test_orig_head(self):
-		assert type(self.rorepo.head.orig_head()) == SymbolicReference
+		assert type(HEAD(self.rorepo).orig_head()) == SymbolicReference
 
 	#@with_rw_repo('0.1.6')
 	# todo reenable
-	def _disabled_test_head_reset(self, rw_repo):
+	#def test_head_reset(self, rw_repo):
+	def test_head_reset(self):
+		raise SkipTest()
 		cur_head = rw_repo.head
 		old_head_commit = cur_head.commit
 		new_head_commit = cur_head.ref.commit.parents[0]
@@ -416,7 +419,7 @@ def _disabled_test_head_reset(self, rw_repo):
 		symbol_ref_path = "refs/symbol_ref"
 		symref = SymbolicReference(rw_repo, symbol_ref_path)
 		assert symref.path == symbol_ref_path
-		symbol_ref_abspath = os.path.join(rw_repo.git_dir, symref.path)
+		symbol_ref_abspath = os.path.join(rw_repo.root_path(), symref.path)
 
 		# set it
 		symref.reference = new_head
@@ -473,7 +476,7 @@ def _disabled_test_head_reset(self, rw_repo):
 		rw_repo.head.reference = Head.create(rw_repo, "master")
 
 		# At least the head should still exist
-		assert os.path.isfile(os.path.join(rw_repo.git_dir, 'HEAD'))
+		assert os.path.isfile(os.path.join(rw_repo.root_path(), 'HEAD'))
 		refs = list(SymbolicReference.iter_items(rw_repo))
 		assert len(refs) == 1
 
@@ -519,5 +522,5 @@ def test_dereference_recursive(self):
 		assert SymbolicReference.dereference_recursive(self.rorepo, 'HEAD')
 
 	def test_reflog(self):
-		assert isinstance(self.rorepo.heads.master.log(), RefLog)
+		assert isinstance(Head.list_items(self.rorepo).master.log(), RefLog)