@@ -58,6 +58,15 @@ Index
   creating several tree objects, so in the end it might be slower. 
   Hmm, probably its okay to use the command unless we go c(++)
 
+
+Head.reset
+----------
+* Should better be an instance method. Problem was that there is no class specifying
+  the HEAD  - in a way reset would always effect the active branch.
+  Probably it would be okay to have a special type called SymbolicReference
+  which represents items like HEAD. These could naturally carry the reset 
+  instance method.
+  
 Remote
 ------
 * 'push' method needs a test, a true test repository is required though, a fork 
 
@@ -11,10 +11,12 @@
 import re
 import os
 import ConfigParser as cp
-from git.odict import OrderedDict
 import inspect
 import cStringIO
 
+from git.odict import OrderedDict
+from git.utils import LockFile
+
 class _MetaParserBuilder(type):
 	"""
 	Utlity class wrapping base-class methods into decorators that assure read-only properties
@@ -70,7 +72,7 @@ def flush_changes(self, *args, **kwargs):
 
 
 
-class GitConfigParser(cp.RawConfigParser, object):
+class GitConfigParser(cp.RawConfigParser, LockFile):
 	"""
 	Implements specifics required to read git style configuration files.
 	
@@ -100,6 +102,7 @@ class GitConfigParser(cp.RawConfigParser, object):
 
 	# list of RawConfigParser methods able to change the instance
 	_mutating_methods_ = ("add_section", "remove_section", "remove_option", "set")
+	__slots__ = ("_sections", "_defaults", "_file_or_files", "_read_only","_is_initialized")
 
 	def __init__(self, file_or_files, read_only=True):
 		"""
@@ -120,7 +123,6 @@ def __init__(self, file_or_files, read_only=True):
 
 		self._file_or_files = file_or_files
 		self._read_only = read_only
-		self._owns_lock = False
 		self._is_initialized = False
 
 
@@ -129,10 +131,11 @@ def __init__(self, file_or_files, read_only=True):
 				raise ValueError("Write-ConfigParsers can operate on a single file only, multiple files have been passed")
 			# END single file check
 
-			self._file_name = file_or_files
-			if not isinstance(self._file_name, basestring):
-				self._file_name = file_or_files.name
-			# END get filename
+			if not isinstance(file_or_files, basestring):
+				file_or_files = file_or_files.name
+			# END get filename from handle/stream
+			# initialize lock base - we want to write
+			LockFile.__init__(self, file_or_files)
 
 			self._obtain_lock_or_raise()	
 		# END read-only check
@@ -155,67 +158,6 @@ def __del__(self):
 		finally:
 			self._release_lock()
 
-	def _lock_file_path(self):
-		"""
-		Return
-			Path to lockfile
-		"""
-		return "%s.lock" % (self._file_name)
-	
-	def _has_lock(self):
-		"""
-		Return
-			True if we have a lock and if the lockfile still exists
-			
-		Raise
-			AssertionError if our lock-file does not exist
-		"""
-		if not self._owns_lock:
-			return False
-		
-		lock_file = self._lock_file_path()
-		try:
-			fp = open(lock_file, "r")
-			pid = int(fp.read())
-			fp.close()
-		except IOError:
-			raise AssertionError("GitConfigParser has a lock but the lock file at %s could not be read" % lock_file)
-		
-		if pid != os.getpid():
-			raise AssertionError("We claim to own the lock at %s, but it was not owned by our process: %i" % (lock_file, os.getpid()))
-		
-		return True
-		
-	def _obtain_lock_or_raise(self):
-		"""
-		Create a lock file as flag for other instances, mark our instance as lock-holder
-		
-		Raise
-			IOError if a lock was already present or a lock file could not be written
-		"""
-		if self._has_lock():
-			return 
-			
-		lock_file = self._lock_file_path()
-		if os.path.exists(lock_file):
-			raise IOError("Lock for file %r did already exist, delete %r in case the lock is illegal" % (self._file_name, lock_file))
-		
-		fp = open(lock_file, "w")
-		fp.write(str(os.getpid()))
-		fp.close()
-		
-		self._owns_lock = True
-		
-	def _release_lock(self):
-		"""
-		Release our lock if we have one
-		"""
-		if not self._has_lock():
-			return 
-			
-		os.remove(self._lock_file_path())
-		self._owns_lock = False
-		
 	def optionxform(self, optionstr):
 		"""
 		Do not transform options in any way when writing
 
@@ -18,13 +18,18 @@ class Diffable(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
+	# standin indicating you want to diff against the index
 	class Index(object):
 		pass 
+		
+	def _process_diff_args(self, args):
+		"""
+		Returns
+			possibly altered version of the given args list.
+			Method is called right before git command execution.
+			Subclasses can use it to alter the behaviour of the superclass
+		"""
+		return args
 
 	def diff(self, other=Index, paths=None, create_patch=False, **kwargs):
 		"""
@@ -60,13 +65,13 @@ def diff(self, other=Index, paths=None, create_patch=False, **kwargs):
 			On a bare repository, 'other' needs to be provided as Index or as 
 			as Tree/Commit, or a git command error will occour
 		"""
-		args = list(self._diff_args[:])
+		args = list()
 		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
+			args.append("-M") 				# check for renames
 		else:
 			args.append("--raw")
 
@@ -87,7 +92,7 @@ def diff(self, other=Index, paths=None, create_patch=False, **kwargs):
 		# END paths handling
 
 		kwargs['as_process'] = True
-		proc = self.repo.git.diff(*args, **kwargs)
+		proc = self.repo.git.diff(*self._process_diff_args(args), **kwargs)
 
 		diff_method = Diff._index_from_raw_format
 		if create_patch:
@@ -96,7 +101,7 @@ def diff(self, other=Index, paths=None, create_patch=False, **kwargs):
 
 		status = proc.wait()
 		if status != 0:
-			raise GitCommandError("git-diff", status, proc.stderr )
+			raise GitCommandError(("git diff",)+tuple(args), status, proc.stderr.read())
 
 		return index
 
@@ -207,6 +212,20 @@ def __init__(self, repo, a_path, b_path, a_blob_id, b_blob_id, a_mode,
 
 		self.diff = diff
 
+
+	def __eq__(self, other):
+		for name in self.__slots__:
+			if getattr(self, name) != getattr(other, name):
+				return False
+		# END for each name
+		return True
+		
+	def __ne__(self, other):
+		return not ( self == other )
+		
+	def __hash__(self):
+		return hash(tuple(getattr(self,n) for n in self.__slots__))
+
 	@property
 	def renamed(self):
 		"""
 
@@ -25,8 +25,8 @@ def __init__(self, command, status, stderr=None):
 		self.stderr = stderr
 		self.status = status
 		self.command = command
-
+		
 	def __str__(self):
-		return repr("'%s' returned exit status %d: %r" %
-					(' '.join(self.command), self.status, str(self.stderr)))
+		return ("'%s' returned exit status %i: %s" %
+					(' '.join(str(i) for i in self.command), self.status, self.stderr))