From dec4663129f72321a14efd6de63f14a7419e3ed2 Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Tue, 23 Nov 2010 09:14:17 +0100
Subject: Split ref implementation up into multiple files, to make room for the
 log implementation

---
 refs/symbolic.py | 512 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 512 insertions(+)
 create mode 100644 refs/symbolic.py

(limited to 'refs/symbolic.py')

diff --git a/refs/symbolic.py b/refs/symbolic.py
new file mode 100644
index 00000000..3329d51c
--- /dev/null
+++ b/refs/symbolic.py
@@ -0,0 +1,512 @@
+import os
+from git.objects import Commit
+from git.util import (
+					join_path, 
+					join_path_native, 
+					to_native_path_linux
+					)
+
+from gitdb.util import (
+							join, 
+							dirname,
+							isdir,
+							exists,
+							isfile,
+							rename,
+							hex_to_bin
+						)
+
+__all__ = ["SymbolicReference"]
+
+class SymbolicReference(object):
+	"""Represents a special case of a reference such that this reference is symbolic.
+	It does not point to a specific commit, but to another Head, which itself 
+	specifies a commit.
+	
+	A typical example for a symbolic reference is HEAD."""
+	__slots__ = ("repo", "path")
+	_common_path_default = ""
+	_id_attribute_ = "name"
+	
+	def __init__(self, repo, path):
+		self.repo = repo
+		self.path = path
+		
+	def __str__(self):
+		return self.path
+		
+	def __repr__(self):
+		return '<git.%s "%s">' % (self.__class__.__name__, self.path)
+		
+	def __eq__(self, other):
+		return self.path == other.path
+		
+	def __ne__(self, other):
+		return not ( self == other )
+		
+	def __hash__(self):
+		return hash(self.path)
+		
+	@property
+	def name(self):
+		"""
+		:return:
+			In case of symbolic references, the shortest assumable name 
+			is the path itself."""
+		return self.path
+	
+	def _abs_path(self):
+		return join_path_native(self.repo.git_dir, self.path)
+		
+	@classmethod
+	def _get_packed_refs_path(cls, repo):
+		return join(repo.git_dir, 'packed-refs')
+		
+	@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(cls._get_packed_refs_path(repo), 'r')
+			for line in fp:
+				line = line.strip()
+				if not line:
+					continue
+				if line.startswith('#'):
+					if line.startswith('# pack-refs with:') and not line.endswith('peeled'):
+						raise TypeError("PackingType of packed-Refs not understood: %r" % line)
+					# END abort if we do not understand the packing scheme
+					continue
+				# END parse comment
+				
+				# skip dereferenced tag object entries - previous line was actual
+				# tag reference for it
+				if line[0] == '^':
+					continue
+				
+				yield tuple(line.split(' ', 1))
+			# END for each line
+		except (OSError,IOError):
+			raise StopIteration
+		# END no packed-refs file handling 
+		# NOTE: Had try-finally block around here to close the fp, 
+		# but some python version woudn't allow yields within that.
+		# I believe files are closing themselves on destruction, so it is 
+		# alright.
+		
+	@classmethod
+	def dereference_recursive(cls, repo, ref_path):
+		"""
+		:return: hexsha stored in the reference at the given ref_path, recursively dereferencing all
+			intermediate references as required
+		:param repo: the repository containing the reference at ref_path"""
+		while True:
+			ref = cls(repo, ref_path)
+			hexsha, ref_path = ref._get_ref_info()
+			if hexsha is not None:
+				return hexsha
+		# END recursive dereferencing
+		
+	def _get_ref_info(self):
+		"""Return: (sha, target_ref_path) if available, the sha the file at 
+		rela_path points to, or None. target_ref_path is the reference we 
+		point to, or None"""
+		tokens = None
+		try:
+			fp = open(self._abs_path(), 'r')
+			value = fp.read().rstrip()
+			fp.close()
+			tokens = value.split(" ")
+		except (OSError,IOError):
+			# Probably we are just packed, find our entry in the packed refs file
+			# NOTE: We are not a symbolic ref if we are in a packed file, as these
+			# are excluded explictly
+			for sha, path in self._iter_packed_refs(self.repo):
+				if path != self.path: continue
+				tokens = (sha, path)
+				break
+			# END for each packed ref
+		# END handle packed refs
+		
+		if tokens is None:
+			raise ValueError("Reference at %r does not exist" % self.path)
+		
+		# is it a reference ?
+		if tokens[0] == 'ref:':
+			return (None, tokens[1])
+			
+		# its a commit
+		if self.repo.re_hexsha_only.match(tokens[0]):
+			return (tokens[0], None)
+			
+		raise ValueError("Failed to parse reference information from %r" % self.path)
+		
+	def _get_commit(self):
+		"""
+		:return:
+			Commit object we point to, works for detached and non-detached 
+			SymbolicReferences"""
+		# we partially reimplement it to prevent unnecessary file access
+		hexsha, target_ref_path = self._get_ref_info()
+		
+		# it is a detached reference
+		if hexsha:
+			return Commit(self.repo, hex_to_bin(hexsha))
+		
+		return self.from_path(self.repo, target_ref_path).commit
+		
+	def _set_commit(self, commit):
+		"""Set our commit, possibly dereference our symbolic reference first.
+		If the reference does not exist, it will be created"""
+		is_detached = True
+		try:
+			is_detached = self.is_detached
+		except ValueError:
+			pass
+		# END handle non-existing ones
+		if is_detached:
+			return self._set_reference(commit)
+			
+		# set the commit on our reference
+		self._get_reference().commit = commit
+	
+	commit = property(_get_commit, _set_commit, doc="Query or set commits directly")
+		
+	def _get_reference(self):
+		""":return: Reference Object we point to"""
+		sha, target_ref_path = self._get_ref_info()
+		if target_ref_path is None:
+			raise TypeError("%s is a detached symbolic reference as it points to %r" % (self, sha))
+		return self.from_path(self.repo, target_ref_path)
+		
+	def _set_reference(self, ref):
+		"""Set ourselves to the given ref. It will stay a symbol if the ref is a Reference.
+		Otherwise we try to get a commit from it using our interface.
+		
+		Strings are allowed but will be checked to be sure we have a commit"""
+		write_value = None
+		if isinstance(ref, SymbolicReference):
+			write_value = "ref: %s" % ref.path
+		elif isinstance(ref, Commit):
+			write_value = ref.hexsha
+		else:
+			try:
+				write_value = ref.commit.hexsha
+			except AttributeError:
+				try:
+					obj = self.repo.rev_parse(ref+"^{}")	# optionally deref tags
+					if obj.type != "commit":
+						raise TypeError("Invalid object type behind sha: %s" % sha)
+					write_value = obj.hexsha
+				except Exception:
+					raise ValueError("Could not extract object from %s" % ref)
+			# END end try string  
+		# END try commit attribute
+		
+		# maintain the orig-head if we are currently checked-out
+		head = HEAD(self.repo)
+		try:
+			if head.ref == self:
+				try:
+					# TODO: implement this atomically, if we fail below, orig_head is at an incorrect spot
+					# Enforce the creation of ORIG_HEAD
+					SymbolicReference.create(self.repo, head.orig_head().name, self.commit, force=True)
+				except ValueError:
+					pass
+				#END exception handling
+			# END if we are checked-out
+		except TypeError:
+			pass
+		# END handle detached heads
+		
+		# if we are writing a ref, use symbolic ref to get the reflog and more
+		# checking
+		# Otherwise we detach it and have to do it manually. Besides, this works
+		# recursively automaitcally, but should be replaced with a python implementation
+		# soon
+		if write_value.startswith('ref:'):
+			self.repo.git.symbolic_ref(self.path, write_value[5:])
+			return
+		# END non-detached handling
+		
+		path = self._abs_path()
+		directory = dirname(path)
+		if not isdir(directory):
+			os.makedirs(directory)
+		
+		fp = open(path, "wb")
+		try:
+			fp.write(write_value)
+		finally:
+			fp.close()
+		# END writing
+	
+
+	# aliased reference
+	reference = property(_get_reference, _set_reference, doc="Returns the Reference we point to")
+	ref = reference
+		
+	def is_valid(self):
+		"""
+		:return:
+			True if the reference is valid, hence it can be read and points to 
+			a valid object or reference."""
+		try:
+			self.commit
+		except (OSError, ValueError):
+			return False
+		else:
+			return True
+		
+	@property
+	def is_detached(self):
+		"""
+		:return:
+			True if we are a detached reference, hence we point to a specific commit
+			instead to another reference"""
+		try:
+			self.reference
+			return False
+		except TypeError:
+			return True
+	
+
+	@classmethod
+	def to_full_path(cls, path):
+		"""
+		:return: string with a full repository-relative path which can be used to initialize 
+			a Reference instance, for instance by using ``Reference.from_path``"""
+		if isinstance(path, SymbolicReference):
+			path = path.path
+		full_ref_path = path
+		if not cls._common_path_default:
+			return full_ref_path
+		if not path.startswith(cls._common_path_default+"/"):
+			full_ref_path = '%s/%s' % (cls._common_path_default, path)
+		return full_ref_path
+	
+	@classmethod
+	def delete(cls, repo, path):
+		"""Delete the reference at the given path
+		
+		:param repo:
+			Repository to delete the reference from
+		
+		:param path:
+			Short or full path pointing to the reference, i.e. refs/myreference
+			or just "myreference", hence 'refs/' is implied.
+			Alternatively the symbolic reference to be deleted"""
+		full_ref_path = cls.to_full_path(path)
+		abs_path = join(repo.git_dir, full_ref_path)
+		if exists(abs_path):
+			os.remove(abs_path)
+		else:
+			# check packed refs
+			pack_file_path = cls._get_packed_refs_path(repo)
+			try:
+				reader = open(pack_file_path)
+			except (OSError,IOError):
+				pass # it didnt exist at all
+			else:
+				new_lines = list()
+				made_change = False
+				dropped_last_line = False
+				for line in reader:
+					# keep line if it is a comment or if the ref to delete is not 
+					# in the line
+					# If we deleted the last line and this one is a tag-reference object, 
+					# we drop it as well
+					if ( line.startswith('#') or full_ref_path not in line ) and \
+						( not dropped_last_line or dropped_last_line and not line.startswith('^') ):
+						new_lines.append(line)
+						dropped_last_line = False
+						continue
+					# END skip comments and lines without our path
+					
+					# drop this line
+					made_change = True
+					dropped_last_line = True
+				# END for each line in packed refs
+				reader.close()
+				
+				# write the new lines
+				if made_change:
+					open(pack_file_path, 'w').writelines(new_lines)
+			# END open exception handling
+		# END handle deletion
+			
+	@classmethod
+	def _create(cls, repo, path, resolve, reference, force):
+		"""internal method used to create a new symbolic reference.
+		If resolve is False,, the reference will be taken as is, creating 
+		a proper symbolic reference. Otherwise it will be resolved to the 
+		corresponding object and a detached symbolic reference will be created
+		instead"""
+		full_ref_path = cls.to_full_path(path)
+		abs_ref_path = join(repo.git_dir, full_ref_path)
+		
+		# figure out target data
+		target = reference
+		if resolve:
+			target = repo.rev_parse(str(reference))
+			
+		if not force and isfile(abs_ref_path):
+			target_data = str(target)
+			if isinstance(target, SymbolicReference):
+				target_data = target.path
+			if not resolve:
+				target_data = "ref: " + target_data
+			if open(abs_ref_path, 'rb').read().strip() != target_data:
+				raise OSError("Reference at %s does already exist" % full_ref_path)
+		# END no force handling
+		
+		ref = cls(repo, full_ref_path)
+		ref.reference = target
+		return ref
+		
+	@classmethod
+	def create(cls, repo, path, reference='HEAD', force=False ):
+		"""Create a new symbolic reference, hence a reference pointing to another reference.
+		
+		:param repo:
+			Repository to create the reference in 
+			
+		:param path:
+			full path at which the new symbolic reference is supposed to be 
+			created at, i.e. "NEW_HEAD" or "symrefs/my_new_symref"
+			
+		:param reference:
+			The reference to which the new symbolic reference should point to
+		
+		:param force:
+			if True, force creation even if a symbolic reference with that name already exists.
+			Raise OSError otherwise
+			
+		:return: Newly created symbolic Reference
+			
+		:raise OSError:
+			If a (Symbolic)Reference with the same name but different contents
+			already exists.
+		
+		:note: This does not alter the current HEAD, index or Working Tree"""
+		return cls._create(repo, path, False, reference, force)
+	
+	def rename(self, new_path, force=False):
+		"""Rename self to a new path
+		
+		:param new_path:
+			Either a simple name or a full path, i.e. new_name or features/new_name.
+			The prefix refs/ is implied for references and will be set as needed.
+			In case this is a symbolic ref, there is no implied prefix
+			
+		:param force:
+			If True, the rename will succeed even if a head with the target name
+			already exists. It will be overwritten in that case
+			
+		:return: self
+		:raise OSError: In case a file at path but a different contents already exists """
+		new_path = self.to_full_path(new_path)
+		if self.path == new_path:
+			return self
+		
+		new_abs_path = join(self.repo.git_dir, new_path)
+		cur_abs_path = join(self.repo.git_dir, self.path)
+		if isfile(new_abs_path):
+			if not force:
+				# if they point to the same file, its not an error
+				if open(new_abs_path,'rb').read().strip() != open(cur_abs_path,'rb').read().strip():
+					raise OSError("File at path %r already exists" % new_abs_path)
+				# else: we could remove ourselves and use the otherone, but 
+				# but clarity we just continue as usual
+			# END not force handling
+			os.remove(new_abs_path)
+		# END handle existing target file
+		
+		dname = dirname(new_abs_path)
+		if not isdir(dname):
+			os.makedirs(dname)
+		# END create directory
+		
+		rename(cur_abs_path, new_abs_path)
+		self.path = new_path
+		
+		return self
+		
+	@classmethod
+	def _iter_items(cls, repo, common_path = None):
+		if common_path is None:
+			common_path = cls._common_path_default
+		rela_paths = set()
+		
+		# walk loose refs
+		# Currently we do not follow links 
+		for root, dirs, files in os.walk(join_path_native(repo.git_dir, common_path)):
+			if 'refs/' not in root: # skip non-refs subfolders
+				refs_id = [ i for i,d in enumerate(dirs) if d == 'refs' ]
+				if refs_id:
+					dirs[0:] = ['refs']
+			# END prune non-refs folders
+			
+			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.git_dir) + '/', ""))
+			# END for each file in root directory
+		# END for each directory to walk
+		
+		# read packed refs
+		for sha, rela_path in cls._iter_packed_refs(repo):
+			if rela_path.startswith(common_path):
+				rela_paths.add(rela_path)
+			# END relative path matches common path
+		# END packed refs reading
+		
+		# return paths in sorted order
+		for path in sorted(rela_paths):
+			try:
+				yield cls.from_path(repo, path)
+			except ValueError:
+				continue
+		# END for each sorted relative refpath
+		
+	@classmethod
+	def iter_items(cls, repo, common_path = None):
+		"""Find all refs in the repository
+
+		:param repo: is the Repo
+
+		:param common_path:
+			Optional keyword argument to the path which is to be shared by all
+			returned Ref objects.
+			Defaults to class specific portion if None assuring that only 
+			refs suitable for the actual class are returned.
+
+		:return:
+			git.SymbolicReference[], each of them is guaranteed to be a symbolic
+			ref which is not detached.
+			
+			List is lexigraphically sorted
+			The returned objects represent actual subclasses, such as Head or TagReference"""
+		return ( r for r in cls._iter_items(repo, common_path) if r.__class__ == SymbolicReference or not r.is_detached )
+		
+	@classmethod
+	def from_path(cls, repo, path):
+		"""
+		:param path: full .git-directory-relative path name to the Reference to instantiate
+		:note: use to_full_path() if you only have a partial path of a known Reference Type
+		:return:
+			Instance of type Reference, Head, or Tag
+			depending on the given path"""
+		if not path:
+			raise ValueError("Cannot create Reference from %r" % path)
+		
+		for ref_type in (HEAD, Head, RemoteReference, TagReference, Reference, SymbolicReference):
+			try:
+				instance = ref_type(repo, path)
+				if instance.__class__ == SymbolicReference and instance.is_detached:
+					raise ValueError("SymbolRef was detached, we drop it")
+				return instance
+			except ValueError:
+				pass
+			# END exception handling
+		# END for each type to try
+		raise ValueError("Could not find reference type suitable to handle path %r" % path)
-- 
cgit v1.2.3


