First rename session, db/test_base.py works, but there is much more work to do

Author: Byron

gitdb/db/py/__init__.py

@@ -9,4 +9,5 @@
 from pack import *
 from git import *
 from ref import *
-
+from resolve import *
+from transport import *

gitdb/db/py/base.py

@@ -35,8 +35,8 @@
 import os
 
 
-__all__ = (	'PureObjectDBR', 'PureObjectDBW', 'PureRootPathDBBase', 'PureCompoundDB', 
-			'NameResolveMixin', 'PureConfigurationMixin', 'PureRepositoryPathsMixin')
+__all__ = (	'PureObjectDBR', 'PureObjectDBW', 'PureRootPathDB', 'PureCompoundDB', 
+			'PureConfigurationMixin', 'PureRepositoryPathsMixin')
 
 
 class PureObjectDBR(ObjectDBR):
@@ -83,10 +83,10 @@ def store_async(self, reader):
 	#} END edit interface
 
 
-class PureRootPathDBBase(RootPathDBBase):
+class PureRootPathDB(RootPathDB):
 
 	def __init__(self, root_path):
-		super(PureRootPathDBBase, self).__init__()
+		super(PureRootPathDB, self).__init__(root_path)
 		self._root_path = root_path
 
 

gitdb/db/py/git.py

@@ -1,20 +1,20 @@
 # Copyright (C) 2010, 2011 Sebastian Thiel (byronimo@gmail.com) and contributors
 #
-# This module is part of GitDB and is released under
+# This module is part of PureGitDB and is released under
 # the New BSD License: http://www.opensource.org/licenses/bsd-license.php
 from base import (
-						CompoundDB, 
-						ObjectDBW, 
-						RootPathDBBase, 
-						RepositoryPathsMixin,
-						ConfigurationMixin,
+						PureCompoundDB, 
+						PureObjectDBW, 
+						PureRootPathDB, 
+						PureRepositoryPathsMixin,
+						PureConfigurationMixin,
 					)
 
-from resolve import NameResolvePureMixin
+from resolve import PureReferencesMixin
 
-from loose import LooseObjectDB
-from pack import PackedDB
-from ref import ReferenceDB
+from loose import PureLooseObjectODB
+from pack import PurePackedODB
+from ref import PureReferenceDB
 
 from gitdb.util import (
 						LazyMixin, 
@@ -29,19 +29,19 @@
 						)
 import os
 
-__all__ = ('GitODB', 'GitDB')
+__all__ = ('PureGitODB', 'PureGitDB')
 
 
-class GitODB(RootPathDBBase, ObjectDBW, CompoundDB):
+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 GitDB type if you need
+		as it deals solely with object lookup. Use a PureGitDB type if you need
 		reference and push support."""
 	# Configuration
-	PackDBCls = PackedDB
-	LooseDBCls = LooseObjectDB
-	ReferenceDBCls = ReferenceDB
+	PackDBCls = PurePackedODB
+	LooseDBCls = PureLooseObjectODB
+	PureReferenceDBCls = PureReferenceDB
 
 	# Directories
 	packs_dir = 'pack'
@@ -50,15 +50,15 @@ class GitODB(RootPathDBBase, ObjectDBW, CompoundDB):
 
 	def __init__(self, root_path):
 		"""Initialize ourselves on a git ./objects directory"""
-		super(GitODB, self).__init__(root_path)
+		super(PureGitODB, self).__init__(root_path)
 
 	def _set_cache_(self, attr):
 		if attr == '_dbs' or attr == '_loose_db':
 			self._dbs = list()
 			loose_db = None
 			for subpath, dbcls in ((self.packs_dir, self.PackDBCls), 
 									(self.loose_dir, self.LooseDBCls),
-									(self.alternates_dir, self.ReferenceDBCls)):
+									(self.alternates_dir, self.PureReferenceDBCls)):
 				path = self.db_path(subpath)
 				if os.path.exists(path):
 					self._dbs.append(dbcls(path))
@@ -79,10 +79,10 @@ def _set_cache_(self, attr):
 			# finally set the value
 			self._loose_db = loose_db
 		else:
-			super(GitODB, self)._set_cache_(attr)
+			super(PureGitODB, self)._set_cache_(attr)
 		# END handle attrs
 
-	#{ ObjectDBW interface
+	#{ PureObjectDBW interface
 
 	def store(self, istream):
 		return self._loose_db.store(istream)
@@ -96,7 +96,7 @@ def set_ostream(self, ostream):
 	#} END objectdbw interface
 
 
-class GitDB(GitODB, RepositoryPathsMixin, ConfigurationMixin, NameResolvePureMixin):
+class PureGitDB(PureGitODB, PureRepositoryPathsMixin, PureConfigurationMixin, PureReferencesMixin):
 	"""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).
 	
