Moved everything into the git subdirectory - some tests still need to be adjusted

1 files changed, 753 insertions, 0 deletions

diff --git a/git/repo/base.py b/git/repo/base.py
new file mode 100644
index 00000000..e26da101
--- /dev/null
+++ b/git/repo/base.py
@@ -0,0 +1,753 @@
+# repo.py
+# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
+#
+# This module is part of GitPython and is released under
+# the BSD License: http://www.opensource.org/licenses/bsd-license.php
+
+from git.exc import InvalidGitRepositoryError, NoSuchPathError
+from git.cmd import Git
+from git.util import Actor
+from git.refs import *
+from git.index import IndexFile
+from git.objects import *
+from git.config import GitConfigParser
+from git.remote import Remote
+from git.db import (
+				GitCmdObjectDB, 
+				GitDB
+				)
+
+
+from gitdb.util import (
+							join,
+							isfile,
+							hex_to_bin
+						)
+
+from fun import (
+					rev_parse,
+					is_git_dir,
+					touch
+				)
+
+import os
+import sys
+import re
+
+DefaultDBType = GitDB
+if sys.version_info[1] < 5:		# python 2.4 compatiblity
+	DefaultDBType = GitCmdObjectDB
+# END handle python 2.4
+
+
+__all__ = ('Repo', )
+
+
+class Repo(object):
+	"""Represents a git repository and allows you to query references, 
+	gather commit information, generate diffs, create and clone repositories query
+	the log.
+	
+	The following attributes are worth using:
+	
+	'working_dir' is the working directory of the git command, wich is the working tree 
+	directory if available or the .git directory in case of bare repositories
+	
+	'working_tree_dir' is the working tree directory, but will raise AssertionError
+	if we are a bare repository.
+	
+	'git_dir' is the .git repository directoy, which is always set."""
+	DAEMON_EXPORT_FILE = 'git-daemon-export-ok'
+	__slots__ = ( "working_dir", "_working_tree_dir", "git_dir", "_bare", "git", "odb" )
+	
+	# precompiled regex
+	re_whitespace = re.compile(r'\s+')
+	re_hexsha_only = re.compile('^[0-9A-Fa-f]{40}$')
+	re_hexsha_shortened = re.compile('^[0-9A-Fa-f]{4,40}$')
+	re_author_committer_start = re.compile(r'^(author|committer)')
+	re_tab_full_line = re.compile(r'^\t(.*)$')
+	
+	# invariants
+	# represents the configuration level of a configuration file
+	config_level = ("system", "global", "repository")
+
+	def __init__(self, path=None, odbt = DefaultDBType):
+		"""Create a new Repo instance
+
+		:param path: is the path to either the root git directory or the bare git repo::
+
+			repo = Repo("/Users/mtrier/Development/git-python")
+			repo = Repo("/Users/mtrier/Development/git-python.git")
+			repo = Repo("~/Development/git-python.git")
+			repo = Repo("$REPOSITORIES/Development/git-python.git")
+		
+		:param odbt: Object DataBase type - a type which is constructed by providing 
+			the directory containing the database objects, i.e. .git/objects. It will
+			be used to access all object data
+		:raise InvalidGitRepositoryError:
+		:raise NoSuchPathError:
+		:return: git.Repo """
+		epath = os.path.abspath(os.path.expandvars(os.path.expanduser(path or os.getcwd())))
+
+		if not os.path.exists(epath):
+			raise NoSuchPathError(epath)
+
+		self.working_dir = None
+		self._working_tree_dir = None
+		self.git_dir = None
+		curpath = epath
+		
+		# walk up the path to find the .git dir
+		while curpath:
+			if is_git_dir(curpath):
+				self.git_dir = curpath
+				self._working_tree_dir = os.path.dirname(curpath)
+				break
+			gitpath = join(curpath, '.git')
+			if is_git_dir(gitpath):
+				self.git_dir = gitpath
+				self._working_tree_dir = curpath
+				break
+			curpath, dummy = os.path.split(curpath)
+			if not dummy:
+				break
+		# END while curpath
+		
+		if self.git_dir is None:
+		   raise InvalidGitRepositoryError(epath)
+
+		self._bare = False
+		try:
+			self._bare = self.config_reader("repository").getboolean('core','bare') 
+		except Exception:
+			# lets not assume the option exists, although it should
+			pass
+
+		# adjust the wd in case we are actually bare - we didn't know that 
+		# in the first place
+		if self._bare:
+			self._working_tree_dir = None
+		# END working dir handling
+		
+		self.working_dir = self._working_tree_dir or self.git_dir
+		self.git = Git(self.working_dir)
+		
+		# special handling, in special times
+		args = [join(self.git_dir, 'objects')]
+		if issubclass(odbt, GitCmdObjectDB):
+			args.append(self.git)
+		self.odb = odbt(*args)
+
+	def __eq__(self, rhs):
+		if isinstance(rhs, Repo):
+			return self.git_dir == rhs.git_dir
+		return False
+		
+	def __ne__(self, rhs):
+		return not self.__eq__(rhs)
+		
+	def __hash__(self):
+		return hash(self.git_dir)
+
+	def __repr__(self):
+		return "%s(%r)" % (type(self).__name__, self.git_dir)
+
+	# Description property
+	def _get_description(self):
+		filename = join(self.git_dir, 'description')
+		return file(filename).read().rstrip()
+
+	def _set_description(self, descr):
+		filename = join(self.git_dir, 'description')
+		file(filename, 'w').write(descr+'\n')
+
+	description = property(_get_description, _set_description,
+						   doc="the project's description")
+	del _get_description
+	del _set_description
+	
+	
+	
+	@property
+	def working_tree_dir(self):
+		""":return: The working tree directory of our git repository
+		:raise AssertionError: If we are a bare repository"""
+		if self._working_tree_dir is None:
+			raise AssertionError( "Repository at %r is bare and does not have a working tree directory" % self.git_dir )
+		return self._working_tree_dir
+	
+	@property
+	def bare(self):
+		""":return: True if the repository is bare"""
+		return self._bare
+
+	@property
+	def heads(self):
+		"""A list of ``Head`` objects representing the branch heads in
+		this repo
+
+		:return: ``git.IterableList(Head, ...)``"""
+		return Head.list_items(self)
+		
+	@property
+	def references(self):
+		"""A list of Reference objects representing tags, heads and remote references.
+		
+		:return: IterableList(Reference, ...)"""
+		return Reference.list_items(self)
+		
+	# alias for references
+	refs = references
+
+	# alias for heads
+	branches = heads
+	
+	@property
+	def index(self):
+		""":return: IndexFile representing this repository's index."""
+		return IndexFile(self)
+
+	@property
+	def head(self):
+		""":return: HEAD Object pointing to the current head reference"""
+		return HEAD(self,'HEAD')
+		
+	@property
+	def remotes(self):
+		"""A list of Remote objects allowing to access and manipulate remotes
+		:return: ``git.IterableList(Remote, ...)``"""
+		return Remote.list_items(self)
+		
+	def remote(self, name='origin'):
+		""":return: Remote with the specified name
+		:raise ValueError:  if no remote with such a name exists"""
+		return Remote(self, name)
+		
+	#{ Submodules
+		
+	@property
+	def submodules(self):
+		"""
+		:return: git.IterableList(Submodule, ...) of direct submodules
+			available from the current head"""
+		return Submodule.list_items(self)
+		
+	def submodule(self, name):
+		""" :return: Submodule with the given name 
+		:raise ValueError: If no such submodule exists"""
+		try:
+			return self.submodules[name]
+		except IndexError:
+			raise ValueError("Didn't find submodule named %r" % name)
+		# END exception handling
+		
+	def create_submodule(self, *args, **kwargs):
+		"""Create a new submodule
+		
+		:note: See the documentation of Submodule.add for a description of the 
+			applicable parameters
+		:return: created submodules"""
+		return Submodule.add(self, *args, **kwargs)
+		
+	def iter_submodules(self, *args, **kwargs):
+		"""An iterator yielding Submodule instances, see Traversable interface
+		for a description of args and kwargs
+		:return: Iterator"""
+		return RootModule(self).traverse(*args, **kwargs)
+		
+	def submodule_update(self, *args, **kwargs):
+		"""Update the submodules, keeping the repository consistent as it will 
+		take the previous state into consideration. For more information, please
+		see the documentation of RootModule.update"""
+		return RootModule(self).update(*args, **kwargs)
+		
+	#}END submodules
+
+	@property
+	def tags(self):
+		"""A list of ``Tag`` objects that are available in this repo
+		:return: ``git.IterableList(TagReference, ...)`` """
+		return TagReference.list_items(self)
+		
+	def tag(self,path):
+		""":return: TagReference Object, reference pointing to a Commit or Tag
+		:param path: path to the tag reference, i.e. 0.1.5 or tags/0.1.5 """
+		return TagReference(self, path)
+		
+	def create_head(self, path, commit='HEAD', force=False, logmsg=None ):
+		"""Create a new head within the repository. 
+		For more documentation, please see the Head.create method.
+		
+		:return: newly created Head Reference"""
+		return Head.create(self, path, commit, force, logmsg)
+		
+	def delete_head(self, *heads, **kwargs):
+		"""Delete the given heads
+		
+		:param kwargs: Additional keyword arguments to be passed to git-branch"""
+		return Head.delete(self, *heads, **kwargs)
+		
+	def create_tag(self, path, ref='HEAD', message=None, force=False, **kwargs):
+		"""Create a new tag reference.
+		For more documentation, please see the TagReference.create method.
+		
+		:return: TagReference object """
+		return TagReference.create(self, path, ref, message, force, **kwargs)
+		
+	def delete_tag(self, *tags):
+		"""Delete the given tag references"""
+		return TagReference.delete(self, *tags)
+		
+	def create_remote(self, name, url, **kwargs):
+		"""Create a new remote.
+		
+		For more information, please see the documentation of the Remote.create 
+		methods 
+		
+		:return: Remote reference"""
+		return Remote.create(self, name, url, **kwargs)
+		
+	def delete_remote(self, remote):
+		"""Delete the given remote."""
+		return Remote.remove(self, remote)
+		
+	def _get_config_path(self, config_level ):
+		# we do not support an absolute path of the gitconfig on windows , 
+		# use the global config instead
+		if sys.platform == "win32" and config_level == "system":
+			config_level = "global"
+			
+		if config_level == "system":
+			return "/etc/gitconfig"
+		elif config_level == "global":
+			return os.path.normpath(os.path.expanduser("~/.gitconfig"))
+		elif config_level == "repository":
+			return join(self.git_dir, "config")
+		
+		raise ValueError( "Invalid configuration level: %r" % config_level )
+			
+	def config_reader(self, config_level=None):
+		"""
+		:return:
+			GitConfigParser allowing to read the full git configuration, but not to write it
+			
+			The configuration will include values from the system, user and repository 
+			configuration files.
+			
+		:param config_level:
+			For possible values, see config_writer method
+			If None, all applicable levels will be used. Specify a level in case 
+			you know which exact file you whish to read to prevent reading multiple files for 
+			instance
+		:note: On windows, system configuration cannot currently be read as the path is 
+			unknown, instead the global path will be used."""
+		files = None
+		if config_level is None:
+			files = [ self._get_config_path(f) for f in self.config_level ]
+		else:
+			files = [ self._get_config_path(config_level) ]
+		return GitConfigParser(files, read_only=True)
+		
+	def config_writer(self, config_level="repository"):
+		"""
+		:return:
+			GitConfigParser allowing to write values of the specified configuration file level.
+			Config writers should be retrieved, used to change the configuration ,and written 
+			right away as they will lock the configuration file in question and prevent other's
+			to write it.
+			
+		:param config_level:
+			One of the following values
+			system = sytem wide configuration file
+			global = user level configuration file
+			repository = configuration file for this repostory only"""
+		return GitConfigParser(self._get_config_path(config_level), read_only = False)
+		
+	def commit(self, rev=None):
+		"""The Commit object for the specified revision
+		:param rev: revision specifier, see git-rev-parse for viable options.
+		:return: ``git.Commit``"""
+		if rev is None:
+			return self.active_branch.commit
+		else:
+			return self.rev_parse(str(rev)+"^0")
+		
+	def iter_trees(self, *args, **kwargs):
+		""":return: Iterator yielding Tree objects
+		:note: Takes all arguments known to iter_commits method"""
+		return ( c.tree for c in self.iter_commits(*args, **kwargs) )
+
+	def tree(self, rev=None):
+		"""The Tree object for the given treeish revision
+		Examples::
+	
+			  repo.tree(repo.heads[0])
+
+		:param rev: is a revision pointing to a Treeish ( being a commit or tree )
+		:return: ``git.Tree``
+			
+		:note:
+			If you need a non-root level tree, find it by iterating the root tree. Otherwise
+			it cannot know about its path relative to the repository root and subsequent 
+			operations might have unexpected results."""
+		if rev is None:
+			return self.active_branch.commit.tree
+		else:
+			return self.rev_parse(str(rev)+"^{tree}")
+
+	def iter_commits(self, rev=None, paths='', **kwargs):
+		"""A list of Commit objects representing the history of a given ref/commit
+
+		:parm rev:
+			revision specifier, see git-rev-parse for viable options.
+			If None, the active branch will be used.
+
+		:parm paths:
+			is an optional path or a list of paths to limit the returned commits to
+			Commits that do not contain that path or the paths will not be returned.
+		
+		:parm kwargs:
+			Arguments to be passed to git-rev-list - common ones are 
+			max_count and skip
+
+		:note: to receive only commits between two named revisions, use the 
+			"revA..revB" revision specifier
+
+		:return ``git.Commit[]``"""
+		if rev is None:
+			rev = self.active_branch
+		
+		return Commit.iter_items(self, rev, paths, **kwargs)
+
+	def _get_daemon_export(self):
+		filename = join(self.git_dir, self.DAEMON_EXPORT_FILE)
+		return os.path.exists(filename)
+
+	def _set_daemon_export(self, value):
+		filename = join(self.git_dir, self.DAEMON_EXPORT_FILE)
+		fileexists = os.path.exists(filename)
+		if value and not fileexists:
+			touch(filename)
+		elif not value and fileexists:
+			os.unlink(filename)
+
+	daemon_export = property(_get_daemon_export, _set_daemon_export,
+							 doc="If True, git-daemon may export this repository")
+	del _get_daemon_export
+	del _set_daemon_export
+
+	def _get_alternates(self):
+		"""The list of alternates for this repo from which objects can be retrieved
+
+		:return: list of strings being pathnames of alternates"""
+		alternates_path = join(self.git_dir, 'objects', 'info', 'alternates')
+
+		if os.path.exists(alternates_path):
+			try:
+				f = open(alternates_path)
+				alts = f.read()
+			finally:
+				f.close()
+			return alts.strip().splitlines()
+		else:
+			return list()
+
+	def _set_alternates(self, alts):
+		"""Sets the alternates
+
+		:parm alts:
+			is the array of string paths representing the alternates at which 
+			git should look for objects, i.e. /home/user/repo/.git/objects
+
+		:raise NoSuchPathError:
+		:note:
+			The method does not check for the existance of the paths in alts
+			as the caller is responsible."""
+		alternates_path = join(self.git_dir, 'objects', 'info', 'alternates') 
+		if not alts:
+			if isfile(alternates_path):
+				os.remove(alternates_path)
+		else:
+			try:
+				f = open(alternates_path, 'w')
+				f.write("\n".join(alts))
+			finally:
+				f.close()
+			# END file handling 
+		# END alts handling
+
+	alternates = property(_get_alternates, _set_alternates, doc="Retrieve a list of alternates paths or set a list paths to be used as alternates")
+
+	def is_dirty(self, index=True, working_tree=True, untracked_files=False):
+		"""
+		:return:
+			``True``, the repository is considered dirty. By default it will react
+			like a git-status without untracked files, hence it is dirty if the 
+			index or the working copy have changes."""
+		if self._bare:
+			# Bare repositories with no associated working directory are
+			# always consired to be clean.
+			return False
+		
+		# start from the one which is fastest to evaluate
+		default_args = ('--abbrev=40', '--full-index', '--raw')
+		if index: 
+			# diff index against HEAD
+			if isfile(self.index.path) and self.head.is_valid() and \
+				len(self.git.diff('HEAD', '--cached', *default_args)):
+				return True
+		# END index handling
+		if working_tree:
+			# diff index against working tree
+			if len(self.git.diff(*default_args)):
+				return True
+		# END working tree handling
+		if untracked_files:
+			if len(self.untracked_files):
+				return True
+		# END untracked files
+		return False
+		
+	@property
+	def untracked_files(self):
+		"""
+		:return:
+			list(str,...)
+			
+			Files currently untracked as they have not been staged yet. Paths 
+			are relative to the current working directory of the git command.
+			
+		:note:
+			ignored files will not appear here, i.e. files mentioned in .gitignore"""
+		# make sure we get all files, no only untracked directores
+		proc = self.git.status(untracked_files=True, as_process=True)
+		stream = iter(proc.stdout)
+		untracked_files = list()
+		for line in stream:
+			if not line.startswith("# Untracked files:"):
+				continue
+			# skip two lines
+			stream.next()
+			stream.next()
+			
+			for untracked_info in stream:
+				if not untracked_info.startswith("#\t"):
+					break
+				untracked_files.append(untracked_info.replace("#\t", "").rstrip())
+			# END for each utracked info line
+		# END for each line
+		return untracked_files
+
+	@property
+	def active_branch(self):
+		"""The name of the currently active branch.
+
+		:return: Head to the active branch"""
+		return self.head.reference
+			
+	def blame(self, rev, file):
+		"""The blame information for the given file at the given revision.
+
+		:parm rev: revision specifier, see git-rev-parse for viable options.
+		:return:
+			list: [git.Commit, list: [<line>]]
+			A list of tuples associating a Commit object with a list of lines that 
+			changed within the given commit. The Commit objects will be given in order
+			of appearance."""
+		data = self.git.blame(rev, '--', file, p=True)
+		commits = dict()
+		blames = list()
+		info = None
+
+		for line in data.splitlines(False):
+			parts = self.re_whitespace.split(line, 1)
+			firstpart = parts[0]
+			if self.re_hexsha_only.search(firstpart):
+				# handles 
+				# 634396b2f541a9f2d58b00be1a07f0c358b999b3 1 1 7		- indicates blame-data start
+				# 634396b2f541a9f2d58b00be1a07f0c358b999b3 2 2
+				digits = parts[-1].split(" ")
+				if len(digits) == 3:
+					info = {'id': firstpart}
+					blames.append([None, []])
+				# END blame data initialization
+			else:
+				m = self.re_author_committer_start.search(firstpart)
+				if m:
+					# handles: 
+					# author Tom Preston-Werner
+					# author-mail <tom@mojombo.com>
+					# author-time 1192271832
+					# author-tz -0700
+					# committer Tom Preston-Werner
+					# committer-mail <tom@mojombo.com>
+					# committer-time 1192271832
+					# committer-tz -0700  - IGNORED BY US
+					role = m.group(0)
+					if firstpart.endswith('-mail'):
+						info["%s_email" % role] = parts[-1]
+					elif firstpart.endswith('-time'):
+						info["%s_date" % role] = int(parts[-1])
+					elif role == firstpart:
+						info[role] = parts[-1]
+					# END distinguish mail,time,name
+				else:
+					# handle
+					# filename lib/grit.rb
+					# summary add Blob
+					# <and rest>
+					if firstpart.startswith('filename'):
+						info['filename'] = parts[-1]
+					elif firstpart.startswith('summary'):
+						info['summary'] = parts[-1]
+					elif firstpart == '':
+						if info:
+							sha = info['id']
+							c = commits.get(sha)
+							if c is None:
+								c = Commit(	 self, hex_to_bin(sha),
+											 author=Actor._from_string(info['author'] + ' ' + info['author_email']),
+											 authored_date=info['author_date'],
+											 committer=Actor._from_string(info['committer'] + ' ' + info['committer_email']),
+											 committed_date=info['committer_date'],
+											 message=info['summary'])
+								commits[sha] = c
+							# END if commit objects needs initial creation
+							m = self.re_tab_full_line.search(line)
+							text,  = m.groups()
+							blames[-1][0] = c
+							blames[-1][1].append( text )
+							info = None
+						# END if we collected commit info
+					# END distinguish filename,summary,rest
+				# END distinguish author|committer vs filename,summary,rest
+			# END distinguish hexsha vs other information
+		return blames
+
+	@classmethod
+	def init(cls, path=None, mkdir=True, **kwargs):
+		"""Initialize a git repository at the given path if specified
+
+		:param path:
+			is the full path to the repo (traditionally ends with /<name>.git)
+			or None in which case the repository will be created in the current 
+			working directory
+
+		:parm mkdir:
+			if specified will create the repository directory if it doesn't
+			already exists. Creates the directory with a mode=0755. 
+			Only effective if a path is explicitly given
+
+		:parm kwargs:
+			keyword arguments serving as additional options to the git-init command
+
+		:return: ``git.Repo`` (the newly created repo)"""
+
+		if mkdir and path and not os.path.exists(path):
+			os.makedirs(path, 0755)
+
+		# git command automatically chdir into the directory
+		git = Git(path)
+		output = git.init(**kwargs)
+		return Repo(path)
+
+	@classmethod
+	def _clone(cls, git, url, path, odb_default_type, **kwargs):
+		# special handling for windows for path at which the clone should be 
+		# created.
+		# tilde '~' will be expanded to the HOME no matter where the ~ occours. Hence
+		# we at least give a proper error instead of letting git fail
+		prev_cwd = None
+		prev_path = None
+		odbt = kwargs.pop('odbt', odb_default_type)
+		if os.name == 'nt':
+			if '~' in path:
+				raise OSError("Git cannot handle the ~ character in path %r correctly" % path)
+				
+			# on windows, git will think paths like c: are relative and prepend the 
+			# current working dir ( before it fails ). We temporarily adjust the working 
+			# dir to make this actually work
+			match = re.match("(\w:[/\\\])(.*)", path)
+			if match:
+				prev_cwd = os.getcwd()
+				prev_path = path
+				drive, rest_of_path = match.groups()
+				os.chdir(drive)
+				path = rest_of_path
+				kwargs['with_keep_cwd'] = True
+			# END cwd preparation 
+		# END windows handling 
+		
+		try:
+			git.clone(url, path, **kwargs)
+		finally:
+			if prev_cwd is not None:
+				os.chdir(prev_cwd)
+				path = prev_path
+			# END reset previous working dir
+		# END bad windows handling
+		
+		# our git command could have a different working dir than our actual 
+		# environment, hence we prepend its working dir if required
+		if not os.path.isabs(path) and git.working_dir:
+			path = join(git._working_dir, path)
+			
+		# adjust remotes - there may be operating systems which use backslashes, 
+		# These might be given as initial paths, but when handling the config file
+		# that contains the remote from which we were clones, git stops liking it
+		# as it will escape the backslashes. Hence we undo the escaping just to be 
+		# sure
+		repo = cls(os.path.abspath(path), odbt = odbt)
+		if repo.remotes:
+			repo.remotes[0].config_writer.set_value('url', repo.remotes[0].url.replace("\\\\", "\\").replace("\\", "/"))
+		# END handle remote repo
+		return repo
+
+	def clone(self, path, **kwargs):
+		"""Create a clone from this repository.
+		:param path:
+			is the full path of the new repo (traditionally ends with ./<name>.git).
+
+		:param kwargs:
+			odbt = ObjectDatabase Type, allowing to determine the object database
+			implementation used by the returned Repo instance
+			
+			All remaining keyword arguments are given to the git-clone command
+			
+		:return: ``git.Repo`` (the newly cloned repo)"""
+		return self._clone(self.git, self.git_dir, path, type(self.odb), **kwargs)
+
+	@classmethod
+	def clone_from(cls, url, to_path, **kwargs):
+		"""Create a clone from the given URL
+		:param url: valid git url, see http://www.kernel.org/pub/software/scm/git/docs/git-clone.html#URLS
+		:param to_path: Path to which the repository should be cloned to
+		:param kwargs: see the ``clone`` method
+		:return: Repo instance pointing to the cloned directory"""
+		return cls._clone(Git(os.getcwd()), url, to_path, GitCmdObjectDB, **kwargs)
+
+	def archive(self, ostream, treeish=None, prefix=None,  **kwargs):
+		"""Archive the tree at the given revision.
+		:parm ostream: file compatible stream object to which the archive will be written
+		:parm treeish: is the treeish name/id, defaults to active branch
+		:parm prefix: is the optional prefix to prepend to each filename in the archive
+		:parm kwargs:
+			Additional arguments passed to git-archive
+			NOTE: Use the 'format' argument to define the kind of format. Use 
+			specialized ostreams to write any format supported by python
+
+		:raise GitCommandError: in case something went wrong
+		:return: self"""
+		if treeish is None:
+			treeish = self.active_branch
+		if prefix and 'prefix' not in kwargs:
+			kwargs['prefix'] = prefix 
+		kwargs['output_stream'] = ostream
+		
+		self.git.archive(treeish, **kwargs)
+		return self
+	
+	rev_parse = rev_parse
+		
+	def __repr__(self):
+		return '<git.Repo "%s">' % self.git_dir