From 8ad01ee239f9111133e52af29b78daed34c52e49 Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Tue, 23 Nov 2010 15:58:32 +0100
Subject: SymbolicReference: log method added, including test

---
 refs/symbolic.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'refs/symbolic.py')

diff --git a/refs/symbolic.py b/refs/symbolic.py
index 3329d51c..9dd7629c 100644
--- a/refs/symbolic.py
+++ b/refs/symbolic.py
@@ -16,6 +16,8 @@ from gitdb.util import (
 							hex_to_bin
 						)
 
+from log import RefLog
+
 __all__ = ["SymbolicReference"]
 
 class SymbolicReference(object):
@@ -270,6 +272,14 @@ class SymbolicReference(object):
 		except TypeError:
 			return True
 	
+	def log(self):
+		"""
+		:return: RefLog for this reference. Its last entry reflects the latest change
+			applied to this reference
+			
+		.. note:: As the log is parsed every time, its recommended to cache it for use
+			instead of calling this method repeatedly"""
+		return RefLog.from_file(RefLog.path(self))
 
 	@classmethod
 	def to_full_path(cls, path):
-- 
cgit v1.2.3


From a21a9f6f13861ddc65671b278e93cf0984adaa30 Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Tue, 23 Nov 2010 21:14:59 +0100
Subject: Actor: Moved it from git.objects.util to git.util, adjusted all
 imports accordingly. Added methods to Actor to retrieve the global committer
 and author information Reflog: implemented and tested append_entry method

