@@ -6,3 +6,4 @@
 /dist
 /doc/_build
 nbproject
+.nosebazinga
@@ -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 @@ def active_branch(self):
 		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
@@ -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()
@@ -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
+
@@ -561,16 +561,8 @@ def delete_tag(self, *tags):
 		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.
 
@@ -104,7 +104,6 @@ def __init__(self, root_path):
 		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 @@ def databases(self):
 
 	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 @@ def partial_to_complete_sha(self, partial_binsha, hex_len):
 
 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 @@ def _initialize(self, path):
 			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 @@ def git_dir(self):
 
 	@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 
 
@@ -22,17 +22,7 @@
 
 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 @@ def set_ostream(self, ostream):
 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 @@ def __init__(self, root_path):
 		super(PurePartialGitDB, self).__init__(self.objects_dir)
 
 
-	
 class PureCompatibilityGitDB(PurePartialGitDB, RepoCompatibilityInterface):
 	"""Pure git database with a compatability layer required by 0.3x code"""
 
@@ -361,7 +361,3 @@ def create_tag(self, path, ref='HEAD', message=None, force=False, **kwargs):
 	def delete_tag(self, *tags):
 		return self.TagReferenceCls.delete(self, *tags)
 
-		
-	# compat
-	branches = heads
-	refs = references
@@ -601,20 +601,26 @@ def test_rev_parse(self):
 		self.failUnlessRaises(NotImplementedError, rev_parse, "@{1 week ago}")
 
 	def test_submodules(self):
-		assert len(self.rorepo.submodules) == 1		# non-recursive
+		assert len(self.rorepo.submodules) == 2		# non-recursive
 		# in previous configurations, we had recursive repositories so this would compare to 2
-		# now there is only one left, as gitdb was merged
-		assert len(list(self.rorepo.iter_submodules())) == 1
+		# now there is only one left, as gitdb was merged, but we have smmap instead
+		assert len(list(self.rorepo.iter_submodules())) == 2
 
-		assert isinstance(self.rorepo.submodule("git/ext/async"), Submodule)
+		assert isinstance(self.rorepo.submodule("async"), Submodule)
 		self.failUnlessRaises(ValueError, self.rorepo.submodule, "doesn't exist")
 
 	@with_rw_repo('HEAD', bare=False)
 	def test_submodule_update(self, rwrepo):
 		# fails in bare mode
 		rwrepo._bare = True
+		# special handling: there are repo implementations which have a bare attribute. IN that case, set it directly
+		if not rwrepo.bare:
+			rwrepo.bare = True
 		self.failUnlessRaises(InvalidGitRepositoryError, rwrepo.submodule_update)
 		rwrepo._bare = False
+		if rwrepo.bare:
+			rwrepo.bare = False
+		#END special repo handling
 
 		# test create submodule
 		sm = rwrepo.submodules[0]
 
@@ -0,0 +1,4 @@
+# Copyright (C) 2010, 2011 Sebastian Thiel (byronimo@gmail.com) and contributors
+#
+# This module is part of GitDB and is released under
+# the New BSD License: http://www.opensource.org/licenses/bsd-license.php