tree: now behaves like a list with string indexing functionality - using a dict as cache is a problem as the tree is ordered, added blobs, trees and traverse method

repo: remove blob function as blobs are created directly or iterated - primitve types should not clutter the repo interface

Author: Byron

CHANGES

@@ -47,7 +47,11 @@ Blob
 Tree
 ----
 * former 'name' member renamed to path as it suits the actual data better
-
+* added traverse method allowing to recursively traverse tree items
+* deleted blob method
+* added blobs and trees properties allowing to query the respective items in the 
+  tree
+* now mimics behaviour of a read-only list instead of a dict to maintain order.
 
 0.1.6
 =====

lib/git/objects/tree.py

@@ -9,26 +9,57 @@
 import base
 
 class Tree(base.IndexObject):
+	"""
+	Tress represent a ordered list of Blobs and other Trees. Hence it can be 
+	accessed like a list.
+	
+	Tree's will cache their contents after first retrieval to improve efficiency.
+	
+	``Tree as a list``::
+		
+		Access a specific blob using the  
+		tree['filename'] notation.
+		
+		You may as well access by index
+		blob = tree[0]
+		
+		
+	"""
 
 	type = "tree"
-	__slots__ = "_contents"
+	__slots__ = "_cache"
 
 	def __init__(self, repo, id, mode=None, path=None):
 		super(Tree, self).__init__(repo, id, mode, path)
 
 	def _set_cache_(self, attr):
-		if attr == "_contents":
-			# Read the tree contents.
-			self._contents = {}
-			for line in self.repo.git.ls_tree(self.id).splitlines():
-				obj = self.content__from_string(self.repo, line)
-				if obj is not None:
-					self._contents[obj.path] = obj
+		if attr == "_cache":
+			# Set the data when we need it
+			self._cache = self._get_tree_cache(self.repo, self.id)
 		else:
 			super(Tree, self)._set_cache_(attr)
 
-	@staticmethod
-	def content__from_string(repo, text):
+	@classmethod
+	def _get_tree_cache(cls, repo, treeish):
+		"""
+		Return
+			list(object_instance, ...)
+		
+		``treeish``
+			sha or ref identifying a tree  
+		"""
+		out = list()
+		for line in repo.git.ls_tree(treeish).splitlines():
+			obj = cls.content_from_string(repo, line)
+			if obj is not None:
+				out.append(obj)
+			# END if object was handled
+		# END for each line from ls-tree
+		return out
+		
+
+	@classmethod
+	def content_from_string(cls, repo, text):
 		"""
 		Parse a content item and create the appropriate object
 
@@ -40,6 +71,8 @@ def content__from_string(repo, text):
 
 		Returns
 			``git.Blob`` or ``git.Tree``
+			
+		NOTE: Currently sub-modules are ignored !
 		"""
 		try:
 			mode, typ, id, path = text.expandtabs(1).split(" ", 3)
@@ -51,6 +84,7 @@ def content__from_string(repo, text):
 		elif typ == "blob":
 			return blob.Blob(repo, id, mode, path)
 		elif typ == "commit":
+			# TODO: Return a submodule
 			return None 
 		else:
 		  raise(TypeError, "Invalid type: %s" % typ)
@@ -67,36 +101,104 @@ def __div__(self, file):
 			<git.Blob "8b1e02c0fb554eed2ce2ef737a68bb369d7527df">
 
 		Returns
