Merge branch 'dulwich'

7 files changed, 158 insertions, 66 deletions

diff --git a/git/db/compat.py b/git/db/compat.py
index 767ab5e0..771a1e77 100644
--- a/git/db/compat.py
+++ b/git/db/compat.py
@@ -4,14 +4,10 @@
 # the New BSD License: http://www.opensource.org/licenses/bsd-license.php
 """Module providing adaptors to maintain backwards compatability"""
 
-class RepoCompatibilityInterface(object):
+class RepoCompatibilityInterfaceNoBare(object):
 	"""Interface to install backwards compatability of the new complex repository
 	types with the previous, all in one, repository."""
 	
-	@property
-	def bare(self):
-		return self.is_bare
-		
 	def rev_parse(self, *args, **kwargs):
 		return self.resolve_object(*args, **kwargs)
 		
@@ -28,4 +24,22 @@ class RepoCompatibilityInterface(object):
 		return self.head.reference
 		
 	def __repr__(self):
+		"""Return the representation of the repository, the way it used to be"""
 		return '<git.Repo "%s">' % self.git_dir
+		
+	@property
+	def branches(self):
+		return self.heads
+
+
+class RepoCompatibilityInterface(RepoCompatibilityInterfaceNoBare):
+	"""Interface to install backwards compatability of the new complex repository
+	types with the previous, all in one, repository."""
+	
+	@property
+	def bare(self):
+		return self.is_bare
+		
+	@property
+	def refs(self):
+		return self.references
diff --git a/git/db/dulwich/__init__.py b/git/db/dulwich/__init__.py
new file mode 100644
index 00000000..92d30941
--- /dev/null
+++ b/git/db/dulwich/__init__.py
@@ -0,0 +1,13 @@
+"""Dulwich module initialization"""
+
+def init_dulwich():
+	""":raise ImportError: if dulwich is not present"""
+	try:
+		import dulwich
+	except ImportError:
+		raise ImportError("Could not find 'dulwich' in the PYTHONPATH - dulwich functionality is not available")
+	#END handle dulwich import
+
+
+
+init_dulwich()
diff --git a/git/db/dulwich/complex.py b/git/db/dulwich/complex.py
new file mode 100644
index 00000000..ad5b97a4
--- /dev/null
+++ b/git/db/dulwich/complex.py
@@ -0,0 +1,90 @@
+
+__all__ = ['DulwichGitODB', 'DulwichGitDB', 'DulwichCompatibilityGitDB']
+
+from git.db.py.complex import PureGitODB
+from git.db.py.base import (
+						PureRepositoryPathsMixin,
+						PureConfigurationMixin,
+						PureIndexDB,
+					)
+from git.db.py.resolve import PureReferencesMixin
+from git.db.py.transport import PureTransportDB
+from git.db.py.submodule import PureSubmoduleDB
+
+from git.db.cmd.complex import CmdHighLevelRepository, GitCommandMixin
+from git.db.compat import RepoCompatibilityInterfaceNoBare
+
+#from git.db.interface import ObjectDBW, ObjectDBR
+from dulwich.repo import Repo as DulwichRepo
+from dulwich.objects import ShaFile
+
+from git.base import OInfo, OStream
+from git.fun import type_id_to_type_map, type_to_type_id_map 
+
+from cStringIO import StringIO 
+import os
+
+
+class DulwichGitODB(PureGitODB):
+	"""A full fledged database to read and write object files from all kinds of sources."""
+	
+	def __init__(self, objects_root):
+		"""Initalize this instance"""
+		PureGitODB.__init__(self, objects_root)
+		if hasattr(self, 'working_dir'):
+			wd = self.working_dir
+		else:
+			wd = os.path.dirname(os.path.dirname(objects_root))
+		#END try to figure out good entry for dulwich, which doesn't do an extensive search
+		self._dw_repo = DulwichRepo(wd)
+		
+	def __getattr__(self, attr):
+		try:
+			# supply LazyMixin with this call first
+			return super(DulwichGitODB, self).__getattr__(attr)
+		except AttributeError:
+			# now assume its on the dulwich repository ... for now
+			return getattr(self._dw_repo, attr)
+		#END handle attr
+		
+	#{ Object DBR
+	
+	def info(self, binsha):
+		type_id, uncomp_data = self._dw_repo.object_store.get_raw(binsha) 
+		return OInfo(binsha, type_id_to_type_map[type_id], len(uncomp_data))
+	
+	def stream(self, binsha):
+		type_id, uncomp_data = self._dw_repo.object_store.get_raw(binsha)
+		return OStream(binsha, type_id_to_type_map[type_id], len(uncomp_data), StringIO(uncomp_data))
+	
+	#}END object dbr
+	
+	#{ Object DBW
+	
+	def store(self, istream):
+		obj = ShaFile.from_raw_string(type_to_type_id_map[istream.type], istream.read())
+		self._dw_repo.object_store.add_object(obj)
+		istream.binsha = obj.sha().digest()
+		return istream
+		
+	#}END object dbw
+		
+class DulwichGitDB(		PureRepositoryPathsMixin, PureConfigurationMixin, 
+						PureReferencesMixin, PureSubmoduleDB, 
+						PureIndexDB, 
+						PureTransportDB, # not fully implemented
+						GitCommandMixin,
+						CmdHighLevelRepository,
+						DulwichGitODB):	# must come last, as it doesn't pass on __init__ with super
+
+
+	def __init__(self, root_path):
+		"""Initialize ourselves on the .git directory, or the .git/objects directory."""
+		PureRepositoryPathsMixin._initialize(self, root_path)
+		super(DulwichGitDB, self).__init__(self.objects_dir)
+	
+
+class DulwichCompatibilityGitDB(RepoCompatibilityInterfaceNoBare, DulwichGitDB):
+	"""Basic dulwich compatibility database"""
+	pass
+
diff --git a/git/db/interface.py b/git/db/interface.py
index 803f7769..9ad74cc1 100644
--- a/git/db/interface.py
+++ b/git/db/interface.py
@@ -561,16 +561,8 @@ class ReferencesMixin(object):
 		raise NotImplementedError()
 		
 	#}END edit methods
