Adjusted all files to (hopefully) deal with the fact that all objects now use 20 byte sha's internally as it is closer to the GitDB implementation

Switched all remaining files back to tabs
Adjusted all remaining docstrings to suit the sphinx doc convention - its likely that there are many of docstring syntax errors though

1 files changed, 68 insertions, 128 deletions

diff --git a/lib/git/objects/base.py b/lib/git/objects/base.py
index 90aa8ca2..118bc3ca 100644
--- a/lib/git/objects/base.py
+++ b/lib/git/objects/base.py
@@ -3,179 +3,140 @@
 #
 # This module is part of GitPython and is released under
 # the BSD License: http://www.opensource.org/licenses/bsd-license.php
-import os
 from git.utils import LazyMixin, join_path_native, stream_copy
-import utils
+from utils import get_object_type_by_name
+from gitdb.util import (
+							hex_to_bin,
+							bin_to_hex,
+							basename
+						)
+
+import gitdb.typ as dbtyp
 	
 _assertion_msg_format = "Created object %r whose python type %r disagrees with the acutal git object type %r"
 
+__all__ = ("Object", "IndexObject")
+
 class Object(LazyMixin):
-	"""
-	Implements an Object which may be Blobs, Trees, Commits and Tags
-	
-	This Object also serves as a constructor for instances of the correct type::
-	
-		inst = Object.new(repo,id)
-		inst.sha		# objects sha in hex
-		inst.size	# objects uncompressed data size
-		inst.data	# byte string containing the whole data of the object
-	"""
+	"""Implements an Object which may be Blobs, Trees, Commits and Tags"""
 	NULL_HEX_SHA = '0'*40
 	NULL_BIN_SHA = '\0'*20
-	TYPES = ("blob", "tree", "commit", "tag")
-	__slots__ = ("repo", "sha", "size", "data" )
+	
+	TYPES = (dbtyp.str_blob_type, dbtyp.str_tree_type, dbtyp.str_commit_type, dbtyp.str_tag_type)
+	__slots__ = ("repo", "binsha", "size" )
 	type = None			# to be set by subclass
 	
-	def __init__(self, repo, id):
-		"""
-		Initialize an object by identifying it by its id. All keyword arguments
-		will be set on demand if None.
+	def __init__(self, repo, binsha):
+		"""Initialize an object by identifying it by its binary sha. 
+		All keyword arguments will be set on demand if None.
 		
-		``repo``
-			repository this object is located in
+		:param repo: repository this object is located in
 			
-		``id``
-			SHA1 or ref suitable for git-rev-parse
-		"""
+		:param binsha: 20 byte SHA1"""
 		super(Object,self).__init__()
 		self.repo = repo
-		self.sha = id
+		self.binsha = binsha
 
 	@classmethod
 	def new(cls, repo, id):
 		"""
-		Return
-			New Object instance of a type appropriate to the object type behind 
-			id. The id of the newly created object will be a hexsha even though 
+		:return: New Object instance of a type appropriate to the object type behind 
+			id. The id of the newly created object will be a binsha even though 
 			the input id may have been a Reference or Rev-Spec
 			
-		Note
-			This cannot be a __new__ method as it would always call __init__
-			with the input id which is not necessarily a hexsha.
-		"""
+		:param id: reference, rev-spec, or hexsha
+			
+		:note: This cannot be a __new__ method as it would always call __init__
+			with the input id which is not necessarily a binsha."""
 		hexsha, typename, size = repo.git.get_object_header(id)
-		obj_type = utils.get_object_type_by_name(typename)
-		inst = obj_type(repo, hexsha)
+		inst = get_object_type_by_name(typename)(repo, hex_to_bin(hexsha))
 		inst.size = size
 		return inst
 	
 	def _set_self_from_args_(self, args_dict):
-		"""
-		Initialize attributes on self from the given dict that was retrieved
+		"""Initialize attributes on self from the given dict that was retrieved
 		from locals() in the calling method.
 		
 		Will only set an attribute on self if the corresponding value in args_dict
-		is not None
-		"""
+		is not None"""
 		for attr, val in args_dict.items():
 			if attr != "self" and val is not None:
 				setattr( self, attr, val )
 		# END set all non-None attributes
 	
 	def _set_cache_(self, attr):
-		"""
-		Retrieve object information
-		"""
+		"""Retrieve object information"""
 		if attr	 == "size":
-			oinfo = self.repo.odb.info(self.sha)
+			oinfo = self.repo.odb.info(self.binsha)
 			self.size = oinfo.size
-			assert oinfo.type == self.type, _assertion_msg_format % (self.sha, oinfo.type, self.type)
-		elif attr == "data":
-			ostream = self.repo.odb.stream(self.sha)
-			self.size = ostream.size
-			self.data = ostream.read()
-			assert ostream.type == self.type, _assertion_msg_format % (self.sha, ostream.type, self.type)
+			# assert oinfo.type == self.type, _assertion_msg_format % (self.binsha, oinfo.type, self.type)
 		else:
 			super(Object,self)._set_cache_(attr)
 		
 	def __eq__(self, other):
-		"""
-		Returns
-			True if the objects have the same SHA1
-		"""
-		return self.sha == other.sha
+		""":return: True if the objects have the same SHA1"""
+		return self.binsha == other.binsha
 		
 	def __ne__(self, other):
-		"""
-		Returns
-			True if the objects do not have the same SHA1
-		"""
-		return self.sha != other.sha
+		""":return: True if the objects do not have the same SHA1 """
+		return self.binsha != other.binsha
 		
 	def __hash__(self):
-		"""
-		Returns
-			Hash of our id allowing objects to be used in dicts and sets
-		"""
-		return hash(self.sha)
+		""":return: Hash of our id allowing objects to be used in dicts and sets"""
+		return hash(self.binsha)
 		
 	def __str__(self):
-		"""
-		Returns
-			string of our SHA1 as understood by all git commands
-		"""
-		return self.sha
+		""":return: string of our SHA1 as understood by all git commands"""
+		return bin_to_hex(self.binsha)
 		
 	def __repr__(self):
-		"""
-		Returns
-			string with pythonic representation of our object
-		"""
-		return '<git.%s "%s">' % (self.__class__.__name__, self.sha)
+		""":return: string with pythonic representation of our object"""
+		return '<git.%s "%s">' % (self.__class__.__name__, self.hexsha)
+
+	@property
+	def hexsha(self):
+		""":return: 40 byte hex version of our 20 byte binary sha"""
+		return bin_to_hex(self.binsha)
 
 	@property
 	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.repo.odb.stream(self.sha)
+		return self.repo.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.repo.odb.stream(self.sha)
+		istream = self.repo.odb.stream(self.binsha)
 		stream_copy(istream, ostream)
 		return self
 		
 
 class IndexObject(Object):
-	"""
-	Base for all objects that can be part of the index file , namely Tree, Blob and
-	SubModule objects
-	"""
+	"""Base for all objects that can be part of the index file , namely Tree, Blob and
+	SubModule objects"""
 	__slots__ = ("path", "mode") 
 	
-	def __init__(self, repo, sha, mode=None, path=None):
-		"""
-		Initialize a newly instanced IndexObject
-		``repo``
-			is the Repo we are located in
-
-		``sha`` : string
-			is the git object id as hex sha
-
-		``mode`` : int
-			is the file mode as int, use the stat module to evaluate the infomration
-
-		``path`` : str
+	def __init__(self, repo, binsha, mode=None, path=None):
+		"""Initialize a newly instanced IndexObject
+		:param repo: is the Repo 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
+		:param path:
 			is the path to the file in the file system, relative to the git repository root, i.e.
 			file.ext or folder/other.ext
-				
-		NOTE
+		:note:
 			Path may not be set of the index object has been created directly as it cannot
-			be retrieved without knowing the parent tree.
-		"""
-		super(IndexObject, self).__init__(repo, sha)
+			be retrieved without knowing the parent tree."""
+		super(IndexObject, self).__init__(repo, binsha)
 		self._set_self_from_args_(locals())
-		if isinstance(mode, basestring):
-			self.mode = self._mode_str_to_int(mode)
 	
 	def __hash__(self):
-		"""
-		Returns
+		""":return:
 			Hash of our path as index items are uniquely identifyable by path, not 
-			by their data !
-		"""
+			by their data !"""
 		return hash(self.path)
 	
 	def _set_cache_(self, attr):
@@ -184,41 +145,20 @@ class IndexObject(Object):
 			raise AttributeError( "path and mode attributes must have been set during %s object creation" % type(self).__name__ )
 		else:
 			super(IndexObject, self)._set_cache_(attr)
+		# END hanlde slot attribute
 	
-	@classmethod
-	def _mode_str_to_int(cls, modestr):
-		"""
-		``modestr``
-			string like 755 or 644 or 100644 - only the last 6 chars will be used
-			
-		Returns
-			String identifying a mode compatible to the mode methods ids of the 
-			stat module regarding the rwx permissions for user, group and other, 
-			special flags and file system flags, i.e. whether it is a symlink
-			for example.
-		"""
-		mode = 0
-		for iteration, char in enumerate(reversed(modestr[-6:])):
-			mode += int(char) << iteration*3
-		# END for each char
-		return mode
-		
 	@property
 	def name(self):
-		"""
-		Returns
-			Name portion of the path, effectively being the basename
-		"""
-		return os.path.basename(self.path)
+		""":return: Name portion of the path, effectively being the basename"""
+		return basename(self.path)
 		
 	@property
 	def abspath(self):
 		"""
-		Returns
+		:return:
 			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. 
-		"""
+			The returned path will be native to the system and contains '\' on windows. """
 		return join_path_native(self.repo.working_tree_dir, self.path)