@@ -57,6 +57,7 @@ GitCommand
 * git.subcommand call scheme now prunes out None from the argument list, allowing 
   to be called more confortably as None can never be a valid to the git command 
   if converted to a string.
+* Renamed 'git_dir' attribute to 'working_dir' which is exactly how it is used
 
 Commit
 ------
@@ -135,6 +136,11 @@ Repo
   - 'config_reader' method
   - 'config_writer' method
   - 'bare' property, previously it was a simple attribute that could be written
+* Renamed the following attributes
+  - 'path' is now 'git_dir'
+  - 'wd' is now 'working_dir'
+* Added attribute
+  - 'working_tree_dir' which may be None in case of bare repositories
 
 Remote
 ------
 
@@ -43,6 +43,8 @@ class Git(object):
 		of the command to stdout.
 		Set its value to 'full' to see details about the returned values.
 	"""
+	__slots__ = ("_working_dir", "cat_file_all", "cat_file_header")
+	
 	class AutoInterrupt(object):
 		"""
 		Kill/Interrupt the stored process instance once this instance goes out of scope. It is 
@@ -92,18 +94,18 @@ def wait(self):
 
 
 
-	def __init__(self, git_dir=None):
+	def __init__(self, working_dir=None):
 		"""
 		Initialize this instance with:
 		
-		``git_dir``
+		``working_dir``
 		   Git directory we should work in. If None, we always work in the current 
 		   directory as returned by os.getcwd().
 		   It is meant to be the working tree directory if available, or the 
 		   .git directory in case of bare repositories.
 		"""
 		super(Git, self).__init__()
-		self.git_dir = git_dir
+		self._working_dir = working_dir
 
 		# cached command slots
 		self.cat_file_header = None
@@ -121,12 +123,12 @@ def __getattr__(self, name):
 		return lambda *args, **kwargs: self._call_process(name, *args, **kwargs)
 
 	@property
-	def get_dir(self):
+	def working_dir(self):
 		"""
 		Returns
 			Git directory we are working on
 		"""
