Merge branch 'improvements'

1 files changed, 258 insertions, 16 deletions

diff --git a/lib/git/utils.py b/lib/git/utils.py
index f84c247d..48427ff2 100644
--- a/lib/git/utils.py
+++ b/lib/git/utils.py
@@ -5,27 +5,223 @@
 # the BSD License: http://www.opensource.org/licenses/bsd-license.php
 
 import os
+import sys
+import tempfile
 
-def dashify(string):
-	return string.replace('_', '-')
+try:
+    import hashlib
+except ImportError:
+    import sha
 
-def touch(filename):
-	os.utime(filename)
+def make_sha(source=''):
+    """
+    A python2.4 workaround for the sha/hashlib module fiasco
+    
+	Note
+		From the dulwich project
+	"""
+    try:
+        return hashlib.sha1(source)
+    except NameError:
+        sha1 = sha.sha(source)
+        return sha1
+
+
+class SHA1Writer(object):
+    """
+    Wrapper around a file-like object that remembers the SHA1 of 
+    the data written to it. It will write a sha when the stream is closed
+    or if the asked for explicitly usign write_sha.
+    
+    Note:
+    	Based on the dulwich project
+    """
+    __slots__ = ("f", "sha1")
+    
+    def __init__(self, f):
+        self.f = f
+        self.sha1 = make_sha("")
+
+    def write(self, data):
+        self.sha1.update(data)
+        self.f.write(data)
+
+    def write_sha(self):
+        sha = self.sha1.digest()
+        self.f.write(sha)
+        return sha
+
+    def close(self):
+        sha = self.write_sha()
+        self.f.close()
+        return sha
+
+    def tell(self):
+        return self.f.tell()
+
+
+class LockFile(object):
+	"""
+	Provides methods to obtain, check for, and release a file based lock which 
+	should be used to handle concurrent access to the same file.
+	
+	As we are a utility class to be derived from, we only use protected methods.
+	
+	Locks will automatically be released on destruction
+	"""
+	__slots__ = ("_file_path", "_owns_lock")
+	
+	def __init__(self, file_path):
+		self._file_path = file_path
+		self._owns_lock = False
+	
+	def __del__(self):
+		self._release_lock()
+	
+	def _lock_file_path(self):
+		"""
+		Return
+			Path to lockfile
+		"""
+		return "%s.lock" % (self._file_path)
+	
+	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_path, 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 is_git_dir(d):
-	""" This is taken from the git setup.c:is_git_directory
-		function."""
 
-	if os.path.isdir(d) and \
-			os.path.isdir(os.path.join(d, 'objects')) and \
-			os.path.isdir(os.path.join(d, 'refs')):
-		headref = os.path.join(d, 'HEAD')
-		return os.path.isfile(headref) or \
-				(os.path.islink(headref) and
-				os.readlink(headref).startswith('refs'))
-	return False
+class ConcurrentWriteOperation(LockFile):
+	"""
+	This class facilitates a safe write operation to a file on disk such that we: 
+	
+		- lock the original file
+		- write to a temporary file
+		- rename temporary file back to the original one on close
+		- unlock the original file
+		
+	This type handles error correctly in that it will assure a consistent state 
+	on destruction
+	"""
+	__slots__ = "_temp_write_fp"
+	
+	def __init__(self, file_path):
+		"""
+		Initialize an instance able to write the given file_path
+		"""
+		super(ConcurrentWriteOperation, self).__init__(file_path)
+		self._temp_write_fp = None
+	
+	def __del__(self):
+		self._end_writing(successful=False)
+		
+	def _begin_writing(self):
+		"""
+		Begin writing our file, hence we get a lock and start writing 
+		a temporary file in the same directory.
+		
+		Returns
+			File Object to write to. It is still maintained by this instance
+			and you do not need to manually close 
+		"""
+		# already writing ? 
+		if self._temp_write_fp is not None:
+			return self._temp_write_fp
+			
+		self._obtain_lock_or_raise()
+		dirname, basename = os.path.split(self._file_path)
+		self._temp_write_fp = open(tempfile.mktemp(basename, '', dirname), "w")
+		return self._temp_write_fp
+		
+	def _is_writing(self):
+		"""
+		Returns 
+			True if we are currently writing a file
+		"""
+		return self._temp_write_fp is not None
 	
+	def _end_writing(self, successful=True):
+		"""
+		Indicate you successfully finished writing the file to:
+		
+			- close the underlying stream
+			- rename the remporary file to the original one
+			- release our lock
+		"""
+		# did we start a write operation ?
+		if self._temp_write_fp is None:
+			return 
+			
+		if not self._temp_write_fp.closed:
+			self._temp_write_fp.close()
+		
+		if successful:
+			# on windows, rename does not silently overwrite the existing one
+			if sys.platform == "win32":
+				if os.path.isfile(self._file_path):
+					os.remove(self._file_path)
+				# END remove if exists
+			# END win32 special handling
+			os.rename(self._temp_write_fp.name, self._file_path)
+		else:
+			# just delete the file so far, we failed
+			os.remove(self._temp_write_fp.name)
+		# END successful handling
 	
+		# finally reset our handle
+		self._release_lock()
+		self._temp_write_fp = None
+
+
 class LazyMixin(object):
 	"""
 	Base class providing an interface to lazily retrieve attribute values upon 
@@ -56,12 +252,55 @@ class LazyMixin(object):
 		pass
 
 
+class IterableList(list):
+	"""
+	List of iterable objects allowing to query an object by id or by named index::
+	 
+	 heads = repo.heads
+	 heads.master
+	 heads['master']
+	 heads[0]
+	 
+	It requires an id_attribute name to be set which will be queried from its 
+	contained items to have a means for comparison.
+	
+	A prefix can be specified which is to be used in case the id returned by the 
+	items always contains a prefix that does not matter to the user, so it 
+	can be left out.
+	"""
+	__slots__ = ('_id_attr', '_prefix')
+	
+	def __new__(cls, id_attr, prefix=''):
+		return super(IterableList,cls).__new__(cls)
+		
+	def __init__(self, id_attr, prefix=''):
+		self._id_attr = id_attr
+		self._prefix = prefix
+		
+	def __getattr__(self, attr):
+		attr = self._prefix + attr
+		for item in self:
+			if getattr(item, self._id_attr) == attr:
+				return item
+		# END for each item
+		return list.__getattribute__(self, attr)
+		
+	def __getitem__(self, index):
+		if isinstance(index, int):
+			return list.__getitem__(self,index)
+		
+		try:
+			return getattr(self, index)
+		except AttributeError:
+			raise IndexError( "No item found with id %r" % self._prefix + index )
+
 class Iterable(object):
 	"""
 	Defines an interface for iterable items which is to assure a uniform 
 	way to retrieve and iterate items within the git repository
 	"""
 	__slots__ = tuple()
+	_id_attribute_ = "attribute that most suitably identifies your instance"
 	
 	@classmethod
 	def list_items(cls, repo, *args, **kwargs):
@@ -75,7 +314,10 @@ class Iterable(object):
 		Returns:
 			list(Item,...) list of item instances 
 		"""
-		return list(cls.iter_items(repo, *args, **kwargs))
+		#return list(cls.iter_items(repo, *args, **kwargs))
+		out_list = IterableList( cls._id_attribute_ )
+		out_list.extend(cls.iter_items(repo, *args, **kwargs))
+		return out_list
 		
 		
 	@classmethod