git cmd implementation of repository appears to work, at least this is what the test suggests. Pure python implementation still has some trouble, but this should be very fixable

Author: Byron

git/db/cmd/base.py

@@ -13,25 +13,26 @@
 
 from git.util import (
 							bin_to_hex, 
-							hex_to_bin
-						)
-from git.db.compat import RepoCompatibilityInterface
-from git.util import RemoteProgress
+							hex_to_bin,
+							RemoteProgress,
+							isfile,
+							join_path,
+							join,
+							Actor
+					)
 from git.db.interface import FetchInfo as GitdbFetchInfo
 from git.db.interface import PushInfo as GitdbPushInfo
 from git.db.interface import HighLevelRepository
-
-from git.util import  join_path
-from git.util import join
 from git.cmd import Git
 from git.refs import (
 						Reference,
 						RemoteReference,
 						SymbolicReference, 
 						TagReference
 					)
-
+from git.objects.commit import Commit
 import re
+import os
 import sys
 
 
@@ -472,6 +473,11 @@ class CmdHighLevelRepository(HighLevelRepository):
 	re_author_committer_start = re.compile(r'^(author|committer)')
 	re_tab_full_line = re.compile(r'^\t(.*)$')
 
+	#{ Configuration
+	CommitCls = Commit
+	GitCls = Git
+	#} END configuration
+	
 	def daemon_export():
 		def _get_daemon_export(self):
 			filename = join(self.git_dir, self.DAEMON_EXPORT_FILE)
@@ -588,7 +594,7 @@ def blame(self, rev, file):
 							sha = info['id']
 							c = commits.get(sha)
 							if c is None:
-								c = Commit(	 self, hex_to_bin(sha),
+								c = self.CommitCls(	 self, hex_to_bin(sha),
 											 author=Actor._from_string(info['author'] + ' ' + info['author_email']),
 											 authored_date=info['author_date'],
 											 committer=Actor._from_string(info['committer'] + ' ' + info['committer_email']),
@@ -619,9 +625,9 @@ def init(cls, path=None, mkdir=True, **kwargs):
 			os.makedirs(path, 0755)
 
 		# git command automatically chdir into the directory
-		git = Git(path)
+		git = cls.GitCls(path)
 		output = git.init(**kwargs)
-		return Repo(path)
+		return cls(path)
 
 	@classmethod
 	def _clone(cls, git, url, path, **kwargs):
@@ -686,7 +692,7 @@ def clone_from(cls, url, to_path, **kwargs):
 		"""
 		:param kwargs: see the ``clone`` method
 		For more information, see the respective method in the HighLevelRepository"""
-		return cls._clone(type(self.git)(os.getcwd()), url, to_path, **kwargs)
+		return cls._clone(cls.GitCls(os.getcwd()), url, to_path, **kwargs)
 
 	def archive(self, ostream, treeish=None, prefix=None,  **kwargs):
 		"""For all args see HighLevelRepository interface

git/db/cmd/complex.py

@@ -1,12 +1,10 @@
 """Module with our own git implementation - it uses the git command"""
 
 from git.db.compat import RepoCompatibilityInterface
-from git.db.py.complex import PureGitDB
-
 from base import *
 
 
-__all__ = ['GitCmdDB', 'CmdCompatibilityGitDB', 'CmdPartialGitDB']
+__all__ = ['CmdPartialGitDB']
 
 
 class CmdPartialGitDB( 	GitCommandMixin, CmdObjectDBRMixin, CmdTransportMixin, 
@@ -16,12 +14,3 @@ class CmdPartialGitDB( 	GitCommandMixin, CmdObjectDBRMixin, CmdTransportMixin,
 	implementations"""
 	pass
 
-
-class CmdGitDB(CmdPartialGitDB, PureGitDB):
-	"""A database which fills in its missing implementation using the pure python 
-	implementation"""
-	pass
-
-
-class CmdCompatibilityGitDB(CmdGitDB, RepoCompatibilityInterface):
-	"""Command git database with the compatabilty interface added for 0.3x code"""

git/db/complex.py

@@ -1,12 +1,25 @@
 """Module with many useful complex databases with different useful combinations of primary implementations"""
 
-from py.complex import PureGitDB
+from py.complex import PurePartialGitDB
 from cmd.complex import CmdPartialGitDB
 from compat import RepoCompatibilityInterface
 
-__all__ = ['CmdPartialGitDB', 'PureGitDB', 'PureCmdGitDB']
+__all__ = ['CmdGitDB', 'PureGitDB', 'CmdCompatibilityGitDB', 'PureCompatibilityGitDB']
 
-class PureCmdGitDB(PureGitDB, CmdPartialGitDB, RepoCompatibilityInterface):
+class CmdGitDB(CmdPartialGitDB, PurePartialGitDB):
+	"""A database which uses primarily the git command implementation, but falls back
+	to pure python where it is more feasible"""
+
+class CmdCompatibilityGitDB(RepoCompatibilityInterface, CmdGitDB):
+	"""A database which fills in its missing implementation using the pure python 
+	implementation"""
+	pass
+
+class PureGitDB(PurePartialGitDB, CmdPartialGitDB):
+	"""A repository which uses the pure implementation primarily, but falls back
+	on using the git command for high-level functionality"""
+
+class PureCompatibilityGitDB(RepoCompatibilityInterface, PureGitDB):
 	"""Repository which uses the pure implementation primarily, but falls back
 	to the git command implementation. Please note that the CmdGitDB does it
 	the opposite way around."""

git/db/py/base.py

@@ -8,6 +8,7 @@
 from git.util import (
 		pool,
 		join,
+		isfile,
 		normpath,
 		abspath,
 		dirname,
@@ -25,7 +26,8 @@
 from git.exc import 	(
 						BadObject, 
 						AmbiguousObjectName,
-						InvalidDBRoot
+						InvalidGitRepositoryError,
+						NoSuchPathError
 						)
 
 from async import ChannelThreadTask
@@ -240,7 +242,7 @@ def _initialize(self, path):
 		epath = abspath(expandvars(expanduser(path or os.getcwd())))
 
 		if not exists(epath):
-			raise InvalidDBRoot(epath)
+			raise NoSuchPathError(epath)
 		#END check file 
 
 		self._working_tree_dir = None
@@ -264,7 +266,7 @@ def _initialize(self, path):
 		# END while curpath
 
 		if self._git_path is None:
-			raise InvalidDBRoot(epath)
+			raise InvalidGitRepositoryError(epath)
 		# END path not found
 
 		self._bare = self._git_path.endswith(self.repo_dir)
@@ -351,6 +353,7 @@ class PureConfigurationMixin(ConfigurationMixin):
 
 	def __init__(self, *args, **kwargs):
 		"""Verify prereqs"""
+		super(PureConfigurationMixin, self).__init__(*args, **kwargs)
 		assert hasattr(self, 'git_dir')
 
 	def _path_at_level(self, level ):

git/db/py/complex.py

@@ -1,6 +1,6 @@
 # Copyright (C) 2010, 2011 Sebastian Thiel (byronimo@gmail.com) and contributors
 #
-# This module is part of PureGitDB and is released under
+# This module is part of PurePartialGitDB and is released under
 # the New BSD License: http://www.opensource.org/licenses/bsd-license.php
 from git.db.interface import HighLevelRepository
 from base import (
@@ -12,7 +12,7 @@
 						PureAlternatesFileMixin,
 						PureIndexDB,
 					)
-
+from transport import PureTransportDB
 from resolve import PureReferencesMixin
 
 from loose import PureLooseObjectODB
@@ -35,14 +35,14 @@
 						)
 import os
 
-__all__ = ('PureGitODB', 'PureGitDB', 'PureCompatibilityGitDB')
+__all__ = ('PureGitODB', 'PurePartialGitDB', 'PureCompatibilityGitDB')
 
 
 class PureGitODB(PureRootPathDB, PureObjectDBW, PureCompoundDB):
 	"""A git-style object-only database, which contains all objects in the 'objects'
 	subdirectory.
 	:note: The type needs to be initialized on the ./objects directory to function, 
-		as it deals solely with object lookup. Use a PureGitDB type if you need
+		as it deals solely with object lookup. Use a PurePartialGitDB type if you need
 		reference and push support."""
 	# Configuration
 	PackDBCls = PurePackedODB
@@ -103,10 +103,10 @@ def set_ostream(self, ostream):
 
 
 
-class PureGitDB(PureGitODB, 
+class PurePartialGitDB(PureGitODB, 
 				PureRepositoryPathsMixin, PureConfigurationMixin, 
 				PureReferencesMixin, PureSubmoduleDB, PureAlternatesFileMixin, 
-				PureIndexDB,
+				PureIndexDB, PureTransportDB
 				# HighLevelRepository  Currently not implemented !
 				):
 	"""Git like database with support for object lookup as well as reference resolution.
@@ -119,10 +119,10 @@ class PureGitDB(PureGitODB,
 	def __init__(self, root_path):
 		"""Initialize ourselves on the .git directory, or the .git/objects directory."""
 		PureRepositoryPathsMixin._initialize(self, root_path)
-		super(PureGitDB, self).__init__(self.objects_dir)
+		super(PurePartialGitDB, self).__init__(self.objects_dir)
 
 
 
-class PureCompatibilityGitDB(PureGitDB, RepoCompatibilityInterface):
+class PureCompatibilityGitDB(PurePartialGitDB, RepoCompatibilityInterface):
 	"""Pure git database with a compatability layer required by 0.3x code"""
 

git/db/py/resolve.py

@@ -320,8 +320,7 @@ def tags(self):
 		return self.TagReferenceCls.list_items(self)
 
 	def tag(self, name):
-		return self.tags[name]
-		
+		return self.TagReferenceCls(self, self.TagReferenceCls.to_full_path(name))
 
 	def commit(self, rev=None):
 		if rev is None:

git/exc.py

@@ -43,11 +43,11 @@ class UnsupportedOperation(ODBError):
 	"""Thrown if the given operation cannot be supported by the object database"""
 
 
-class InvalidGitRepositoryError(GitPythonError):
+class InvalidGitRepositoryError(InvalidDBRoot):
 	""" Thrown if the given repository appears to have an invalid format.  """
 
 
-class NoSuchPathError(GitPythonError):
+class NoSuchPathError(InvalidDBRoot):
 	""" Thrown if a path could not be access by the system. """
 
 

git/objects/base.py

@@ -14,7 +14,8 @@
 							join_path_native, 
 							stream_copy
 						)
-
+from git.db.interface import RepositoryPathsMixin
+from git.exc import UnsupportedOperation
 from git.typ import ObjectType
 
 _assertion_msg_format = "Created object %r whose python type %r disagrees with the acutal git object type %r"
@@ -173,7 +174,15 @@ def abspath(self):
 			Absolute path to this index object in the file system ( as opposed to the 
 			.path field which is a path relative to the git repository ).
 			
-			The returned path will be native to the system and contains '\' on windows. """
-		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)
+			The returned path will be native to the system and contains '\' on windows.
+		:raise UnsupportedOperation: if underlying odb does not support the required method to obtain a working dir"""
+		# TODO: Here we suddenly need something better than a plain object database
+		# which indicates our odb should better be named repo !
+		root = ''
+		if isinstance(self.odb, RepositoryPathsMixin):
+			root = self.odb.working_tree_dir
+		else:
+			raise UnsupportedOperation("Cannot provide absolute path from a database without Repository path support")
+		#END handle odb type
+		return join_path_native(root, self.path)
 

git/objects/submodule/base.py

@@ -58,7 +58,7 @@ class UpdateProgress(RemoteProgress):
 # IndexObject comes via util module, its a 'hacky' fix thanks to pythons import 
 # mechanism which cause plenty of trouble of the only reason for packages and
 # modules is refactoring - subpackages shoudn't depend on parent packages
-class Submodule(Iterable, Traversable, RepoAliasMixin):
+class Submodule(util.IndexObject, Iterable, Traversable, RepoAliasMixin):
 	"""Implements access to a git submodule. They are special in that their sha
 	represents a commit in the submodule's repository which is to be checked out
 	at the path of this instance. 

git/refs/reference.py

@@ -28,7 +28,7 @@ def __init__(self, repo, 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 ))
+			raise ValueError("Cannot instantiate %r from path %s, maybe use %s.to_full_path(name) to safely generate a valid full path from a name" % ( self.__class__.__name__, path, type(self).__name__))
 		super(Reference, self).__init__(repo, path)
 
 

git/refs/symbolic.py

@@ -237,7 +237,7 @@ def set_commit(self, commit, logmsg = None):
 			is_invalid_type = commit.object.type != self.CommitCls.type
 		else:
 			try:
-				is_invalid_type = self.repo.resolve(commit).type != self.CommitCls.type
+				is_invalid_type = self.repo.resolve_object(commit).type != self.CommitCls.type
 			except BadObject:
 				raise ValueError("Invalid object: %s" % commit)
 			#END handle exception
@@ -293,7 +293,7 @@ def set_reference(self, ref, logmsg = None):
 			write_value = ref.hexsha
 		elif isinstance(ref, basestring):
 			try:
-				obj = self.repo.resolve(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)
@@ -481,7 +481,7 @@ def _create(cls, repo, path, resolve, reference, force, logmsg=None):
 			elif isinstance(reference, SymbolicReference):
 				target = reference.object.hexsha
 			else:
-				target = repo.resolve(str(reference))
+				target = repo.resolve_object(str(reference))
 			#END handle resoltion
 		#END need resolution
 

git/repo.py

@@ -5,7 +5,7 @@
 # the BSD License: http://www.opensource.org/licenses/bsd-license.php
 """This module is just to maintain compatibility to git-python 0.3x"""
 
-from git.db.cmd.complex import CmdCompatibilityGitDB
+from git.db.complex import CmdCompatibilityGitDB
 
 
 import warnings