object: renamed id attribute to sha as it in fact is always being rewritten as sha, even if the passed in id was a ref. This is done to assure objects are uniquely identified and will compare correctly

Author: Byron

TODO

@@ -27,15 +27,6 @@ Object
   It would be good to improve things there as cat-file keeps all the data in a buffer
   before it writes it. Hence it does not write to a stream directly, which can be 
   bad if files are large, say 1GB :).
-* Effectively Objects only store hexsha's in their id attributes, so in fact 
-  it should be renamed to 'sha'. There was a time when references where allowed as 
-  well, but now objects will be 'baked' to the actual sha to assure comparisons work.
-  
-Commit
-------
-* message is stipped during parsing, which is wrong unless we parse from 
-  rev-list output. In fact we don't know that, and can't really tell either.
-  Currently we strip away white space that might actually belong to the message
 
 Config
 ------
@@ -115,7 +106,9 @@ Repo
 * Blame: Read the blame format making assumptions about its structure, 
   currently regex are used a lot although we can deduct what will be next.
   - Read data from a stream directly from git command
-* Figure out how to implement a proper merge API
+* Figure out how to implement a proper merge API. It should be index based, but provide 
+  all necessary information to the ones willing to ask for it. The index implementation 
+  actually provides this already, but some real use-cases would be great to have a least.
 * repo.checkout should be added that does everything HEAD.reset does, but in addition
   it allows to checkout heads beforehand, hence its more like a repo.head.reference = other_head.
 

lib/git/diff.py

