Merge branch 'submodule'

Author: Byron

lib/git/config.py

@@ -15,27 +15,31 @@
 from git.odict import OrderedDict
 from git.util import LockFile
 
-__all__ = ('GitConfigParser', )
+__all__ = ('GitConfigParser', 'SectionConstraint')
 
 class MetaParserBuilder(type):
 	"""Utlity class wrapping base-class methods into decorators that assure read-only properties"""
 	def __new__(metacls, name, bases, clsdict):
 		"""
 		Equip all base-class methods with a needs_values decorator, and all non-const methods
 		with a set_dirty_and_flush_changes decorator in addition to that."""
-		mutating_methods = clsdict['_mutating_methods_']
-		for base in bases:
-			methods = ( t for t in inspect.getmembers(base, inspect.ismethod) if not t[0].startswith("_") )
-			for name, method in methods:
-				if name in clsdict:
-					continue
-				method_with_values = needs_values(method)
-				if name in mutating_methods:
-					method_with_values = set_dirty_and_flush_changes(method_with_values)
-				# END mutating methods handling
-				
-				clsdict[name] = method_with_values
-		# END for each base
+		kmm = '_mutating_methods_'
+		if kmm in clsdict:
+			mutating_methods = clsdict[kmm]
+			for base in bases:
+				methods = ( t for t in inspect.getmembers(base, inspect.ismethod) if not t[0].startswith("_") )
+				for name, method in methods:
+					if name in clsdict:
+						continue
+					method_with_values = needs_values(method)
+					if name in mutating_methods:
+						method_with_values = set_dirty_and_flush_changes(method_with_values)
+					# END mutating methods handling
+					
+					clsdict[name] = method_with_values
+				# END for each name/method pair
+			# END for each base
+		# END if mutating methods configuration is set
 
 		new_type = super(MetaParserBuilder, metacls).__new__(metacls, name, bases, clsdict)
 		return new_type
@@ -63,7 +67,35 @@ def flush_changes(self, *args, **kwargs):
 	flush_changes.__name__ = non_const_func.__name__
 	return flush_changes
 
+
+class SectionConstraint(object):
+	"""Constrains a ConfigParser to only option commands which are constrained to 
+	always use the section we have been initialized with.
+	
+	It supports all ConfigParser methods that operate on an option"""
+	__slots__ = ("_config", "_section_name")
+	_valid_attrs_ = ("get_value", "set_value", "get", "set", "getint", "getfloat", "getboolean", "has_option", 
+					"remove_section", "remove_option", "options")
 
+	def __init__(self, config, section):
+		self._config = config
+		self._section_name = section
+		
+	def __getattr__(self, attr):
+		if attr in self._valid_attrs_:
+			return lambda *args, **kwargs: self._call_config(attr, *args, **kwargs)
+		return super(SectionConstraint,self).__getattribute__(attr)
+		
+	def _call_config(self, method, *args, **kwargs):
+		"""Call the configuration at the given method which must take a section name 
+		as first argument"""
+		return getattr(self._config, method)(self._section_name, *args, **kwargs)
+		
+	@property
+	def config(self):
+		"""return: Configparser instance we constrain"""
+		return self._config
+		
 
 class GitConfigParser(cp.RawConfigParser, object):
 	"""Implements specifics required to read git style configuration files.
@@ -249,9 +281,9 @@ def read(self):
 			if not hasattr(file_object, "seek"):
 				try:
 					fp = open(file_object)
+					close_fp = True
 				except IOError,e:
 					continue
-				close_fp = True
 			# END fp handling
 
 			try:
@@ -286,17 +318,21 @@ def write(self):
 		:raise IOError: if this is a read-only writer instance or if we could not obtain 
 			a file lock"""
 		self._assure_writable("write")
-		self._lock._obtain_lock()
-		
 
 		fp = self._file_or_files
 		close_fp = False
 
+		# we have a physical file on disk, so get a lock
+		if isinstance(fp, (basestring, file)):
+			self._lock._obtain_lock()
+		# END get lock for physical files
+		
 		if not hasattr(fp, "seek"):
 			fp = open(self._file_or_files, "w")
 			close_fp = True
 		else:
 			fp.seek(0)
+		# END handle stream or file
 
 		# WRITE DATA
 		try:
@@ -368,7 +404,7 @@ def get_value(self, section, option, default = None):
 		return valuestr
 
 	@needs_values