---
 refs/symbolic.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'refs/symbolic.py')

diff --git a/refs/symbolic.py b/refs/symbolic.py
index 9dd7629c..b978e484 100644
--- a/refs/symbolic.py
+++ b/refs/symbolic.py
@@ -236,6 +236,7 @@ class SymbolicReference(object):
 		if not isdir(directory):
 			os.makedirs(directory)
 		
+		# TODO: Write using LockedFD
 		fp = open(path, "wb")
 		try:
 			fp.write(write_value)
-- 
cgit v1.2.3


From 61f3db7bd07ac2f3c2ff54615c13bf9219289932 Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Tue, 23 Nov 2010 22:47:34 +0100
Subject: Removed ORIG_HEAD handling which was downright wrong. ORIG_HEAD gets
 only set during merge and rebase, and probably everything that changes the
 ref more drastically. Probably I have to reread that. What needs to be
 adjusted though is the reflog

---
 refs/symbolic.py | 25 ++++++-------------------
 1 file changed, 6 insertions(+), 19 deletions(-)

(limited to 'refs/symbolic.py')

diff --git a/refs/symbolic.py b/refs/symbolic.py
index b978e484..94e8d726 100644
--- a/refs/symbolic.py
+++ b/refs/symbolic.py
@@ -13,7 +13,8 @@ from gitdb.util import (
 							exists,
 							isfile,
 							rename,
-							hex_to_bin
+							hex_to_bin,
+							LockedFD
 						)
 
 from log import RefLog
@@ -181,11 +182,13 @@ class SymbolicReference(object):
 			raise TypeError("%s is a detached symbolic reference as it points to %r" % (self, sha))
 		return self.from_path(self.repo, target_ref_path)
 		