-		
-	#{ Backward Compatability
-	# These aliases need to be provided by the implementing interface as well
-	refs = references
-	branches = heads
-	#} END backward compatability
-		
-		
-	
-		
+
+
 class RepositoryPathsMixin(object):
 	"""Represents basic functionality of a full git repository. This involves an 
 	optional working tree, a git directory with references and an object directory.
diff --git a/git/db/py/base.py b/git/db/py/base.py
index 2c21c136..49f28a8d 100644
--- a/git/db/py/base.py
+++ b/git/db/py/base.py
@@ -104,7 +104,6 @@ class PureRootPathDB(RootPathDB):
 		super(PureRootPathDB, self).__init__(root_path)
 		
 		
-		
 	#{ Interface 
 	def root_path(self):
 		return self._root_path
@@ -132,44 +131,33 @@ class PureCompoundDB(CompoundDB, PureObjectDBR, LazyMixin, CachingDB):
 	def _set_cache_(self, attr):
 		if attr == '_dbs':
 			self._dbs = list()
-		elif attr == '_obj_cache':
-			self._obj_cache = dict()
 		else:
 			super(PureCompoundDB, self)._set_cache_(attr)
 	
-	def _db_query(self, sha):
-		""":return: database containing the given 20 byte sha
-		:raise BadObject:"""
-		# most databases use binary representations, prevent converting 
-		# it everytime a database is being queried
-		try:
-			return self._obj_cache[sha]
-		except KeyError:
-			pass
-		# END first level cache
-		
-		for db in self._dbs:
-			if db.has_object(sha):
-				self._obj_cache[sha] = db
-				return db
-		# END for each database
-		raise BadObject(sha)
-	
 	#{ PureObjectDBR interface 
 	
 	def has_object(self, sha):
-		try:
-			self._db_query(sha)
-			return True
-		except BadObject:
-			return False
-		# END handle exceptions
+		for db in self._dbs:
+			if db.has_object(sha):
+				return True
+		#END for each db
+		return False
 		
 	def info(self, sha):
-		return self._db_query(sha).info(sha)
+		for db in self._dbs:
+			try:
+				return db.info(sha)
+			except BadObject:
+				pass
+		#END for each db
 		
 	def stream(self, sha):
-		return self._db_query(sha).stream(sha)
+		for db in self._dbs:
+			try:
+				return db.stream(sha)
+			except BadObject:
+				pass
+		#END for each db
 
 	def size(self):
 		return reduce(lambda x,y: x+y, (db.size() for db in self._dbs), 0)
@@ -186,7 +174,6 @@ class PureCompoundDB(CompoundDB, PureObjectDBR, LazyMixin, CachingDB):
 
 	def update_cache(self, force=False):
 		# something might have changed, clear everything
-		self._obj_cache.clear()
 		stat = False
 		for db in self._dbs:
 			if isinstance(db, CachingDB):
@@ -233,7 +220,7 @@ class PureCompoundDB(CompoundDB, PureObjectDBR, LazyMixin, CachingDB):
 		
 class PureRepositoryPathsMixin(RepositoryPathsMixin):
 	# slots has no effect here, its just to keep track of used attrs
-	__slots__  = ("_git_path", '_bare')
+	__slots__  = ("_git_path", '_bare', '_working_tree_dir')
 	
 	#{ Configuration 
 	repo_dir = '.git'
@@ -272,14 +259,16 @@ class PureRepositoryPathsMixin(RepositoryPathsMixin):
 			raise InvalidGitRepositoryError(epath)
 		# END path not found
 
-		self._bare = self._git_path.endswith(self.repo_dir)
+		self._bare = self._working_tree_dir is None
 		if hasattr(self, 'config_reader'):
 			try:
 				self._bare = self.config_reader("repository").getboolean('core','bare') 
 			except Exception:
 				# lets not assume the option exists, although it should
 				pass
+			#END handle exception
 		#END check bare flag
+		self._working_tree_dir = self._bare and None or self._working_tree_dir
 		
 	#} end subclass interface
 	
@@ -313,7 +302,7 @@ class PureRepositoryPathsMixin(RepositoryPathsMixin):
 		
 	@property
 	def working_tree_dir(self):
-		if self.is_bare:
+		if self._working_tree_dir is None:
 			raise AssertionError("Repository at %s is bare and does not have a working tree directory" % self.git_dir)
 		#END assertion
 		return dirname(self.git_dir)
@@ -354,6 +343,10 @@ class PureConfigurationMixin(ConfigurationMixin):
 	repo_config_file_name = "config"
 	#} END
 	
+	def __new__(cls, *args, **kwargs):
+		"""This is just a stupid workaround for the evil py2.6 change which makes mixins quite impossible"""
+		return super(PureConfigurationMixin, cls).__new__(cls, *args, **kwargs)
+	
 	def __init__(self, *args, **kwargs):
 		"""Verify prereqs"""
 		try:
@@ -421,7 +414,11 @@ class PureAlternatesFileMixin(object):
 	#} END configuration
 	
 	def __init__(self, *args, **kwargs):
-		super(PureAlternatesFileMixin, self).__init__(*args, **kwargs)
+		try:
+			super(PureAlternatesFileMixin, self).__init__(*args, **kwargs)
+		except TypeError:
+			pass
+		#END handle py2.6 code breaking changes
 		self._alternates_path()	# throws on incompatible type
 	
 	#{ Interface 
diff --git a/git/db/py/complex.py b/git/db/py/complex.py
index d5c185f3..5f4e81e0 100644
--- a/git/db/py/complex.py
+++ b/git/db/py/complex.py
@@ -22,17 +22,7 @@ from submodule import PureSubmoduleDB
 
 from git.db.compat import RepoCompatibilityInterface
 
-from git.util import (
-						LazyMixin, 
-						normpath,
-						join,
-						dirname
-					)
-from git.exc import (
-						InvalidDBRoot, 
-						BadObject, 
-						AmbiguousObjectName
-						)
+from git.exc import InvalidDBRoot
 import os
 
 __all__ = ('PureGitODB', 'PurePartialGitDB', 'PureCompatibilityGitDB')
@@ -106,7 +96,8 @@ class PureGitODB(PureRootPathDB, PureObjectDBW, PureCompoundDB, PureAlternatesFi
 class PurePartialGitDB(PureGitODB, 
 				PureRepositoryPathsMixin, PureConfigurationMixin, 
 				PureReferencesMixin, PureSubmoduleDB, 
-				PureIndexDB, PureTransportDB
+				PureIndexDB, 
+				PureTransportDB # not fully implemented
 				# HighLevelRepository  Currently not implemented !
 				):
 	"""Git like database with support for object lookup as well as reference resolution.
@@ -122,7 +113,6 @@ class PurePartialGitDB(PureGitODB,
 		super(PurePartialGitDB, self).__init__(self.objects_dir)
 	
 	
-	
 class PureCompatibilityGitDB(PurePartialGitDB, RepoCompatibilityInterface):
 	"""Pure git database with a compatability layer required by 0.3x code"""
 	
diff --git a/git/db/py/resolve.py b/git/db/py/resolve.py
index 7bea779e..9a31fbd8 100644
--- a/git/db/py/resolve.py
+++ b/git/db/py/resolve.py
@@ -361,7 +361,3 @@ class PureReferencesMixin(ReferencesMixin):
 	def delete_tag(self, *tags):
 		return self.TagReferenceCls.delete(self, *tags)
 		
-		
-	# compat
-	branches = heads
-	refs = references