-	@set_dirty_and_flush_changes	
+	@set_dirty_and_flush_changes
 	def set_value(self, section, option, value):
 		"""Sets the given option in section to the given value.
 		It will create the section if required, and will not throw as opposed to the default 

lib/git/ext/gitdb

@@ -35,7 +35,8 @@
 						)
 
 from git.objects import (
-							Blob, 
+							Blob,
+							Submodule,
 							Tree, 
 							Object, 
 							Commit,
@@ -553,7 +554,7 @@ def _preprocess_add_items(self, items):
 		for item in items:
 			if isinstance(item, basestring):
 				paths.append(self._to_relative_path(item))
-			elif isinstance(item, Blob):
+			elif isinstance(item, (Blob, Submodule)):
 				entries.append(BaseIndexEntry.from_blob(item))
 			elif isinstance(item, BaseIndexEntry):
 				entries.append(item)
@@ -588,7 +589,7 @@ def add(self, items, force=True, fprogress=lambda *args: None, path_rewriter=Non
 
 				They are added at stage 0
 
-			- Blob object
+			- Blob or Submodule object
 				Blobs are added as they are assuming a valid mode is set.
 				The file they refer to may or may not exist in the file system, but
 				must be a path relative to our repository.
@@ -612,6 +613,7 @@ def add(self, items, force=True, fprogress=lambda *args: None, path_rewriter=Non
 				explicitly set. Please note that Index Entries require binary sha's.
 
 		:param force:
+			**CURRENTLY INEFFECTIVE**
 			If True, otherwise ignored or excluded files will be
 			added anyway.
 			As opposed to the git-add command, we enable this flag by default
@@ -748,7 +750,7 @@ def _items_to_rela_paths(self, items):
 		may be absolute or relative paths, entries or blobs"""
 		paths = list()
 		for item in items:
-			if isinstance(item, (BaseIndexEntry,Blob)):
+			if isinstance(item, (BaseIndexEntry,(Blob, Submodule))):
 				paths.append(self._to_relative_path(item.path))
 			elif isinstance(item, basestring):
 				paths.append(self._to_relative_path(item))
@@ -775,7 +777,7 @@ def remove(self, items, working_tree=False, **kwargs):
 
 				The path string may include globs, such as *.c.
 
-			- Blob object
+			- Blob Object
 				Only the path portion is used in this case.
 
 			- BaseIndexEntry or compatible type

lib/git/index/base.py

@@ -30,6 +30,7 @@
 					CE_NAMEMASK, 
 					CE_STAGESHIFT
 				)