-	def _set_reference(self, ref):
+	def _set_reference(self, ref, msg = None):
 		"""Set ourselves to the given ref. It will stay a symbol if the ref is a Reference.
 		Otherwise we try to get a commit from it using our interface.
 		
-		Strings are allowed but will be checked to be sure we have a commit"""
+		Strings are allowed but will be checked to be sure we have a commit
+		:param msg: If set to a string, the message will be used in the reflog.
+			Otherwise, a reflog entry is not written for the changed reference"""
 		write_value = None
 		if isinstance(ref, SymbolicReference):
 			write_value = "ref: %s" % ref.path
@@ -205,22 +208,6 @@ class SymbolicReference(object):
 			# END end try string  
 		# END try commit attribute
 		
-		# maintain the orig-head if we are currently checked-out
-		head = HEAD(self.repo)
-		try:
-			if head.ref == self:
-				try:
-					# TODO: implement this atomically, if we fail below, orig_head is at an incorrect spot
-					# Enforce the creation of ORIG_HEAD
-					SymbolicReference.create(self.repo, head.orig_head().name, self.commit, force=True)
-				except ValueError:
-					pass
-				#END exception handling
-			# END if we are checked-out
-		except TypeError:
-			pass
-		# END handle detached heads
-		
 		# if we are writing a ref, use symbolic ref to get the reflog and more
 		# checking
 		# Otherwise we detach it and have to do it manually. Besides, this works
-- 
cgit v1.2.3


From 7029773512eee5a0bb765b82cfdd90fd5ab34e15 Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Tue, 23 Nov 2010 23:20:11 +0100
Subject: Implemented revlog.append_entry as classmethod, to assure we will
 always actually write_append the new entry, instead of rewriting the whole
 file. Added file-locking and directory handling, so the implementation should
 be similar (enough) to the git reference implementation. Next up is to
 implement a way to update the reflog when changing references, which is going
 to be a little more complicated

---
 refs/symbolic.py | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

(limited to 'refs/symbolic.py')

diff --git a/refs/symbolic.py b/refs/symbolic.py
index 94e8d726..0d8fdfd1 100644
--- a/refs/symbolic.py
+++ b/refs/symbolic.py
@@ -266,8 +266,19 @@ class SymbolicReference(object):
 			applied to this reference
 			
 		.. note:: As the log is parsed every time, its recommended to cache it for use
-			instead of calling this method repeatedly"""
+			instead of calling this method repeatedly. It should be considered read-only."""
 		return RefLog.from_file(RefLog.path(self))
+		
+	def log_append(self, oldbinsha, message, newbinsha=None):
+		"""Append a logentry to the logfile of this ref
+		:param oldbinsha: binary sha this ref used to point to
+		:param message: A message describing the change
+		:param newbinsha: The sha the ref points to now. If None, our current commit sha
+			will be used
+		:return: added RefLogEntry instance"""
+		return RefLog.append_entry(RefLog.path(self), oldbinsha, 
+									(newbinsha is None and self.commit.binsha) or newbinsha, 
+									message) 
 
 	@classmethod
 	def to_full_path(cls, path):
-- 
cgit v1.2.3


From a17c43d0662bab137903075f2cff34bcabc7e1d1 Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Wed, 24 Nov 2010 12:30:51 +0100
Subject: Made previously protected methods public to introduce a method with
 reflog support which cannot be exposed using the respective property.
 Ref-Creation is now fully implemented in python. For details, see
 doc/source/changes.rst

---
 refs/symbolic.py | 114 +++++++++++++++++++++++++++++++++----------------------
 1 file changed, 69 insertions(+), 45 deletions(-)

(limited to 'refs/symbolic.py')

diff --git a/refs/symbolic.py b/refs/symbolic.py
index 0d8fdfd1..90fef8d5 100644
--- a/refs/symbolic.py
+++ b/refs/symbolic.py
@@ -3,7 +3,8 @@ from git.objects import Commit
 from git.util import (
 					join_path, 
 					join_path_native, 
-					to_native_path_linux
+					to_native_path_linux,
+					assure_directory_exists
 					)
 
 from gitdb.util import (
@@ -28,6 +29,7 @@ class SymbolicReference(object):
 	
 	A typical example for a symbolic reference is HEAD."""
 	__slots__ = ("repo", "path")
+	_resolve_ref_on_create = False
 	_common_path_default = ""
 	_id_attribute_ = "name"
 	
@@ -58,7 +60,8 @@ class SymbolicReference(object):
 			is the path itself."""
 		return self.path
 	
-	def _abs_path(self):
+	@property
+	def abspath(self):
 		return join_path_native(self.repo.git_dir, self.path)
 		
 	@classmethod
@@ -116,7 +119,7 @@ class SymbolicReference(object):
 		point to, or None"""
 		tokens = None
 		try:
-			fp = open(self._abs_path(), 'r')
+			fp = open(self.abspath, 'r')
 			value = fp.read().rstrip()
 			fp.close()
 			tokens = value.split(" ")
@@ -158,37 +161,48 @@ class SymbolicReference(object):
 		
 		return self.from_path(self.repo, target_ref_path).commit
 		
-	def _set_commit(self, commit):
+	def set_commit(self, commit, msg = None):
 		"""Set our commit, possibly dereference our symbolic reference first.
-		If the reference does not exist, it will be created"""
+		If the reference does not exist, it will be created
+		
+		:param msg: If not None, the message will be used in the reflog entry to be 
+			written. Otherwise the reflog is not altered"""
 		is_detached = True
 		try:
 			is_detached = self.is_detached
 		except ValueError:
 			pass
 		# END handle non-existing ones
+		
 		if is_detached:
-			return self._set_reference(commit)
+			return self.set_reference(commit, msg)
 			
 		# set the commit on our reference
-		self._get_reference().commit = commit
+		self._get_reference().set_commit(commit, msg)
 	
-	commit = property(_get_commit, _set_commit, doc="Query or set commits directly")
+	commit = property(_get_commit, set_commit, doc="Query or set commits directly")
 		
 	def _get_reference(self):
-		""":return: Reference Object we point to"""
+		""":return: Reference Object we point to
+		:raise TypeError: If this symbolic reference is detached, hence it doesn't point
+			to a reference, but to a commit"""
 		sha, target_ref_path = self._get_ref_info()
 		if target_ref_path is None:
 			raise TypeError("%s is a detached symbolic reference as it points to %r" % (self, sha))
 		return self.from_path(self.repo, target_ref_path)
 		
-	def _set_reference(self, ref, msg = None):
+	def set_reference(self, ref, msg = None):
 		"""Set ourselves to the given ref. It will stay a symbol if the ref is a Reference.
-		Otherwise we try to get a commit from it using our interface.
+		Otherwise a commmit, given as Commit object or refspec, is assumed and if valid, 
+		will be set which effectively detaches the refererence if it was a purely 
+		symbolic one.
 		
-		Strings are allowed but will be checked to be sure we have a commit
+		:param ref: SymbolicReference instance, Commit instance or refspec string
 		:param msg: If set to a string, the message will be used in the reflog.
-			Otherwise, a reflog entry is not written for the changed reference"""
+			Otherwise, a reflog entry is not written for the changed reference.
+			The previous commit of the entry will be the commit we point to now.
+			
+			See also: log_append()"""
 		write_value = None
 		if isinstance(ref, SymbolicReference):
 			write_value = "ref: %s" % ref.path
@@ -207,33 +221,31 @@ class SymbolicReference(object):
 					raise ValueError("Could not extract object from %s" % ref)
 			# END end try string  
 		# END try commit attribute
+		oldbinsha = None
+		if msg is not None:
+			try:
+				oldhexsha = self.commit.binsha
+			except ValueError:
+				oldbinsha = Commit.NULL_BIN_SHA
+			#END handle non-existing
+		#END retrieve old hexsha
+		
+		fpath = self.abspath
+		assure_directory_exists(fpath, is_file=True)
+		
+		lfd = LockedFD(fpath)
+		fd = lfd.open(write=True, stream=True)
+		fd.write(write_value)
+		lfd.commit()
+		
+		# Adjust the reflog
+		if msg is not None:
+			self.log_append(oldbinsha, msg)
+		#END handle reflog
 		
-		# if we are writing a ref, use symbolic ref to get the reflog and more
-		# checking
-		# Otherwise we detach it and have to do it manually. Besides, this works
-		# recursively automaitcally, but should be replaced with a python implementation
-		# soon
-		if write_value.startswith('ref:'):
-			self.repo.git.symbolic_ref(self.path, write_value[5:])
-			return
-		# END non-detached handling
-		
-		path = self._abs_path()
-		directory = dirname(path)
-		if not isdir(directory):
-			os.makedirs(directory)
-		
-		# TODO: Write using LockedFD
-		fp = open(path, "wb")
-		try:
-			fp.write(write_value)
-		finally:
-			fp.close()
-		# END writing
-	
 
 	# aliased reference
-	reference = property(_get_reference, _set_reference, doc="Returns the Reference we point to")
+	reference = property(_get_reference, set_reference, doc="Returns the Reference we point to")
 	ref = reference
 		
 	def is_valid(self):
@@ -255,7 +267,7 @@ class SymbolicReference(object):
 			True if we are a detached reference, hence we point to a specific commit
 			instead to another reference"""
 		try:
-			self.reference
+			self.ref
 			return False
 		except TypeError:
 			return True
@@ -343,11 +355,18 @@ class SymbolicReference(object):
 					open(pack_file_path, 'w').writelines(new_lines)
 			# END open exception handling
 		# END handle deletion
+		
+		# delete the reflog
+		reflog_path = RefLog.path(cls(repo, full_ref_path))
+		if os.path.isfile(reflog_path):
+			os.remove(reflog_path)
+		#END remove reflog
+		
 			
 	@classmethod
-	def _create(cls, repo, path, resolve, reference, force):
+	def _create(cls, repo, path, resolve, reference, force, msg=None):
 		"""internal method used to create a new symbolic reference.
-		If resolve is False,, the reference will be taken as is, creating 
+		If resolve is False, the reference will be taken as is, creating 
 		a proper symbolic reference. Otherwise it will be resolved to the 
 		corresponding object and a detached symbolic reference will be created
 		instead"""
@@ -365,16 +384,17 @@ class SymbolicReference(object):
 				target_data = target.path
 			if not resolve:
 				target_data = "ref: " + target_data
-			if open(abs_ref_path, 'rb').read().strip() != target_data:
-				raise OSError("Reference at %s does already exist" % full_ref_path)
+			existing_data = open(abs_ref_path, 'rb').read().strip() 
+			if existing_data != target_data:
+				raise OSError("Reference at %r does already exist, pointing to %r, requested was %r" % (full_ref_path, existing_data, target_data))
 		# END no force handling
 		
 		ref = cls(repo, full_ref_path)
-		ref.reference = target
+		ref.set_reference(target, msg)
 		return ref
 		
 	@classmethod
-	def create(cls, repo, path, reference='HEAD', force=False ):
+	def create(cls, repo, path, reference='HEAD', force=False, msg=None):
 		"""Create a new symbolic reference, hence a reference pointing to another reference.
 		
 		:param repo:
@@ -391,6 +411,10 @@ class SymbolicReference(object):
 			if True, force creation even if a symbolic reference with that name already exists.
 			Raise OSError otherwise
 			
+		:param msg:
+			If not None, the message to append to the reflog. Otherwise no reflog
+			entry is written.
+			
 		:return: Newly created symbolic Reference
 			
 		:raise OSError:
@@ -398,7 +422,7 @@ class SymbolicReference(object):
 			already exists.
 		
 		:note: This does not alter the current HEAD, index or Working Tree"""
-		return cls._create(repo, path, False, reference, force)
+		return cls._create(repo, path, cls._resolve_ref_on_create, reference, force, msg)
 	
 	def rename(self, new_path, force=False):
 		"""Rename self to a new path
-- 
cgit v1.2.3


From ec0657cf5de9aeb5629cc4f4f38b36f48490493e Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Wed, 24 Nov 2010 15:56:49 +0100
Subject: Unified object and commit handling which should make the reflog
 handling much easier. There is some bug in it though, it still needs fixing

---
 refs/symbolic.py | 122 +++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 78 insertions(+), 44 deletions(-)

(limited to 'refs/symbolic.py')

diff --git a/refs/symbolic.py b/refs/symbolic.py
index 90fef8d5..2ecdee4a 100644
--- a/refs/symbolic.py
+++ b/refs/symbolic.py
@@ -1,5 +1,5 @@
 import os
-from git.objects import Commit
+from git.objects import Object, Commit
 from git.util import (
 					join_path, 
 					join_path_native, 
@@ -30,6 +30,7 @@ class SymbolicReference(object):
 	A typical example for a symbolic reference is HEAD."""
 	__slots__ = ("repo", "path")
 	_resolve_ref_on_create = False
+	_points_to_commits_only = True
 	_common_path_default = ""
 	_id_attribute_ = "name"
 	
@@ -107,19 +108,19 @@ class SymbolicReference(object):
 			intermediate references as required
 		:param repo: the repository containing the reference at ref_path"""
 		while True:
-			ref = cls(repo, ref_path)
-			hexsha, ref_path = ref._get_ref_info()
+			hexsha, ref_path = cls._get_ref_info(repo, ref_path)
 			if hexsha is not None:
 				return hexsha
 		# END recursive dereferencing
 		
-	def _get_ref_info(self):
+	@classmethod
+	def _get_ref_info(cls, repo, path):
 		"""Return: (sha, target_ref_path) if available, the sha the file at 
 		rela_path points to, or None. target_ref_path is the reference we 
 		point to, or None"""
 		tokens = None
 		try:
-			fp = open(self.abspath, 'r')
+			fp = open(join(repo.git_dir, path), 'r')
 			value = fp.read().rstrip()
 			fp.close()
 			tokens = value.split(" ")
@@ -127,46 +128,69 @@ class SymbolicReference(object):
 			# Probably we are just packed, find our entry in the packed refs file
 			# NOTE: We are not a symbolic ref if we are in a packed file, as these
 			# are excluded explictly
-			for sha, path in self._iter_packed_refs(self.repo):
-				if path != self.path: continue
+			for sha, path in cls._iter_packed_refs(repo):
+				if path != path: continue
 				tokens = (sha, path)
 				break
 			# END for each packed ref
 		# END handle packed refs
 		
 		if tokens is None:
-			raise ValueError("Reference at %r does not exist" % self.path)
+			raise ValueError("Reference at %r does not exist" % path)
 		
 		# is it a reference ?
 		if tokens[0] == 'ref:':
 			return (None, tokens[1])
 			
 		# its a commit
-		if self.repo.re_hexsha_only.match(tokens[0]):
+		if repo.re_hexsha_only.match(tokens[0]):
 			return (tokens[0], None)
 			
-		raise ValueError("Failed to parse reference information from %r" % self.path)
-		
+		raise ValueError("Failed to parse reference information from %r" % path)
+	
+	def _get_object(self):
+		"""
+		:return:
+			The object our ref currently refers to. Refs can be cached, they will 
+			always point to the actual object as it gets re-created on each query"""
+		# have to be dynamic here as we may be a tag which can point to anything
+		# Our path will be resolved to the hexsha which will be used accordingly
+		return Object.new_from_sha(self.repo, hex_to_bin(self.dereference_recursive(self.repo, self.path)))
+	
 	def _get_commit(self):
 		"""
 		:return:
 			Commit object we point to, works for detached and non-detached 
-			SymbolicReferences"""
-		# we partially reimplement it to prevent unnecessary file access
-		hexsha, target_ref_path = self._get_ref_info()
-		
-		# it is a detached reference
-		if hexsha:
-			return Commit(self.repo, hex_to_bin(hexsha))
-		
-		return self.from_path(self.repo, target_ref_path).commit
+			SymbolicReferences. The symbolic reference will be dereferenced recursively."""
+		obj = self._get_object()
+		if obj.type != Commit.type:
+			raise TypeError("Symbolic Reference pointed to object %r, commit was required" % obj)
+		#END handle type
+		return obj
 		
 	def set_commit(self, commit, msg = None):
-		"""Set our commit, possibly dereference our symbolic reference first.
+		"""As set_object, but restricts the type of object to be a Commit
+		:note: To save cycles, we do not yet check whether the given Object 
+			is actually referring to a commit - for now it may be any of our 
+			Object or Reference types, as well as a refspec"""
+		# may have to check the type ... this is costly as we would have to use 
+		# revparse
+		self.set_object(commit, msg)
+		
+	
+	def set_object(self, object, msg = None):
+		"""Set the object we point to, possibly dereference our symbolic reference first.
 		If the reference does not exist, it will be created
 		
+		:param object: a refspec, a SymbolicReference or an Object instance. SymbolicReferences
+			will be dereferenced beforehand to obtain the object they point to
 		:param msg: If not None, the message will be used in the reflog entry to be 
-			written. Otherwise the reflog is not altered"""
+			written. Otherwise the reflog is not altered
+		:note: plain SymbolicReferences may not actually point to objects by convention"""
+		if isinstance(object, SymbolicReference):
+			object = object.object
+		#END resolve references
+		
 		is_detached = True
 		try:
 			is_detached = self.is_detached
@@ -175,56 +199,66 @@ class SymbolicReference(object):
 		# END handle non-existing ones
 		
 		if is_detached:
-			return self.set_reference(commit, msg)
+			return self.set_reference(object, msg)
 			
 		# set the commit on our reference
-		self._get_reference().set_commit(commit, msg)
+		self._get_reference().set_object(object, msg)
 	
 	commit = property(_get_commit, set_commit, doc="Query or set commits directly")
+	object = property(_get_object, set_object, doc="Return the object our ref currently refers to")
 		
 	def _get_reference(self):
 		""":return: Reference Object we point to
 		:raise TypeError: If this symbolic reference is detached, hence it doesn't point
 			to a reference, but to a commit"""
-		sha, target_ref_path = self._get_ref_info()
+		sha, target_ref_path = self._get_ref_info(self.repo, self.path)
 		if target_ref_path is None:
 			raise TypeError("%s is a detached symbolic reference as it points to %r" % (self, sha))
 		return self.from_path(self.repo, target_ref_path)
 		
 	def set_reference(self, ref, msg = None):
 		"""Set ourselves to the given ref. It will stay a symbol if the ref is a Reference.
-		Otherwise a commmit, given as Commit object or refspec, is assumed and if valid, 
+		Otherwise an Object, given as Object instance or refspec, is assumed and if valid, 
 		will be set which effectively detaches the refererence if it was a purely 
 		symbolic one.
 		
-		:param ref: SymbolicReference instance, Commit instance or refspec string
+		:param ref: SymbolicReference instance, Object instance or refspec string
+			Only if the ref is a SymbolicRef instance, we will point to it. Everthiny
+			else is dereferenced to obtain the actual object.
 		:param msg: If set to a string, the message will be used in the reflog.
 			Otherwise, a reflog entry is not written for the changed reference.
 			The previous commit of the entry will be the commit we point to now.
 			
-			See also: log_append()"""
+			See also: log_append()
+		:note: This symbolic reference will not be dereferenced. For that, see 
+			``set_object(...)``"""
 		write_value = None
+		obj = None
 		if isinstance(ref, SymbolicReference):
 			write_value = "ref: %s" % ref.path
-		elif isinstance(ref, Commit):
+		elif isinstance(ref, Object):
+			obj = ref
 			write_value = ref.hexsha
-		else:
+		elif isinstance(ref, basestring):
 			try:
-				write_value = ref.commit.hexsha
-			except AttributeError:
-				try:
-					obj = self.repo.rev_parse(ref+"^{}")	# optionally deref tags
-					if obj.type != "commit":
-						raise TypeError("Invalid object type behind sha: %s" % sha)
-					write_value = obj.hexsha
-				except Exception:
-					raise ValueError("Could not extract object from %s" % ref)
-			# END end try string  
+				obj = self.repo.rev_parse(ref+"^{}")	# optionally deref tags
+				write_value = obj.hexsha
+			except Exception:
+				raise ValueError("Could not extract object from %s" % ref)
+			# END end try string
+		else:
+			raise ValueError("Unrecognized Value: %r" % ref)
 		# END try commit attribute
+		
+		# typecheck
+		if obj is not None and self._points_to_commits_only and obj.type != Commit.type:
+			raise TypeError("Require commit, got %r" % obj)
+		#END verify type
+		
 		oldbinsha = None
 		if msg is not None:
 			try:
-				oldhexsha = self.commit.binsha
+				oldbinsha = self.commit.binsha
 			except ValueError:
 				oldbinsha = Commit.NULL_BIN_SHA
 			#END handle non-existing
@@ -247,14 +281,14 @@ class SymbolicReference(object):
 	# aliased reference
 	reference = property(_get_reference, set_reference, doc="Returns the Reference we point to")
 	ref = reference
-		
+	
 	def is_valid(self):
 		"""
 		:return:
 			True if the reference is valid, hence it can be read and points to 
 			a valid object or reference."""
 		try:
-			self.commit
+			self.object
 		except (OSError, ValueError):
 			return False
 		else:
@@ -288,7 +322,7 @@ class SymbolicReference(object):
 		:param newbinsha: The sha the ref points to now. If None, our current commit sha
 			will be used
 		:return: added RefLogEntry instance"""
-		return RefLog.append_entry(RefLog.path(self), oldbinsha, 
+		return RefLog.append_entry(self.repo.config_reader(), RefLog.path(self), oldbinsha, 
 									(newbinsha is None and self.commit.binsha) or newbinsha, 
 									message) 
 
-- 
cgit v1.2.3


From 264ba6f54f928da31a037966198a0849325b3732 Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Wed, 24 Nov 2010 17:12:36 +0100
Subject: Fixed remaining issues, all tests work as expected

---
 refs/symbolic.py | 44 ++++++++++++++++++++++++++++++++------------
 1 file changed, 32 insertions(+), 12 deletions(-)

(limited to 'refs/symbolic.py')

diff --git a/refs/symbolic.py b/refs/symbolic.py
index 2ecdee4a..83dbafd2 100644
--- a/refs/symbolic.py
+++ b/refs/symbolic.py
@@ -7,6 +7,7 @@ from git.util import (
 					assure_directory_exists
 					)
 
+from gitdb.exc import BadObject
 from gitdb.util import (
 							join, 
 							dirname,
@@ -114,13 +115,13 @@ class SymbolicReference(object):
 		# END recursive dereferencing
 		
 	@classmethod
-	def _get_ref_info(cls, repo, path):
+	def _get_ref_info(cls, repo, ref_path):
 		"""Return: (sha, target_ref_path) if available, the sha the file at 
 		rela_path points to, or None. target_ref_path is the reference we 
 		point to, or None"""
 		tokens = None
 		try:
-			fp = open(join(repo.git_dir, path), 'r')
+			fp = open(join(repo.git_dir, ref_path), 'r')
 			value = fp.read().rstrip()
 			fp.close()
 			tokens = value.split(" ")
@@ -129,14 +130,13 @@ class SymbolicReference(object):
 			# NOTE: We are not a symbolic ref if we are in a packed file, as these
 			# are excluded explictly
 			for sha, path in cls._iter_packed_refs(repo):
-				if path != path: continue
+				if path != ref_path: continue
 				tokens = (sha, path)
 				break
 			# END for each packed ref
 		# END handle packed refs
-		
 		if tokens is None:
-			raise ValueError("Reference at %r does not exist" % path)
+			raise ValueError("Reference at %r does not exist" % ref_path)
 		
 		# is it a reference ?
 		if tokens[0] == 'ref:':
@@ -146,7 +146,7 @@ class SymbolicReference(object):
 		if repo.re_hexsha_only.match(tokens[0]):
 			return (tokens[0], None)
 			
-		raise ValueError("Failed to parse reference information from %r" % path)
+		raise ValueError("Failed to parse reference information from %r" % ref_path)
 	
 	def _get_object(self):
 		"""
@@ -163,6 +163,10 @@ class SymbolicReference(object):
 			Commit object we point to, works for detached and non-detached 
 			SymbolicReferences. The symbolic reference will be dereferenced recursively."""
 		obj = self._get_object()
+		if obj.type == 'tag':
+			obj = obj.object
+		#END dereference tag
+		
 		if obj.type != Commit.type:
 			raise TypeError("Symbolic Reference pointed to object %r, commit was required" % obj)
 		#END handle type
@@ -170,11 +174,27 @@ class SymbolicReference(object):
 		
 	def set_commit(self, commit, msg = None):
 		"""As set_object, but restricts the type of object to be a Commit
-		:note: To save cycles, we do not yet check whether the given Object 
-			is actually referring to a commit - for now it may be any of our 
-			Object or Reference types, as well as a refspec"""
-		# may have to check the type ... this is costly as we would have to use 
-		# revparse
+		:raise ValueError: If commit is not a Commit object or doesn't point to 
+			a commit"""
+		# check the type - assume the best if it is a base-string
+		invalid_type = False
+		if isinstance(commit, Object):
+			invalid_type = commit.type != Commit.type
+		elif isinstance(commit, SymbolicReference):
+			invalid_type = commit.object.type != Commit.type
+		else:
+			try:
+				invalid_type = self.repo.rev_parse(commit).type != Commit.type
+			except BadObject:
+				raise ValueError("Invalid object: %s" % commit)
+			#END handle exception
+		# END verify type
+		
+		if invalid_type:
+			raise ValueError("Need commit, got %r" % commit)
+		#END handle raise
+		
+		# we leave strings to the rev-parse method below
 		self.set_object(commit, msg)
 		
 	
@@ -243,7 +263,7 @@ class SymbolicReference(object):
 			try:
 				obj = self.repo.rev_parse(ref+"^{}")	# optionally deref tags
 				write_value = obj.hexsha
-			except Exception:
+			except BadObject:
 				raise ValueError("Could not extract object from %s" % ref)
 			# END end try string
 		else:
-- 
cgit v1.2.3


From c946bf260d3f7ca54bffb796a82218dce0eb703f Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Wed, 24 Nov 2010 17:51:22 +0100
Subject: Added tests for creation and adjustments of reference, verifying the
 log gets written

---
 refs/symbolic.py | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

(limited to 'refs/symbolic.py')

diff --git a/refs/symbolic.py b/refs/symbolic.py
index 83dbafd2..cdd6158a 100644
--- a/refs/symbolic.py
+++ b/refs/symbolic.py
@@ -175,7 +175,8 @@ class SymbolicReference(object):
 	def set_commit(self, commit, msg = None):
 		"""As set_object, but restricts the type of object to be a Commit
 		:raise ValueError: If commit is not a Commit object or doesn't point to 
-			a commit"""
+			a commit
+		:return: self"""
 		# check the type - assume the best if it is a base-string
 		invalid_type = False
 		if isinstance(commit, Object):
@@ -197,6 +198,8 @@ class SymbolicReference(object):
 		# we leave strings to the rev-parse method below
 		self.set_object(commit, msg)
 		
+		return self
+		
 	
 	def set_object(self, object, msg = None):
 		"""Set the object we point to, possibly dereference our symbolic reference first.
@@ -206,7 +209,8 @@ class SymbolicReference(object):
 			will be dereferenced beforehand to obtain the object they point to
 		:param msg: If not None, the message will be used in the reflog entry to be 
 			written. Otherwise the reflog is not altered
-		:note: plain SymbolicReferences may not actually point to objects by convention"""
+		:note: plain SymbolicReferences may not actually point to objects by convention
+		:return: self"""
 		if isinstance(object, SymbolicReference):
 			object = object.object
 		#END resolve references
@@ -222,7 +226,7 @@ class SymbolicReference(object):
 			return self.set_reference(object, msg)
 			
 		# set the commit on our reference
-		self._get_reference().set_object(object, msg)
+		return self._get_reference().set_object(object, msg)
 	
 	commit = property(_get_commit, set_commit, doc="Query or set commits directly")
 	object = property(_get_object, set_object, doc="Return the object our ref currently refers to")
@@ -250,6 +254,8 @@ class SymbolicReference(object):
 			The previous commit of the entry will be the commit we point to now.
 			
 			See also: log_append()
+		
+		:return: self
 		:note: This symbolic reference will not be dereferenced. For that, see 
 			``set_object(...)``"""
 		write_value = None
@@ -297,6 +303,8 @@ class SymbolicReference(object):
 			self.log_append(oldbinsha, msg)
 		#END handle reflog
 		
+		return self
+		
 
 	# aliased reference
 	reference = property(_get_reference, set_reference, doc="Returns the Reference we point to")
-- 
cgit v1.2.3


From 86523260c495d9a29aa5ab29d50d30a5d1981a0c Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Wed, 24 Nov 2010 17:55:43 +0100
Subject: Renamed msg named parameter to logmsg, as it describes the purpose of
 the message much better Added test for deletion of reflog file when the
 corresponding ref is deleted

---
 refs/symbolic.py | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

(limited to 'refs/symbolic.py')

diff --git a/refs/symbolic.py b/refs/symbolic.py
index cdd6158a..f333bd46 100644
--- a/refs/symbolic.py
+++ b/refs/symbolic.py
@@ -172,7 +172,7 @@ class SymbolicReference(object):
 		#END handle type
 		return obj
 		
-	def set_commit(self, commit, msg = None):
+	def set_commit(self, commit, logmsg = None):
 		"""As set_object, but restricts the type of object to be a Commit
 		:raise ValueError: If commit is not a Commit object or doesn't point to 
 			a commit
@@ -196,18 +196,18 @@ class SymbolicReference(object):
 		#END handle raise
 		
 		# we leave strings to the rev-parse method below
-		self.set_object(commit, msg)
+		self.set_object(commit, logmsg)
 		
 		return self
 		
 	
-	def set_object(self, object, msg = None):
+	def set_object(self, object, logmsg = None):
 		"""Set the object we point to, possibly dereference our symbolic reference first.
 		If the reference does not exist, it will be created
 		
 		:param object: a refspec, a SymbolicReference or an Object instance. SymbolicReferences
 			will be dereferenced beforehand to obtain the object they point to
-		:param msg: If not None, the message will be used in the reflog entry to be 
+		:param logmsg: If not None, the message will be used in the reflog entry to be 
 			written. Otherwise the reflog is not altered
 		:note: plain SymbolicReferences may not actually point to objects by convention
 		:return: self"""
@@ -223,10 +223,10 @@ class SymbolicReference(object):
 		# END handle non-existing ones
 		
 		if is_detached:
-			return self.set_reference(object, msg)
+			return self.set_reference(object, logmsg)
 			
 		# set the commit on our reference
-		return self._get_reference().set_object(object, msg)
+		return self._get_reference().set_object(object, logmsg)
 	
 	commit = property(_get_commit, set_commit, doc="Query or set commits directly")
 	object = property(_get_object, set_object, doc="Return the object our ref currently refers to")
@@ -240,7 +240,7 @@ class SymbolicReference(object):
 			raise TypeError("%s is a detached symbolic reference as it points to %r" % (self, sha))
 		return self.from_path(self.repo, target_ref_path)
 		
-	def set_reference(self, ref, msg = None):
+	def set_reference(self, ref, logmsg = None):
 		"""Set ourselves to the given ref. It will stay a symbol if the ref is a Reference.
 		Otherwise an Object, given as Object instance or refspec, is assumed and if valid, 
 		will be set which effectively detaches the refererence if it was a purely 
@@ -249,7 +249,7 @@ class SymbolicReference(object):
 		:param ref: SymbolicReference instance, Object instance or refspec string
 			Only if the ref is a SymbolicRef instance, we will point to it. Everthiny
 			else is dereferenced to obtain the actual object.
-		:param msg: If set to a string, the message will be used in the reflog.
+		:param logmsg: If set to a string, the message will be used in the reflog.
 			Otherwise, a reflog entry is not written for the changed reference.
 			The previous commit of the entry will be the commit we point to now.
 			
@@ -282,7 +282,7 @@ class SymbolicReference(object):
 		#END verify type
 		
 		oldbinsha = None
-		if msg is not None:
+		if logmsg is not None:
 			try:
 				oldbinsha = self.commit.binsha
 			except ValueError:
@@ -299,8 +299,8 @@ class SymbolicReference(object):
 		lfd.commit()
 		
 		# Adjust the reflog
-		if msg is not None:
-			self.log_append(oldbinsha, msg)
+		if logmsg is not None:
+			self.log_append(oldbinsha, logmsg)
 		#END handle reflog
 		
 		return self
@@ -426,7 +426,7 @@ class SymbolicReference(object):
 		
 			
 	@classmethod
-	def _create(cls, repo, path, resolve, reference, force, msg=None):
+	def _create(cls, repo, path, resolve, reference, force, logmsg=None):
 		"""internal method used to create a new symbolic reference.
 		If resolve is False, the reference will be taken as is, creating 
 		a proper symbolic reference. Otherwise it will be resolved to the 
@@ -452,11 +452,11 @@ class SymbolicReference(object):
 		# END no force handling
 		
 		ref = cls(repo, full_ref_path)
-		ref.set_reference(target, msg)
+		ref.set_reference(target, logmsg)
 		return ref
 		
 	@classmethod
-	def create(cls, repo, path, reference='HEAD', force=False, msg=None):
+	def create(cls, repo, path, reference='HEAD', force=False, logmsg=None):
 		"""Create a new symbolic reference, hence a reference pointing to another reference.
 		
 		:param repo:
@@ -473,7 +473,7 @@ class SymbolicReference(object):
 			if True, force creation even if a symbolic reference with that name already exists.
 			Raise OSError otherwise
 			
-		:param msg:
+		:param logmsg:
 			If not None, the message to append to the reflog. Otherwise no reflog
 			entry is written.
 			
@@ -484,7 +484,7 @@ class SymbolicReference(object):
 			already exists.
 		
 		:note: This does not alter the current HEAD, index or Working Tree"""
-		return cls._create(repo, path, cls._resolve_ref_on_create, reference, force, msg)
+		return cls._create(repo, path, cls._resolve_ref_on_create, reference, force, logmsg)
 	
 	def rename(self, new_path, force=False):
 		"""Rename self to a new path
-- 
cgit v1.2.3


From 98a313305f0d554a179b93695d333199feb5266c Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Wed, 24 Nov 2010 19:36:34 +0100
Subject: RefLog: added entry_at method, which is a faster way of reading
 single entries, including test

---
 refs/symbolic.py | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'refs/symbolic.py')

diff --git a/refs/symbolic.py b/refs/symbolic.py
index f333bd46..6ba8083f 100644
--- a/refs/symbolic.py
+++ b/refs/symbolic.py
@@ -354,6 +354,15 @@ class SymbolicReference(object):
 									(newbinsha is None and self.commit.binsha) or newbinsha, 
 									message) 
 
+	def log_entry(self, index):
+		""":return: RefLogEntry at the given index
+		:param index: python list compatible positive or negative index
+		
+		.. note:: This method must read part of the reflog during execution, hence 
+			it should be used sparringly, or only if you need just one index.
+			In that case, it will be faster than the ``log()`` method"""
+		return RefLog.entry_at(RefLog.path(self), index)
+
 	@classmethod
 	def to_full_path(cls, path):
 		"""
-- 
cgit v1.2.3


From 3203cd7629345d32806f470a308975076b2b4686 Mon Sep 17 00:00:00 2001
From: Sebastian Thiel <byronimo@gmail.com>
Date: Wed, 24 Nov 2010 19:48:44 +0100
Subject: Fixed doc strings, improved error checking on RefLog.write method

---
 refs/symbolic.py | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'refs/symbolic.py')

diff --git a/refs/symbolic.py b/refs/symbolic.py
index 6ba8083f..9937cf0c 100644
--- a/refs/symbolic.py
+++ b/refs/symbolic.py
@@ -174,6 +174,7 @@ class SymbolicReference(object):
 		
 	def set_commit(self, commit, logmsg = None):
 		"""As set_object, but restricts the type of object to be a Commit
+		
 		:raise ValueError: If commit is not a Commit object or doesn't point to 
 			a commit
 		:return: self"""
@@ -345,6 +346,7 @@ class SymbolicReference(object):
 		
 	def log_append(self, oldbinsha, message, newbinsha=None):
 		"""Append a logentry to the logfile of this ref
+		
 		:param oldbinsha: binary sha this ref used to point to
 		:param message: A message describing the change
 		:param newbinsha: The sha the ref points to now. If None, our current commit sha
-- 
cgit v1.2.3