Merge branch 'remote-fixes' into 0.3

Byron · Byron · commit 1ddf05a78475 · 2011-07-04T23:26:13.000+02:00
diff --git a/.gitmodules b/.gitmodules
@@ -1,3 +1,3 @@
-[submodule "gitdb"]
-	path = git/ext/gitdb
-	url = git://github.com/gitpython-developers/gitdb.git
+[submodule "gitdb"]
+	path = git/ext/gitdb
+	url = git://github.com/gitpython-developers/gitdb.git
diff --git a/git/ext/gitdb b/git/ext/gitdb
@@ -1 +1 @@
-Subproject commit 4524faf0d0c5383268b134084954b34faeaa766d
+Subproject commit a5ed410aa0d3bed587214c3c017af2916b740da1
diff --git a/git/refs/reference.py b/git/refs/reference.py
@@ -13,6 +13,18 @@
 
 __all__ = ["Reference"]
 
+#{ Utilities
+def require_remote_ref_path(func):
+	"""A decorator raising a TypeError if we are not a valid remote, based on the path"""
+	def wrapper(self, *args):
+		if not self.path.startswith(self._remote_common_path_default + "/"):
+			raise ValueError("ref path does not point to a remote reference: %s" % path)
+		return func(self, *args)
+	#END wrapper
+	wrapper.__name__ = func.__name__
+	return wrapper
+#}END utilites
+
 
 class Reference(SymbolicReference, LazyMixin, Iterable):
 	"""Represents a named reference to any object. Subclasses may apply restrictions though, 
@@ -22,20 +34,24 @@ class Reference(SymbolicReference, LazyMixin, Iterable):
 	_resolve_ref_on_create = True
 	_common_path_default = "refs"
 	
-	def __init__(self, repo, path):
+	def __init__(self, repo, path, check_path = True):
 		"""Initialize this instance
 		:param repo: Our parent repository
 		
 		:param path:
 			Path relative to the .git/ directory pointing to the ref in question, i.e.
-			refs/heads/master"""
-		if not path.startswith(self._common_path_default+'/'):
-			raise ValueError("Cannot instantiate %r from path %s" % ( self.__class__.__name__, path ))
+			refs/heads/master
+		:param check_path: if False, you can provide any path. Otherwise the path must start with the 
+			default path prefix of this type."""
+		if check_path and not path.startswith(self._common_path_default+'/'):
+			raise ValueError("Cannot instantiate %r from path %s" % (self.__class__.__name__, path))
 		super(Reference, self).__init__(repo, path)
 		
 
 	def __str__(self):
 		return self.name
+		
+	#{ Interface
 
 	def set_object(self, object, logmsg = None):
 		"""Special version which checks if the head-log needs an update as well"""
@@ -82,3 +98,30 @@ def iter_items(cls, repo, common_path = None):
 		"""Equivalent to SymbolicReference.iter_items, but will return non-detached
 		references as well."""
 		return cls._iter_items(repo, common_path)
+		
+	#}END interface
+	
+	
+	#{ Remote Interface
+	
+	@property
+	@require_remote_ref_path
+	def remote_name(self):
+		"""
+		:return:
+			Name of the remote we are a reference of, such as 'origin' for a reference
+			named 'origin/master'"""
+		tokens = self.path.split('/')
+		# /refs/remotes/<remote name>/<branch_name>
+		return tokens[2]
+		
+	@property
+	@require_remote_ref_path
+	def remote_head(self):
+		""":return: Name of the remote head itself, i.e. master.
+		:note: The returned name is usually not qualified enough to uniquely identify
+			a branch"""
+		tokens = self.path.split('/')
+		return '/'.join(tokens[3:])
+	
+	#} END remote interface
diff --git a/git/refs/remote.py b/git/refs/remote.py
@@ -10,7 +10,7 @@
 	
 class RemoteReference(Head):
 	"""Represents a reference pointing to a remote head."""
-	_common_path_default = "refs/remotes"
+	_common_path_default = Head._remote_common_path_default
 	
 	
 	@classmethod
@@ -22,24 +22,6 @@ def iter_items(cls, repo, common_path = None, remote=None):
 		# END handle remote constraint
 		return super(RemoteReference, cls).iter_items(repo, common_path)
 	
-	@property
-	def remote_name(self):
-		"""
-		:return:
-			Name of the remote we are a reference of, such as 'origin' for a reference
-			named 'origin/master'"""
-		tokens = self.path.split('/')
-		# /refs/remotes/<remote name>/<branch_name>
-		return tokens[2]
-		
-	@property
-	def remote_head(self):
-		""":return: Name of the remote head itself, i.e. master.
-		:note: The returned name is usually not qualified enough to uniquely identify
-			a branch"""
-		tokens = self.path.split('/')
-		return '/'.join(tokens[3:])
-		
 	@classmethod
 	def delete(cls, repo, *refs, **kwargs):
 		"""Delete the given remote references.
diff --git a/git/refs/symbolic.py b/git/refs/symbolic.py
@@ -33,6 +33,7 @@ class SymbolicReference(object):
 	_resolve_ref_on_create = False
 	_points_to_commits_only = True
 	_common_path_default = ""
+	_remote_common_path_default = "refs/remotes"
 	_id_attribute_ = "name"
 	
 	def __init__(self, repo, path):
diff --git a/git/remote.py b/git/remote.py
@@ -271,18 +271,44 @@ def _from_line(cls, repo, line, fetch_line):
 		ref_type = None
 		if remote_local_ref == "FETCH_HEAD":
 			ref_type = SymbolicReference
-		elif ref_type_name	== "branch":
+		elif ref_type_name in ("remote-tracking", "branch"):
+			# note: remote-tracking is just the first part of the 'remote-tracking branch' token.
+			# We don't parse it correctly, but its enough to know what to do, and its new in git 1.7something
 			ref_type = RemoteReference
 		elif ref_type_name == "tag":
 			ref_type = TagReference
 		else:
 			raise TypeError("Cannot handle reference type: %r" % ref_type_name)
+		#END handle ref type
 			
 		# create ref instance
 		if ref_type is SymbolicReference:
 			remote_local_ref = ref_type(repo, "FETCH_HEAD") 
 		else:
-			remote_local_ref = Reference.from_path(repo, join_path(ref_type._common_path_default, remote_local_ref.strip()))
+			# determine prefix. Tags are usually pulled into refs/tags, they may have subdirectories.
+			# It is not clear sometimes where exactly the item is, unless we have an absolute path as indicated
+			# by the 'ref/' prefix. Otherwise even a tag could be in refs/remotes, which is when it will have the
+			# 'tags/' subdirectory in its path.
+			# We don't want to test for actual existence, but try to figure everything out analytically.
+			ref_path = None
+			remote_local_ref = remote_local_ref.strip()
+			if remote_local_ref.startswith(Reference._common_path_default + "/"):
+				# always use actual type if we get absolute paths
+				# Will always be the case if something is fetched outside of refs/remotes (if its not a tag)
+				ref_path = remote_local_ref
+				if ref_type is not TagReference and not remote_local_ref.startswith(RemoteReference._common_path_default + "/"):
+					ref_type = Reference
+				#END downgrade remote reference
+			elif ref_type is TagReference and 'tags/' in remote_local_ref:
+				# even though its a tag, it is located in refs/remotes
+				ref_path = join_path(RemoteReference._common_path_default, remote_local_ref)
+			else:
+				ref_path = join_path(ref_type._common_path_default, remote_local_ref)
+			#END obtain refpath
+			
+			# even though the path could be within the git conventions, we make 
+			# sure we respect whatever the user wanted, and disabled path checking
+			remote_local_ref = ref_type(repo, ref_path, check_path=False)
 		# END create ref instance 
 		
 		note = ( note and note.strip() ) or ''
diff --git a/git/test/test_refs.py b/git/test/test_refs.py
@@ -24,6 +24,11 @@ def test_from_path(self):
 				assert isinstance(instance, ref_type)
 			# END for each name 
 		# END for each type
+		
+		# invalid path
+		self.failUnlessRaises(ValueError, TagReference, self.rorepo, "refs/invalid/tag")
+		# works without path check
+		TagReference(self.rorepo, "refs/invalid/tag", check_path=False)
 	
 	def test_tag_base(self):
 		tag_object_refs = list()
diff --git a/git/test/test_remote.py b/git/test/test_remote.py