@@ -186,11 +186,11 @@ def __init__(self, repo, a_path, b_path, a_blob_id, b_blob_id, a_mode,
 		if not a_blob_id or self.re_is_null_hexsha.search(a_blob_id):
 			self.a_blob = None
 		else:
-			self.a_blob = blob.Blob(repo, id=a_blob_id, mode=a_mode, path=a_path)
+			self.a_blob = blob.Blob(repo, a_blob_id, mode=a_mode, path=a_path)
 		if not b_blob_id or self.re_is_null_hexsha.search(b_blob_id):
 			self.b_blob = None
 		else:
-			self.b_blob = blob.Blob(repo, id=b_blob_id, mode=b_mode, path=b_path)
+			self.b_blob = blob.Blob(repo, b_blob_id, mode=b_mode, path=b_path)
 
 		self.a_mode = a_mode
 		self.b_mode = b_mode

lib/git/index.py

@@ -92,7 +92,7 @@ def from_blob(cls, blob, stage = 0):
 		Returns
 			Fully equipped BaseIndexEntry at the given stage
 		"""
-		return cls((blob.mode, blob.id, stage, blob.path))
+		return cls((blob.mode, blob.sha, stage, blob.path))
 
 
 class IndexEntry(BaseIndexEntry):
@@ -165,7 +165,7 @@ def from_blob(cls, blob):
 			Minimal entry resembling the given blob objecft
 		"""
 		time = struct.pack(">LL", 0, 0)
-		return IndexEntry((blob.mode, blob.id, 0, blob.path, time, time, 0, 0, 0, 0, blob.size))
+		return IndexEntry((blob.mode, blob.sha, 0, blob.path, time, time, 0, 0, 0, 0, blob.size))
 
 
 def clear_cache(func):

lib/git/objects/base.py

@@ -16,13 +16,13 @@ class Object(LazyMixin):
 	This Object also serves as a constructor for instances of the correct type::
 	
 		inst = Object.new(repo,id)
-		inst.id		# objects sha in hex
+		inst.sha		# objects sha in hex
 		inst.size	# objects uncompressed data size
 		inst.data	# byte string containing the whole data of the object
 	"""
 	NULL_HEX_SHA = '0'*40
 	TYPES = ("blob", "tree", "commit", "tag")
-	__slots__ = ("repo", "id", "size", "data" )
+	__slots__ = ("repo", "sha", "size", "data" )
 	type = None			# to be set by subclass
 
 	def __init__(self, repo, id):
@@ -38,7 +38,7 @@ def __init__(self, repo, id):
 		"""
 		super(Object,self).__init__()
 		self.repo = repo
-		self.id = id
+		self.sha = id
 
 	@classmethod
 	def new(cls, repo, id):
@@ -76,11 +76,11 @@ def _set_cache_(self, attr):
 		Retrieve object information
 		"""
 		if attr  == "size":
-			hexsha, typename, self.size = self.repo.git.get_object_header(self.id)
-			assert typename == self.type, _assertion_msg_format % (self.id, typename, self.type)
+			hexsha, typename, self.size = self.repo.git.get_object_header(self.sha)
+			assert typename == self.type, _assertion_msg_format % (self.sha, typename, self.type)
 		elif attr == "data":
-			hexsha, typename, self.size, self.data = self.repo.git.get_object_data(self.id)
-			assert typename == self.type, _assertion_msg_format % (self.id, typename, self.type)
+			hexsha, typename, self.size, self.data = self.repo.git.get_object_data(self.sha)
+			assert typename == self.type, _assertion_msg_format % (self.sha, typename, self.type)
 		else:
 			super(Object,self)._set_cache_(attr)
 
@@ -89,43 +89,43 @@ def __eq__(self, other):
 		Returns
 			True if the objects have the same SHA1
 		"""
-		return self.id == other.id
+		return self.sha == other.sha
 
 	def __ne__(self, other):
 		"""
 		Returns
 			True if the objects do not have the same SHA1
 		"""
-		return self.id != other.id
+		return self.sha != other.sha
 
 	def __hash__(self):
 		"""
 		Returns
 			Hash of our id allowing objects to be used in dicts and sets
 		"""
-		return hash(self.id)
+		return hash(self.sha)
 
 	def __str__(self):
 		"""
 		Returns
 			string of our SHA1 as understood by all git commands
 		"""
-		return self.id
+		return self.sha
 
 	def __repr__(self):
 		"""
 		Returns
 			string with pythonic representation of our object
 		"""
-		return '<git.%s "%s">' % (self.__class__.__name__, self.id)
+		return '<git.%s "%s">' % (self.__class__.__name__, self.sha)
 
 	@property
 	def data_stream(self):
 		"""
 		Returns 
 			File Object compatible stream to the uncompressed raw data of the object
 		"""
-		proc = self.repo.git.cat_file(self.type, self.id, as_process=True)
+		proc = self.repo.git.cat_file(self.type, self.sha, as_process=True)
 		return utils.ProcessStreamAdapter(proc, "stdout") 
 
 	def stream_data(self, ostream):
@@ -138,7 +138,7 @@ def stream_data(self, ostream):
 		Returns
 			self
 		"""
-		self.repo.git.cat_file(self.type, self.id, output_stream=ostream)
+		self.repo.git.cat_file(self.type, self.sha, output_stream=ostream)
 		return self
 
 class IndexObject(Object):
@@ -148,13 +148,13 @@ class IndexObject(Object):
 	"""
 	__slots__ = ("path", "mode") 
 
-	def __init__(self, repo, id, mode=None, path=None):
+	def __init__(self, repo, sha, mode=None, path=None):
 		"""
 		Initialize a newly instanced IndexObject
 		``repo``
 			is the Repo we are located in
 
-		``id`` : string
+		``sha`` : string
 			is the git object id as hex sha
 
 		``mode`` : int
@@ -168,7 +168,7 @@ def __init__(self, repo, id, mode=None, path=None):
 			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, id)
+		super(IndexObject, self).__init__(repo, sha)
 		self._set_self_from_args_(locals())
 		if isinstance(mode, basestring):
 			self.mode = self._mode_str_to_int(mode)

lib/git/objects/blob.py

@@ -33,4 +33,4 @@ def mime_type(self):
 
 
 	def __repr__(self):
-		return '<git.Blob "%s">' % self.id
+		return '<git.Blob "%s">' % self.sha

lib/git/objects/commit.py

@@ -23,17 +23,17 @@ class Commit(base.Object, Iterable, diff.Diffable):
 	type = "commit"
 	__slots__ = ("tree", "author", "authored_date", "committer", "committed_date",
 					"message", "parents")
-	_id_attribute_ = "id"
+	_id_attribute_ = "sha"
 
-	def __init__(self, repo, id, tree=None, author=None, authored_date=None,
+	def __init__(self, repo, sha, tree=None, author=None, authored_date=None,
 				 committer=None, committed_date=None, message=None, parents=None):
 		"""
 		Instantiate a new Commit. All keyword arguments taking None as default will 
 		be implicitly set if id names a valid sha. 
 		
 		The parameter documentation indicates the type of the argument after a colon ':'.
 
-		``id``
+		``sha``
 			is the sha id of the commit or a ref
 
 		``parents`` : tuple( Commit, ... )
@@ -62,15 +62,15 @@ def __init__(self, repo, id, tree=None, author=None, authored_date=None,
 		Returns
 			git.Commit
 		"""
-		super(Commit,self).__init__(repo, id)
+		super(Commit,self).__init__(repo, sha)
 		self._set_self_from_args_(locals())
 
 		if parents is not None:
 			self.parents = tuple( self.__class__(repo, p) for p in parents )
 		# END for each parent to convert
 
-		if self.id and tree is not None:
-			self.tree = Tree(repo, id=tree, path='')
+		if self.sha and tree is not None:
+			self.tree = Tree(repo, tree, path='')
 		# END id to tree conversion
 
 	def _set_cache_(self, attr):
@@ -82,7 +82,7 @@ def _set_cache_(self, attr):
 		if attr in Commit.__slots__:
 			# prepare our data lines to match rev-list
 			data_lines = self.data.splitlines()
-			data_lines.insert(0, "commit %s" % self.id)
+			data_lines.insert(0, "commit %s" % self.sha)
 			temp = self._iter_from_process_or_stream(self.repo, iter(data_lines), False).next()
 			self.parents = temp.parents
 			self.tree = temp.tree
@@ -116,7 +116,7 @@ def count(self, paths='', **kwargs):
 		Returns
 			int
 		"""
-		return len(self.repo.git.rev_list(self.id, '--', paths, **kwargs).strip().splitlines())
+		return len(self.repo.git.rev_list(self.sha, '--', paths, **kwargs).strip().splitlines())
 
 	@property
 	def name_rev(self):
@@ -189,14 +189,14 @@ def stats(self):
 			git.Stats
 		"""
 		if not self.parents:
-			text = self.repo.git.diff_tree(self.id, '--', numstat=True, root=True)
+			text = self.repo.git.diff_tree(self.sha, '--', numstat=True, root=True)
 			text2 = ""
 			for line in text.splitlines()[1:]:
 				(insertions, deletions, filename) = line.split("\t")
 				text2 += "%s\t%s\t%s\n" % (insertions, deletions, filename)
 			text = text2
 		else:
-			text = self.repo.git.diff(self.parents[0].id, self.id, '--', numstat=True)
+			text = self.repo.git.diff(self.parents[0].sha, self.sha, '--', numstat=True)
 		return stats.Stats._list_from_string(self.repo, text)
 
 	@classmethod
@@ -259,15 +259,15 @@ def _iter_from_process_or_stream(cls, repo, proc_or_stream, from_rev_list):
 			# END message parsing
 			message = '\n'.join(message_lines)
 
-			yield Commit(repo, id=id, parents=tuple(parents), tree=tree, author=author, authored_date=authored_date,
+			yield Commit(repo, id, parents=tuple(parents), tree=tree, author=author, authored_date=authored_date,
 						  committer=committer, committed_date=committed_date, message=message)
 		# END for each line in stream
 
 
 	def __str__(self):
 		""" Convert commit to string which is SHA1 """
-		return self.id
+		return self.sha
 
 	def __repr__(self):
-		return '<git.Commit "%s">' % self.id
+		return '<git.Commit "%s">' % self.sha
 

lib/git/objects/tag.py

@@ -17,15 +17,15 @@ class TagObject(base.Object):
 	type = "tag"
 	__slots__ = ( "object", "tag", "tagger", "tagged_date", "message" )
 
-	def __init__(self, repo, id, object=None, tag=None, 
+	def __init__(self, repo, sha, object=None, tag=None, 
 				tagger=None, tagged_date=None, message=None):
 		"""
 		Initialize a tag object with additional data
 		
 		``repo``
 			repository this object is located in
 			
-		``id``
+		``sha``
 			SHA1 or ref suitable for git-rev-parse
 			
 		 ``object``
@@ -41,7 +41,7 @@ def __init__(self, repo, id, object=None, tag=None,
 			is the DateTime of the tag creation - use time.gmtime to convert 
 			it into a different format
 		"""
-		super(TagObject, self).__init__(repo, id )
+		super(TagObject, self).__init__(repo, sha )
 		self._set_self_from_args_(locals())
 
 	def _set_cache_(self, attr):

lib/git/objects/tree.py

@@ -43,8 +43,8 @@ class Tree(base.IndexObject, diff.Diffable):
 	tree_id = 040
 
 
-	def __init__(self, repo, id, mode=0, path=None):
-		super(Tree, self).__init__(repo, id, mode, path)
+	def __init__(self, repo, sha, mode=0, path=None):
+		super(Tree, self).__init__(repo, sha, mode, path)
 
 	def _set_cache_(self, attr):
 		if attr == "_cache":
@@ -150,7 +150,7 @@ def __div__(self, file):
 
 
 	def __repr__(self):
-		return '<git.Tree "%s">' % self.id
+		return '<git.Tree "%s">' % self.sha
 
 	@classmethod
 	def _iter_recursive(cls, repo, tree, cur_depth, max_depth, predicate, prune ):

lib/git/refs.py

@@ -312,17 +312,17 @@ def _set_reference(self, ref):
 		if isinstance(ref, Head):
 			write_value = "ref: %s" % ref.path
 		elif isinstance(ref, Commit):
-			write_value = ref.id
+			write_value = ref.sha
 		else:
 			try:
-				write_value = ref.commit.id
+				write_value = ref.commit.sha
 			except AttributeError:
 				sha = str(ref)
 				try:
 					obj = Object.new(self.repo, sha)
 					if obj.type != "commit":
 						raise TypeError("Invalid object type behind sha: %s" % sha)
-					write_value = obj.id
+					write_value = obj.sha
 				except Exception:
 					raise ValueError("Could not extract object from %s" % ref)
 			# END end try string  
@@ -428,7 +428,7 @@ class Head(Reference):
 		>>> head.commit		
 		<git.Commit "1c09f116cbc2cb4100fb6935bb162daa4723f455">
 
-		>>> head.commit.id
+		>>> head.commit.sha
 		'1c09f116cbc2cb4100fb6935bb162daa4723f455'
 	"""
 	_common_path_default = "refs/heads"

lib/git/repo.py

@@ -622,7 +622,7 @@ def blame(self, rev, file):
 							sha = info['id']
 							c = commits.get(sha)
 							if c is None:
-								c = Commit(  self, id=sha,
+								c = Commit(  self, sha,
 											 author=Actor._from_string(info['author'] + ' ' + info['author_email']),
 											 authored_date=info['author_date'],
 											 committer=Actor._from_string(info['committer'] + ' ' + info['committer_email']),