Merge branch 'diffing' into improvements

* diffing:
  DiffIndex implemented including test
  diff: implemented raw diff parsing which appears to be able to handle possible input types, DiffIndex still requires implementation though
  resolved cyclic inclusion issue by moving the Diffable interface into the diff module, which probably is the right thing to do anyway
  repo: fixed untracked files function which used git-commit before, it can open vim to get a message though which makes the program appear to freeze - using git-status now
  implemented diff tests, but will have to move the diff module as it needs to create objects, whose import would create a dependency cycle
  Removed a few diff-related test cases that fail now as the respective method is missing - these tests have to be redone in test-diff module accordingly
  added Diffable interface to objects.base, its used by Commit and Tree objects.
  Fixed object bug that would cause object ids not to be resolved to sha's as this was assumed - now there is a test for it as well

Author: Byron

CHANGES

@@ -27,6 +27,9 @@ General
   terms are used everywhere, such as "Reference" ( ref ) and "Revision" ( rev ).
   Prevously multiple terms where used making it harder to know which type was allowed
   or not.
+* Unified diff interface to allow easy diffing between trees, trees and index, trees
+  and working tree, index and working tree, trees and index. This closely follows
+  the git-diff capabilities.
 
 
 Item Iteration
@@ -60,6 +63,8 @@ Repo
      related repositories, i.e. clones, git-rev-list would be sufficient to find 
      commits that would need to be transferred for example.
   - 'create' method which equals the 'init' method's functionality
+  - 'diff' - it returned a mere string which still had to be parsed
+  - 'commit_diff' - moved to Commit, Tree and Diff types respectively
 * Renamed the following methods:
   - commits to iter_commits to improve the performance, adjusted signature
   - init_bare to init, implying less about the options to be used
@@ -75,6 +80,13 @@ Diff
 * Members a a_commit and b_commit renamed to a_blob and b_blob - they are populated
   with Blob objects if possible
 * Members a_path and b_path removed as this information is kept in the blobs
+* Diffs are now returned as DiffIndex allowing to more quickly find the kind of 
+  diffs you are interested in
+  
+Diffing
+-------
+* Commit and Tree objects now support diffing natively with a common interface to 
+  compare agains other Commits or Trees, against the working tree or against the index.
 
 Blob
 ----

lib/git/__init__.py

@@ -12,7 +12,7 @@
 from git.objects import *
 from git.refs import *
 from git.actor import Actor
-from git.diff import Diff
+from git.diff import *
 from git.errors import InvalidGitRepositoryError, NoSuchPathError, GitCommandError
 from git.cmd import Git
 from git.repo import Repo

lib/git/diff.py

@@ -7,9 +7,128 @@
 import re
 import objects.blob as blob
 
+	
+class Diffable(object):
+	"""
+	Common interface for all object that can be diffed against another object of compatible type.
+	
+	NOTE: 
+		Subclasses require a repo member as it is the case for Object instances, for practical 
+		reasons we do not derive from Object.
+	"""
+	__slots__ = tuple()
+	
+	# subclasses provide additional arguments to the git-diff comamnd by supplynig 
+	# them in this tuple
+	_diff_args = tuple()
+	
+	# Temporary standin for Index type until we have a real index type
+	class Index(object):
+		pass 
+	
+	def diff(self, other=None, paths=None, create_patch=False, **kwargs):
+		"""
+		Creates diffs between two items being trees, trees and index or an 
+		index and the working tree.
+
+		``other``
+			Is the item to compare us with. 
+			If None, we will be compared to the working tree.
+			If Index ( type ), it will be compared against the index
+
+		``paths``
+			is a list of paths or a single path to limit the diff to.
+			It will only include at least one of the givne path or paths.
+
+		``create_patch``
+			If True, the returned Diff contains a detailed patch that if applied
+			makes the self to other. Patches are somwhat costly as blobs have to be read
+			and diffed.
+
+		``kwargs``
+			Additional arguments passed to git-diff, such as 
+			R=True to swap both sides of the diff.
+
+		Returns
+			git.DiffIndex
+			
+		Note
+			Rename detection will only work if create_patch is True
+		"""
+		args = list(self._diff_args[:])
+		args.append( "--abbrev=40" )		# we need full shas
+		args.append( "--full-index" )		# get full index paths, not only filenames
+		
+		if create_patch:
+			args.append("-p")
+			args.append("-M") # check for renames
+		else:
+			args.append("--raw")
+		
+		if paths is not None and not isinstance(paths, (tuple,list)):
+			paths = [ paths ]
+
+		if other is not None and other is not self.Index:
+			args.insert(0, other)
+		if other is self.Index:
+			args.insert(0, "--cached")
+		
+		args.insert(0,self)
+		
+		# paths is list here or None
+		if paths:
+			args.append("--")
+			args.extend(paths)
+		# END paths handling
+		
+		kwargs['as_process'] = True
+		proc = self.repo.git.diff(*args, **kwargs)
+		
+		diff_method = Diff._index_from_raw_format
+		if create_patch:
+			diff_method = Diff._index_from_patch_format
+		return diff_method(self.repo, proc.stdout)
+
+
+class DiffIndex(list):
+	"""
+	Implements an Index for diffs, allowing a list of Diffs to be queried by 
+	the diff properties.
+	
+	The class improves the diff handling convenience
+	"""
+	# change type invariant identifying possible ways a blob can have changed
+	# A = Added
+	# D = Deleted
+	# R = Renamed
+	# NOTE: 'Modified' mode is impllied as it wouldn't be listed as a diff otherwise
+	change_type = ("A", "D", "R")
+	
+	
+	def iter_change_type(self, change_type):
+		"""
+		Return
+			iterator yieling Diff instances that match the given change_type
+		
+		``change_type``
+			Member of DiffIndex.change_type
+		"""
+		if change_type not in self.change_type:
+			raise ValueError( "Invalid change type: %s" % change_type )
+			
+		for diff in self:
+			if change_type == "A" and diff.new_file:
+				yield diff
+			elif change_type == "D" and diff.deleted_file:
+				yield diff
+			elif change_type == "R" and diff.renamed:
+				yield diff
+		# END for each diff
+	
+
 class Diff(object):
 	"""
-	A Diff contains diff information between two commits.
+	A Diff contains diff information between two Trees.
 	
 	It contains two sides a and b of the diff, members are prefixed with 
 	"a" and "b" respectively to inidcate that.
@@ -27,7 +146,7 @@ class Diff(object):
 	``Deleted File``::
 	
 		b_mode is None
-		b_blob is NOne
+		b_blob is None
 	"""
 
 	# precompiled regex
@@ -46,7 +165,7 @@ class Diff(object):
 							""", re.VERBOSE | re.MULTILINE)
 	re_is_null_hexsha = re.compile( r'^0{40}$' )
 	__slots__ = ("a_blob", "b_blob", "a_mode", "b_mode", "new_file", "deleted_file", 
-				 "rename_from", "rename_to", "renamed", "diff")
+				 "rename_from", "rename_to", "diff")
 
 	def __init__(self, repo, a_path, b_path, a_blob_id, b_blob_id, a_mode,
 				 b_mode, new_file, deleted_file, rename_from,
@@ -62,31 +181,45 @@ def __init__(self, repo, a_path, b_path, a_blob_id, b_blob_id, a_mode,
 
 		self.a_mode = a_mode
 		self.b_mode = b_mode
+		
 		if self.a_mode:
 			self.a_mode = blob.Blob._mode_str_to_int( self.a_mode )
 		if self.b_mode:
 			self.b_mode = blob.Blob._mode_str_to_int( self.b_mode )
+			
 		self.new_file = new_file
 		self.deleted_file = deleted_file
-		self.rename_from = rename_from
-		self.rename_to = rename_to
-		self.renamed = rename_from != rename_to
+		
+		# be clear and use None instead of empty strings
+		self.rename_from = rename_from or None
+		self.rename_to = rename_to or None
+		
 		self.diff = diff
 
+	@property
+	def renamed(self):
+		"""
+		Returns:
+			True if the blob of our diff has been renamed
+		"""
+		return self.rename_from != self.rename_to
+
 	@classmethod
-	def _list_from_string(cls, repo, text):
+	def _index_from_patch_format(cls, repo, stream):
 		"""