@@ -106,8 +106,8 @@ class GitDB(GitODB, RepositoryPathsMixin, ConfigurationMixin, NameResolvePureMix
 
 	def __init__(self, root_path):
 		"""Initialize ourselves on the .git directory, or the .git/objects directory."""
-		RepositoryPathsMixin._initialize(self, root_path)
-		super(GitDB, self).__init__(self.objects_path())
+		PureRepositoryPathsMixin._initialize(self, root_path)
+		super(PureGitDB, self).__init__(self.objects_path())
 
 
 

gitdb/db/py/loose.py

@@ -3,9 +3,9 @@
 # This module is part of GitDB and is released under
 # the New BSD License: http://www.opensource.org/licenses/bsd-license.php
 from base import (
-						RootPathDBBase, 
-						ObjectDBR, 
-						ObjectDBW
+						PureRootPathDB, 
+						PureObjectDBR, 
+						PureObjectDBW
 				)
 
 
@@ -57,10 +57,10 @@
 import os
 
 
-__all__ = ( 'LooseObjectDB', )
+__all__ = ( 'PureLooseObjectODB', )
 
 
-class LooseObjectDB(RootPathDBBase, ObjectDBR, ObjectDBW):
+class PureLooseObjectODB(PureRootPathDB, PureObjectDBR, PureObjectDBW):
 	"""A database which operates on loose object files"""
 
 	# CONFIGURATION
@@ -75,7 +75,7 @@ class LooseObjectDB(RootPathDBBase, ObjectDBR, ObjectDBW):
 
 
 	def __init__(self, root_path):
-		super(LooseObjectDB, self).__init__(root_path)
+		super(PureLooseObjectODB, self).__init__(root_path)
 		self._hexsha_to_file = dict()
 		# Additional Flags - might be set to 0 after the first failure
 		# Depending on the root, this might work for some mounts, for others not, which
@@ -156,7 +156,7 @@ def set_ostream(self, stream):
 		""":raise TypeError: if the stream does not support the Sha1Writer interface"""
 		if stream is not None and not isinstance(stream, Sha1Writer):
 			raise TypeError("Output stream musst support the %s interface" % Sha1Writer.__name__)
-		return super(LooseObjectDB, self).set_ostream(stream)
+		return super(PureLooseObjectODB, self).set_ostream(stream)
 
 	def info(self, sha):
 		m = self._map_loose_object(sha)

gitdb/db/py/mem.py

@@ -3,10 +3,10 @@
 # This module is part of GitDB and is released under
 # the New BSD License: http://www.opensource.org/licenses/bsd-license.php
 """Contains the MemoryDatabase implementation"""
-from loose import LooseObjectDB
+from loose import PureLooseObjectODB
 from base import (
-						ObjectDBR, 
-						ObjectDBW
+						PureObjectDBR, 
+						PureObjectDBW
 					)
 
 from gitdb.base import (
@@ -25,9 +25,9 @@
 
 from cStringIO import StringIO
 
-__all__ = ("MemoryDB", )
+__all__ = ("PureMemoryDB", )
 
-class MemoryDB(ObjectDBR, ObjectDBW):
+class PureMemoryDB(PureObjectDBR, PureObjectDBW):
 	"""A memory database stores everything to memory, providing fast IO and object
 	retrieval. It should be used to buffer results and obtain SHAs before writing
 	it to the actual physical storage, as it allows to query whether object already
@@ -37,14 +37,14 @@ class MemoryDB(ObjectDBR, ObjectDBW):
 		for storing"""
 
 	def __init__(self):
-		super(MemoryDB, self).__init__()
-		self._db = LooseObjectDB("path/doesnt/matter")
+		super(PureMemoryDB, self).__init__()
+		self._db = PureLooseObjectODB("path/doesnt/matter")
 
 		# maps 20 byte shas to their OStream objects
 		self._cache = dict()
 
 	def set_ostream(self, stream):
-		raise UnsupportedOperation("MemoryDB's always stream into memory")
+		raise UnsupportedOperation("PureMemoryDB's always stream into memory")
 
 	def store(self, istream):
 		zstream = ZippedStoreShaWriter()
@@ -62,7 +62,7 @@ def store(self, istream):
 		return istream
 
 	def store_async(self, reader):
-		raise UnsupportedOperation("MemoryDBs cannot currently be used for async write access")
+		raise UnsupportedOperation("PureMemoryDBs cannot currently be used for async write access")
 
 	def has_object(self, sha):
 		return sha in self._cache

gitdb/db/py/pack.py

@@ -3,10 +3,10 @@
 # This module is part of GitDB and is released under
 # the New BSD License: http://www.opensource.org/licenses/bsd-license.php
 """Module containing a database to deal with packs"""
+from gitdb.db import CachingDB
 from base import (
-						RootPathDBBase, 
-						ObjectDBR, 
-						CachingDB
+						PureRootPathDB, 
+						PureObjectDBR 
 				)
 
 from gitdb.util import LazyMixin
@@ -22,12 +22,12 @@
 import os
 import glob
 
-__all__ = ('PackedDB', )
+__all__ = ('PurePackedODB', )
 
 #{ Utilities
 
 
-class PackedDB(RootPathDBBase, ObjectDBR, CachingDB, LazyMixin):
+class PurePackedODB(PureRootPathDB, PureObjectDBR, CachingDB, LazyMixin):
 	"""A database operating on a set of object packs"""
 
 	# the type to use when instantiating a pack entity
@@ -39,7 +39,7 @@ class PackedDB(RootPathDBBase, ObjectDBR, CachingDB, LazyMixin):
 	_sort_interval = 500
 
 	def __init__(self, root_path):
-		super(PackedDB, self).__init__(root_path)
+		super(PurePackedODB, self).__init__(root_path)
 		# list of lists with three items:
 		# * hits - number of times the pack was hit with a request
 		# * entity - Pack entity instance
@@ -127,7 +127,7 @@ def store(self, istream):
 		raise UnsupportedOperation()
 
 	def store_async(self, reader):
-		# TODO: add ObjectDBRW before implementing this
+		# TODO: add PureObjectDBRW before implementing this
 		raise NotImplementedError()
 
 	#} END object db write

gitdb/db/py/ref.py

@@ -2,14 +2,12 @@
 #
 # This module is part of GitDB and is released under
 # the New BSD License: http://www.opensource.org/licenses/bsd-license.php
-from base import (
-					CompoundDB,
-				)
+from base import PureCompoundDB
 
 import os
-__all__ = ('ReferenceDB', )
+__all__ = ('PureReferenceDB', )
 
-class ReferenceDB(CompoundDB):
+class PureReferenceDB(PureCompoundDB):
 	"""A database consisting of database referred to in a file"""
 
 	# Configuration
@@ -18,15 +16,15 @@ class ReferenceDB(CompoundDB):
 	ObjectDBCls = None
 
 	def __init__(self, ref_file):
-		super(ReferenceDB, self).__init__()
+		super(PureReferenceDB, self).__init__()
 		self._ref_file = ref_file
 
 	def _set_cache_(self, attr):
 		if attr == '_dbs':
 			self._dbs = list()
 			self._update_dbs_from_ref_file()
 		else:
-			super(ReferenceDB, self)._set_cache_(attr)
+			super(PureReferenceDB, self)._set_cache_(attr)
 		# END handle attrs
 
 	def _update_dbs_from_ref_file(self):
@@ -64,7 +62,7 @@ def _update_dbs_from_ref_file(self):
 			try:
 				db = dbcls(path)
 				# force an update to verify path
-				if isinstance(db, CompoundDB):
+				if isinstance(db, PureCompoundDB):
 					db.databases()
 				# END verification
 				self._dbs.append(db)
@@ -76,4 +74,4 @@ def _update_dbs_from_ref_file(self):
 	def update_cache(self, force=False):
 		# re-read alternates and update databases
 		self._update_dbs_from_ref_file()
-		return super(ReferenceDB, self).update_cache(force)
+		return super(PureReferenceDB, self).update_cache(force)

gitdb/db/py/resolve.py

@@ -17,7 +17,7 @@
 import os
 import re
 
-__all__ = ["NameResolvePureMixin"]
+__all__ = ["PureReferencesMixin"]
 
 #{ Utilities
 

gitdb/test/db/lib.py

@@ -13,6 +13,10 @@
 
 from gitdb.stream import Sha1Writer
 
+# import database types we want to support
+# they will be set to None if the respective library could not be loaded
+from gitdb.db.py import PureGitDB
+
 from gitdb.base import (
 							IStream,
 							OStream,
@@ -36,6 +40,9 @@ class TestDBBase(TestBase):
 	two_lines = "1234\nhello world"
 	all_data = (two_lines, )
 
+	# all supported database types. Add your own type 
+	ref_db_types = (PureGitDB, )
+	
 	def _assert_object_writing_simple(self, db):
 		# write a bunch of objects and query their streams and info
 		null_objs = db.size()

gitdb/test/db/test_loose.py

@@ -3,15 +3,15 @@
 # This module is part of GitDB and is released under
 # the New BSD License: http://www.opensource.org/licenses/bsd-license.php
 from lib import *
-from gitdb.db import LooseObjectDB
+from gitdb.db import PureLooseObjectODB
 from gitdb.exc import BadObject
 from gitdb.util import bin_to_hex
 
 class TestLooseDB(TestDBBase):
 
 	@with_rw_directory
 	def test_basics(self, path):
-		ldb = LooseObjectDB(path)
+		ldb = PureLooseObjectODB(path)
 
 		# write data
 		self._assert_object_writing(ldb)