-		return self.git_dir
+		return self._working_dir
 
 	def execute(self, command,
 				istream=None,
@@ -150,8 +152,8 @@ def execute(self, command,
 
 		``with_keep_cwd``
 			Whether to use the current working directory from os.getcwd().
-			GitPython uses get_work_tree() as its working directory by
-			default and get_git_dir() for bare repositories.
+			The cmd otherwise uses its own working_dir that it has been initialized
+			with if possible.
 
 		``with_extended_output``
 			Whether to return a (status, stdout, stderr) tuple.
@@ -198,10 +200,10 @@ def execute(self, command,
 			print ' '.join(command)
 
 		# Allow the user to have the command executed in their working dir.
-		if with_keep_cwd or self.git_dir is None:
+		if with_keep_cwd or self._working_dir is None:
 		  cwd = os.getcwd()
 		else:
-		  cwd=self.git_dir
+		  cwd=self._working_dir
 
 		# Start the process
 		proc = subprocess.Popen(command,
 
@@ -325,7 +325,7 @@ def _set_cache_(self, attr):
 			super(IndexFile, self)._set_cache_(attr)
 
 	def _index_path(self):
-		return join_path_native(self.repo.path, "index")
+		return join_path_native(self.repo.git_dir, "index")
 
 
 	@property
@@ -539,15 +539,15 @@ def from_tree(cls, repo, *treeish, **kwargs):
 
 		# tmp file created in git home directory to be sure renaming 
 		# works - /tmp/ dirs could be on another device
-		tmp_index = tempfile.mktemp('','',repo.path)
+		tmp_index = tempfile.mktemp('','',repo.git_dir)
 		arg_list.append("--index-output=%s" % tmp_index)
 		arg_list.extend(treeish)
 
 		# move current index out of the way - otherwise the merge may fail
 		# as it considers existing entries. moving it essentially clears the index.
 		# Unfortunately there is no 'soft' way to do it.
 		# The _TemporaryFileSwap assure the original file get put back
-		index_handler = _TemporaryFileSwap(join_path_native(repo.path, 'index'))
+		index_handler = _TemporaryFileSwap(join_path_native(repo.git_dir, 'index'))
 		try:
 			repo.git.read_tree(*arg_list, **kwargs)
 			index = cls(repo, tmp_index)
@@ -579,7 +579,7 @@ def _index_mode_to_tree_index_mode(cls, index_mode):
 		return ret
 
 
-	# UTILITIES 
+	# UTILITIES
 	def _iter_expand_paths(self, paths):
 		"""Expand the directories in list of paths to the corresponding paths accordingly, 
 		
@@ -588,7 +588,7 @@ def _iter_expand_paths(self, paths):
 		times - we respect that and do not prune"""
 		def raise_exc(e):
 			raise e
-		r = self.repo.git.git_dir
+		r = self.repo.working_tree_dir
 		rs = r + '/'
 		for path in paths:
 			abs_path = path
@@ -798,9 +798,9 @@ def _to_relative_path(self, path):
 		"""
 		if not os.path.isabs(path):
 			return path
-		relative_path = path.replace(self.repo.git.git_dir+os.sep, "")
+		relative_path = path.replace(self.repo.working_tree_dir+os.sep, "")
 		if relative_path == path:
-			raise ValueError("Absolute path %r is not in git repository at %r" % (path,self.repo.git.git_dir))
+			raise ValueError("Absolute path %r is not in git repository at %r" % (path,self.repo.working_tree_dir))
 		return relative_path
 
 	def _preprocess_add_items(self, items):
 
@@ -223,5 +223,5 @@ def abspath(self):
 			
 			The returned path will be native to the system and contains '\' on windows. 
 		"""
-		return join_path_native(self.repo.git.git_dir, self.path)
+		return join_path_native(self.repo.working_tree_dir, self.path)
 
@@ -52,15 +52,15 @@ def name(self):
 		return self.path	
 
 	def _get_path(self):
-		return join_path_native(self.repo.path, self.path)
+		return join_path_native(self.repo.git_dir, self.path)
 
 	@classmethod
 	def _iter_packed_refs(cls, repo):
 		"""Returns an iterator yielding pairs of sha1/path pairs for the corresponding
 		refs.
 		NOTE: The packed refs file will be kept open as long as we iterate"""
 		try:
-			fp = open(os.path.join(repo.path, 'packed-refs'), 'r')
+			fp = open(os.path.join(repo.git_dir, 'packed-refs'), 'r')
 			for line in fp:
 				line = line.strip()
 				if not line:
@@ -258,7 +258,7 @@ def delete(cls, repo, path):
 			Alternatively the symbolic reference to be deleted
 		"""
 		full_ref_path = cls._to_full_path(repo, path)
-		abs_path = os.path.join(repo.path, full_ref_path)
+		abs_path = os.path.join(repo.git_dir, full_ref_path)
 		if os.path.exists(abs_path):
 			os.remove(abs_path)
 
@@ -271,7 +271,7 @@ def _create(cls, repo, path, resolve, reference, force):
 		instead"""
 		full_ref_path = cls._to_full_path(repo, path)
 
-		abs_ref_path = os.path.join(repo.path, full_ref_path)
+		abs_ref_path = os.path.join(repo.git_dir, full_ref_path)
 		if not force and os.path.isfile(abs_ref_path):
 			raise OSError("Reference at %s does already exist" % full_ref_path)
 
@@ -401,10 +401,10 @@ def iter_items(cls, repo, common_path = None, **kwargs):
 
 		# walk loose refs
 		# Currently we do not follow links 
-		for root, dirs, files in os.walk(join_path_native(repo.path, common_path)):
+		for root, dirs, files in os.walk(join_path_native(repo.git_dir, common_path)):
 			for f in files:
 				abs_path = to_native_path_linux(join_path(root, f))
-				rela_paths.add(abs_path.replace(to_native_path_linux(repo.path) + '/', ""))
+				rela_paths.add(abs_path.replace(to_native_path_linux(repo.git_dir) + '/', ""))
 			# END for each file in root directory
 		# END for each directory to walk
 
 
@@ -575,7 +575,7 @@ def _get_fetch_info_from_stderr(self, stderr):
 		err_info = stderr.splitlines()[1:]
 
 		# read head information 
-		fp = open(os.path.join(self.repo.path, 'FETCH_HEAD'),'r')
+		fp = open(os.path.join(self.repo.git_dir, 'FETCH_HEAD'),'r')
 		fetch_head_info = fp.readlines()
 		fp.close()
 
 
@@ -41,9 +41,19 @@ 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__ = ( "wd", "path", "_bare", "git" )
+	__slots__ = ( "working_dir", "_working_tree_dir", "git_dir", "_bare", "git" )
 
 	# precompiled regex
 	re_whitespace = re.compile(r'\s+')
@@ -81,26 +91,28 @@ def __init__(self, path=None):
 		if not os.path.exists(epath):
 			raise NoSuchPathError(epath)
 
-		self.path = None
+		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.path = curpath
-				self.wd = os.path.dirname(curpath)
+				self.git_dir = curpath
+				self._working_tree_dir = os.path.dirname(curpath)
 				break
 			gitpath = os.path.join(curpath, '.git')
 			if is_git_dir(gitpath):
-				self.path = gitpath
-				self.wd = curpath
+				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.path is None:
+		if self.git_dir is None:
 		   raise InvalidGitRepositoryError(epath)
 
 		self._bare = False
@@ -113,24 +125,38 @@ def __init__(self, path=None):
 		# adjust the wd in case we are actually bare - we didn't know that 
 		# in the first place
 		if self._bare:
-			self.wd = self.path
-
-		self.git = Git(self.wd)
+			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)
 
 	# Description property
 	def _get_description(self):
-		filename = os.path.join(self.path, 'description')
+		filename = os.path.join(self.git_dir, 'description')
 		return file(filename).read().rstrip()
 
 	def _set_description(self, descr):
-		filename = os.path.join(self.path, 'description')
+		filename = os.path.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):
+		"""
+		Returns
+			The working tree directory of our git repository
+			
+		Raises 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):
@@ -286,7 +312,7 @@ def _get_config_path(self, config_level ):
 		elif config_level == "global":
 			return os.path.expanduser("~/.gitconfig")
 		elif config_level == "repository":
-			return "%s/config" % self.path
+			return "%s/config" % self.git_dir
 
 		raise ValueError( "Invalid configuration level: %r" % config_level )
 
@@ -413,11 +439,11 @@ def iter_commits(self, rev=None, paths='', **kwargs):
 		return Commit.iter_items(self, rev, paths, **kwargs)
 
 	def _get_daemon_export(self):
-		filename = os.path.join(self.path, self.DAEMON_EXPORT_FILE)
+		filename = os.path.join(self.git_dir, self.DAEMON_EXPORT_FILE)
 		return os.path.exists(filename)
 
 	def _set_daemon_export(self, value):
-		filename = os.path.join(self.path, self.DAEMON_EXPORT_FILE)
+		filename = os.path.join(self.git_dir, self.DAEMON_EXPORT_FILE)
 		fileexists = os.path.exists(filename)
 		if value and not fileexists:
 			touch(filename)
@@ -436,7 +462,7 @@ def _get_alternates(self):
 		Returns
 			list of strings being pathnames of alternates
 		"""
-		alternates_path = os.path.join(self.path, 'objects', 'info', 'alternates')
+		alternates_path = os.path.join(self.git_dir, 'objects', 'info', 'alternates')
 
 		if os.path.exists(alternates_path):
 			try:
@@ -466,7 +492,7 @@ def _set_alternates(self, alts):
 		Returns
 			None
 		"""
-		alternates_path = os.path.join(self.path, 'objects', 'info', 'alternates') 
+		alternates_path = os.path.join(self.git_dir, 'objects', 'info', 'alternates') 
 		if not alts:
 			if os.path.isfile(alternates_path):
 				os.remove(alternates_path)
@@ -706,7 +732,7 @@ def clone(self, path, **kwargs):
 		# END windows handling 
 
 		try:
-			self.git.clone(self.path, path, **kwargs)
+			self.git.clone(self.git_dir, path, **kwargs)
 		finally:
 			if prev_cwd is not None:
 				os.chdir(prev_cwd)
@@ -754,4 +780,4 @@ def archive(self, ostream, treeish=None, prefix=None,  **kwargs):
 		return self
 
 	def __repr__(self):
-		return '<git.Repo "%s">' % self.path
+		return '<git.Repo "%s">' % self.git_dir
@@ -362,3 +362,18 @@ def iter_items(cls, repo, *args, **kwargs):
 		"""
 		raise NotImplementedError("To be implemented by Subclass")
 
+def needs_working_tree(func):
+	"""
+	Decorator assuring the wrapped method may only run if the repository has a
+	working tree, hence it is not bare.
+	"""
+	def check_default_index(self, *args, **kwargs):
+		if self.repo.working_tree_dir is None:
+			raise AssertionError( "Cannot call %r bare git repositories" % func.__name__ )
+		return func(self, *args, **kwargs)
+	# END wrpaper method
+	
+	check_default_index.__name__ = func.__name__
+	return check_default_index
+
+