-		Create a new diff object from the given text
+		Create a new DiffIndex from the given text which must be in patch format
 		``repo``
 			is the repository we are operating on - it is required 
 		
-		``text``
-			result of 'git diff' between two commits or one commit and the index
+		``stream``
+			result of 'git diff' as a stream (supporting file protocol)
 		
 		Returns
-			git.Diff[]
+			git.DiffIndex
 		"""
-		diffs = []
+		# for now, we have to bake the stream
+		text = stream.read()
+		index = DiffIndex()
 
 		diff_header = cls.re_header.match
 		for diff in ('\n' + text).split('\ndiff --git')[1:]:
@@ -97,9 +230,51 @@ def _list_from_string(cls, repo, text):
 				a_blob_id, b_blob_id, b_mode = header.groups()
 			new_file, deleted_file = bool(new_file_mode), bool(deleted_file_mode)
 
-			diffs.append(Diff(repo, a_path, b_path, a_blob_id, b_blob_id,
+			index.append(Diff(repo, a_path, b_path, a_blob_id, b_blob_id,
 				old_mode or deleted_file_mode, new_mode or new_file_mode or b_mode,
 				new_file, deleted_file, rename_from, rename_to, diff[header.end():]))
 
-		return diffs
+		return index
+		
+	@classmethod
+	def _index_from_raw_format(cls, repo, stream):
+		"""
+		Create a new DiffIndex from the given stream which must be in raw format.
+		
+		NOTE: 
+			This format is inherently incapable of detecting renames, hence we only 
+			modify, delete and add files
+		
+		Returns
+			git.DiffIndex
+		"""
+		# handles 
+		# :100644 100644 6870991011cc8d9853a7a8a6f02061512c6a8190 37c5e30c879213e9ae83b21e9d11e55fc20c54b7 M	.gitignore
+		index = DiffIndex()
+		for line in stream:
+			if not line.startswith(":"):
+				continue
+			# END its not a valid diff line
+			old_mode, new_mode, a_blob_id, b_blob_id, change_type, path = line[1:].split()
+			a_path = path
+			b_path = path
+			deleted_file = False
+			new_file = False
+			
+			# NOTE: We cannot conclude from the existance of a blob to change type
+			# as diffs with the working do not have blobs yet
+			if change_type == 'D':
+				b_path = None
+				deleted_file = True
+			elif change_type == 'A':
+				a_path = None
+				new_file = True
+			# END add/remove handling
+			
+			diff = Diff(repo, a_path, b_path, a_blob_id, b_blob_id, old_mode, new_mode,
+						new_file, deleted_file, None, None, '')
+			index.append(diff)
+		# END for each line
+		
+		return index
 

lib/git/objects/base.py

@@ -15,22 +15,12 @@ class Object(LazyMixin):
 	
 	This Object also serves as a constructor for instances of the correct type::
 	
-		inst = Object(repo,id)
+		inst = Object.new(repo,id)
 	"""
 	TYPES = ("blob", "tree", "commit", "tag")
 	__slots__ = ("repo", "id", "size", "data" )
 	type = None			# to be set by subclass
 
-	def __new__(cls, repo, id, *args, **kwargs):
-		if cls is Object:
-			hexsha, typename, size = repo.git.get_object_header(id)
-			obj_type = utils.get_object_type_by_name(typename)
-			inst = super(Object,cls).__new__(obj_type, repo, hexsha, *args, **kwargs)
-			inst.size = size
-			return inst
-		else:
-			return super(Object,cls).__new__(cls, repo, id, *args, **kwargs)
-	
 	def __init__(self, repo, id):
 		"""
 		Initialize an object by identifying it by its id. All keyword arguments
@@ -45,7 +35,25 @@ def __init__(self, repo, id):
 		super(Object,self).__init__()
 		self.repo = repo
 		self.id = id
-		
+
+	@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 
+			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.
+		"""
+		hexsha, typename, size = repo.git.get_object_header(id)
+		obj_type = utils.get_object_type_by_name(typename)
+		inst = obj_type(repo, 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
@@ -162,5 +170,4 @@ def _mode_str_to_int(cls, modestr):
 			mode += int(char) << iteration*3
 		# END for each char
 		return mode
-