-			``git.Blob`` or ``git.Tree`` or ``None`` if not found
+			``git.Blob`` or ``git.Tree``
+		
+		Raise 
+			KeyError if given file or tree does not exist in tree
 		"""
-		return self.get(file)
+		return self[file]
 
 
 	def __repr__(self):
 		return '<git.Tree "%s">' % self.id
+		
+	@classmethod
+	def _iter_recursive(cls, repo, tree, cur_depth, max_depth, predicate ):
+		
+		for obj in tree:
+			# adjust path to be complete
+			obj.path = os.path.join(tree.path, obj.path)
+			if not predicate(obj):
+				continue
+			yield obj
+			if obj.type == "tree" and ( max_depth < 0 or cur_depth+1 <= max_depth ):
+				for recursive_obj in cls._iter_recursive( repo, obj, cur_depth+1, max_depth, predicate ):
+					yield recursive_obj
+				# END for each recursive object
+			# END if we may enter recursion
+		# END for each object
+		
+	def traverse(self, max_depth=-1, predicate = lambda i: True):
+		"""
+		Returns
+			Iterator to traverse the tree recursively up to the given level.
+			The iterator returns Blob and Tree objects
+		
+		``max_depth``
+		
+			if -1, the whole tree will be traversed
+			if 0, only the first level will be traversed which is the same as 
+			the default non-recursive iterator
+			
+		``predicate``
+		
+			If predicate(item) returns True, item will be returned by iterator
+		"""
+		return self._iter_recursive( self.repo, self, 0, max_depth, predicate )
+		
+	@property
+	def trees(self):
+		"""
+		Returns
+			list(Tree, ...) list of trees directly below this tree
+		"""
+		return [ i for i in self if i.type == "tree" ]
+		
+	@property
+	def blobs(self):
+		"""
+		Returns
+			list(Blob, ...) list of blobs directly below this tree
+		"""
+		return [ i for i in self if i.type == "blob" ]
 
-	# Implement the basics of the dict protocol:
-	# directories/trees can be seen as object dicts.
-	def __getitem__(self, key):
-		return self._contents[key]
 
+	# List protocol
+	def __getslice__(self,i,j):
+		return self._cache[i:j]
+		
 	def __iter__(self):
-		return iter(self._contents)
-
+		return iter(self._cache)
+		
 	def __len__(self):
-		return len(self._contents)
-
-	def __contains__(self, key):
-		return key in self._contents
-
-	def get(self, key):
-		return self._contents.get(key)
-
-	def items(self):
-		return self._contents.items()
-
-	def keys(self):
-		return self._contents.keys()
-
-	def values(self):
-		return self._contents.values()
+		return len(self._cache)
+		
+	def __getitem__(self,item):
+		if isinstance(item, int):
+			return self._cache[item]
+		
+		if isinstance(item, basestring):
+			# compatability
+			for obj in self._cache:
+				if obj.path == item:
+					return obj
+			# END for each obj
+			raise KeyError( "Blob or Tree named %s not found" % item )
+		# END index is basestring 
+		
+		raise TypeError( "Invalid index type: %r" % item )
+		
+		
+	def __contains__(self,item):
+		if isinstance(item, base.IndexObject):
+			return item in self._cache
+		
+		# compatability
+		for obj in self._cache:
+			if item == obj.path:
+				return True
+		# END for each item
+		return False
+	
+	def __reversed__(self):
+		return reversed(self._cache)

lib/git/repo.py

@@ -342,19 +342,10 @@ def tree(self, treeish=None):
 
 		# we should also check whether the ref has a valid commit ... but lets n
 		# not be over-critical
-		return Tree(self, treeish)
+		# the root has an empty relative path and the default mode
+		root = Tree(self, treeish, 0, '')
+		return root
 
-	def blob(self, id):
-		"""
-		The Blob object for the given id
-
-		``id``
-			is the SHA1 id of the blob
-
-		Returns
-			``git.Blob``
-		"""
-		return Blob(self, id=id)
 
 	def log(self, commit='master', path=None, **kwargs):
 		"""

test/git/test_repo.py

@@ -93,16 +93,16 @@ def test_tree(self, git):
 
 		tree = self.repo.tree(Head(self.repo, 'master'))
 
-		assert_equal(4, len([c for c in tree.values() if isinstance(c, Blob)]))
-		assert_equal(3, len([c for c in tree.values() if isinstance(c, Tree)]))
+		assert_equal(4, len([c for c in tree if isinstance(c, Blob)]))
+		assert_equal(3, len([c for c in tree if isinstance(c, Tree)]))
 
 		assert_true(git.called)
 
 	@patch_object(Git, '_call_process')
 	def test_blob(self, git):
 		git.return_value = fixture('cat_file_blob')
 
-		blob = self.repo.blob("abc")
+		blob = Blob(self.repo,"abc")
 		assert_equal("Hello world", blob.data)
 
 		assert_true(git.called)