+CE_NAMEMASK_INV = ~CE_NAMEMASK
 
 from util import 	(
 					pack, 
@@ -53,22 +54,6 @@ def stat_mode_to_index_mode(mode):
 	return S_IFREG | 0644 | (mode & 0100) 		# blobs with or without executable bit
 
 
-def write_cache_entry(entry, stream):
-	"""Write the given entry to the stream"""
-	beginoffset = stream.tell()
-	write = stream.write
-	write(entry[4])			# ctime
-	write(entry[5])			# mtime
-	path = entry[3]
-	plen = len(path) & CE_NAMEMASK		# path length
-	assert plen == len(path), "Path %s too long to fit into index" % entry[3]
-	flags = plen | entry[2]
-	write(pack(">LLLLLL20sH", entry[6], entry[7], entry[0],
-								entry[8], entry[9], entry[10], entry[1], flags))
-	write(path)
-	real_size = ((stream.tell() - beginoffset + 8) & ~7)
-	write("\0" * ((beginoffset + real_size) - stream.tell()))
-
 def write_cache(entries, stream, extension_data=None, ShaStreamCls=IndexFileSHA1Writer):
 	"""Write the cache represented by entries to a stream
 	
@@ -83,15 +68,29 @@ def write_cache(entries, stream, extension_data=None, ShaStreamCls=IndexFileSHA1
 		a 4 byte identifier, followed by its size ( 4 bytes )"""
 	# wrap the stream into a compatible writer
 	stream = ShaStreamCls(stream)
+	
+	tell = stream.tell
+	write = stream.write
 
 	# header
 	version = 2
-	stream.write("DIRC")
-	stream.write(pack(">LL", version, len(entries)))
+	write("DIRC")
+	write(pack(">LL", version, len(entries)))
 
 	# body
 	for entry in entries:
-		write_cache_entry(entry, stream)
+		beginoffset = tell()
+		write(entry[4])			# ctime
+		write(entry[5])			# mtime
+		path = entry[3]
+		plen = len(path) & CE_NAMEMASK		# path length
+		assert plen == len(path), "Path %s too long to fit into index" % entry[3]
+		flags = plen | (entry[2] & CE_NAMEMASK_INV)		# clear possible previous values
+		write(pack(">LLLLLL20sH", entry[6], entry[7], entry[0],
+									entry[8], entry[9], entry[10], entry[1], flags))
+		write(path)
+		real_size = ((tell() - beginoffset + 8) & ~7)
+		write("\0" * ((beginoffset + real_size) - tell()))
 	# END for each entry
 
 	# write previously cached extensions data
@@ -101,21 +100,6 @@ def write_cache(entries, stream, extension_data=None, ShaStreamCls=IndexFileSHA1
 	# write the sha over the content
 	stream.write_sha()
 
-def read_entry(stream):
-	"""Return: One entry of the given stream"""
-	beginoffset = stream.tell()
-	read = stream.read
-	ctime = unpack(">8s", read(8))[0]
-	mtime = unpack(">8s", read(8))[0]
-	(dev, ino, mode, uid, gid, size, sha, flags) = \
-		unpack(">LLLLLL20sH", read(20 + 4 * 6 + 2))
-	path_size = flags & CE_NAMEMASK
-	path = read(path_size)
-
-	real_size = ((stream.tell() - beginoffset + 8) & ~7)
-	data = read((beginoffset + real_size) - stream.tell())
-	return IndexEntry((mode, sha, flags, path, ctime, mtime, dev, ino, uid, gid, size))
-
 def read_header(stream):
 		"""Return tuple(version_long, num_entries) from the given stream"""
 		type_id = stream.read(4)
@@ -147,10 +131,23 @@ def read_cache(stream):
 	version, num_entries = read_header(stream)
 	count = 0
 	entries = dict()
+	
+	read = stream.read
+	tell = stream.tell
 	while count < num_entries:
-		entry = read_entry(stream)
+		beginoffset = tell()
+		ctime = unpack(">8s", read(8))[0]
+		mtime = unpack(">8s", read(8))[0]
+		(dev, ino, mode, uid, gid, size, sha, flags) = \
+			unpack(">LLLLLL20sH", read(20 + 4 * 6 + 2))
+		path_size = flags & CE_NAMEMASK
+		path = read(path_size)
+	
+		real_size = ((tell() - beginoffset + 8) & ~7)
+		data = read((beginoffset + real_size) - tell())
+		entry = IndexEntry((mode, sha, flags, path, ctime, mtime, dev, ino, uid, gid, size))
 		# entry_key would be the method to use, but we safe the effort
-		entries[(entry.path, entry.stage)] = entry
+		entries[(path, entry.stage)] = entry
 		count += 1
 	# END for each entry
 

lib/git/index/fun.py

@@ -3,11 +3,18 @@
 """
 import inspect
 from base import *
+# Fix import dependency - add IndexObject to the util module, so that it can be 
+# imported by the submodule.base
+import submodule.util
+submodule.util.IndexObject = IndexObject
+from submodule.base import *
+from submodule.root import *
+
+# must come after submodule was made available
 from tag import *
 from blob import *
-from tree import *
 from commit import *
-from submodule import *
+from tree import *
 from util import Actor
 
 __all__ = [ name for name, obj in locals().items()

lib/git/objects/__init__.py

@@ -62,17 +62,6 @@ def new_from_sha(cls, repo, sha1):
 		inst.size = oinfo.size
 		return inst 
 
-	def _set_self_from_args_(self, args_dict):
-		"""Initialize attributes on self from the given dict that was retrieved
-		from locals() in the calling method.
-		
-		Will only set an attribute on self if the corresponding value in args_dict
-		is not None"""
-		for attr, val in args_dict.items():
-			if attr != "self" and val is not None:
-				setattr( self, attr, val )
-		# END set all non-None attributes
-	
 	def _set_cache_(self, attr):
 		"""Retrieve object information"""
 		if attr	 == "size":
@@ -125,7 +114,10 @@ def stream_data(self, ostream):
 class IndexObject(Object):
 	"""Base for all objects that can be part of the index file , namely Tree, Blob and
 	SubModule objects"""
-	__slots__ = ("path", "mode") 
+	__slots__ = ("path", "mode")
+	
+	# for compatability with iterable lists
+	_id_attribute_ = 'path'
 
 	def __init__(self, repo, binsha, mode=None, path=None):
 		"""Initialize a newly instanced IndexObject
@@ -140,7 +132,10 @@ def __init__(self, repo, binsha, mode=None, path=None):
 			Path may not be set of the index object has been created directly as it cannot
 			be retrieved without knowing the parent tree."""
 		super(IndexObject, self).__init__(repo, binsha)
-		self._set_self_from_args_(locals())
+		if mode is not None:
+			self.mode = mode
+		if path is not None:
+			self.path = path
 
 	def __hash__(self):
 		""":return: