"""
return len(tree_status(verbose = verbose)) != 0
+def get_heads():
+ heads = []
+ for line in _output_lines(['git-show-ref', '--heads']):
+ m = re.match('^[0-9a-f]{40} refs/heads/(.+)$', line)
+ heads.append(m.group(1))
+ return heads
+
# HEAD value cached
__head = None
# head cache flushing is needed since we might have a different value
# in the new head
__clear_head_cache()
- if __run('git-symbolic-ref HEAD',
- [os.path.join('refs', 'heads', ref)]) != 0:
+ if __run('git-symbolic-ref HEAD', ['refs/heads/%s' % ref]) != 0:
raise GitException, 'Could not set head to "%s"' % ref
+def set_ref(ref, val):
+ """Point ref at a new commit object."""
+ if __run('git-update-ref', [ref, val]) != 0:
+ raise GitException, 'Could not update %s to "%s".' % (ref, val)
+
def set_branch(branch, val):
- """Point branch at a new commit object."""
- if __run('git-update-ref', [branch, val]) != 0:
- raise GitException, 'Could not update %s to "%s".' % (branch, val)
+ set_ref('refs/heads/%s' % branch, val)
def __set_head(val):
"""Sets the HEAD value
global __head
if not __head or __head != val:
- set_branch('HEAD', val)
+ set_ref('HEAD', val)
__head = val
# only allow SHA1 hashes
except GitException:
raise GitException, 'Unknown revision: %s' % git_id
+def ref_exists(ref):
+ try:
+ rev_parse(ref)
+ return True
+ except GitException:
+ return False
+
def branch_exists(branch):
- """Existence check for the named branch
- """
- branch = os.path.join('refs', 'heads', branch)
- for line in _output_lines('git-rev-parse --symbolic --all 2>&1'):
- if line.strip() == branch:
- return True
- if re.compile('[ |/]'+branch+' ').search(line):
- raise GitException, 'Bogus branch: %s' % line
- return False
+ return ref_exists('refs/heads/%s' % branch)
def create_branch(new_branch, tree_id = None):
"""Create a new branch in the git repository
if not branch_exists(new_branch):
raise GitException, 'Branch "%s" does not exist' % new_branch
- tree_id = rev_parse(os.path.join('refs', 'heads', new_branch)
- + '^{commit}')
+ tree_id = rev_parse('refs/heads/%s^{commit}' % new_branch)
if tree_id != get_head():
refresh_index()
if __run('git-read-tree -u -m', [get_head(), tree_id]) != 0:
if os.path.isfile(os.path.join(basedir.get(), 'MERGE_HEAD')):
os.remove(os.path.join(basedir.get(), 'MERGE_HEAD'))
+def delete_ref(ref):
+ if not ref_exists(ref):
+ raise GitException, '%s does not exist' % ref
+ sha1 = _output_one_line(['git-show-ref', '-s', ref])
+ if __run('git-update-ref -d %s %s' % (ref, sha1)):
+ raise GitException, 'Failed to delete ref %s' % ref
+
def delete_branch(name):
- """Delete a git branch
- """
- if not branch_exists(name):
- raise GitException, 'Branch "%s" does not exist' % name
- remove_file_and_dirs(os.path.join(basedir.get(), 'refs', 'heads'),
- name)
+ delete_ref('refs/heads/%s' % name)
-def rename_branch(from_name, to_name):
- """Rename a git branch
- """
- if not branch_exists(from_name):
- raise GitException, 'Branch "%s" does not exist' % from_name
- if branch_exists(to_name):
- raise GitException, 'Branch "%s" already exists' % to_name
+def rename_ref(from_ref, to_ref):
+ if not ref_exists(from_ref):
+ raise GitException, '"%s" does not exist' % from_ref
+ if ref_exists(to_ref):
+ raise GitException, '"%s" already exists' % to_ref
+ sha1 = _output_one_line(['git-show-ref', '-s', from_ref])
+ if __run('git-update-ref %s %s %s' % (to_ref, sha1, '0'*40)):
+ raise GitException, 'Failed to create new ref %s' % to_ref
+ if __run('git-update-ref -d %s %s' % (from_ref, sha1)):
+ raise GitException, 'Failed to delete ref %s' % from_ref
+
+def rename_branch(from_name, to_name):
+ """Rename a git branch."""
+ rename_ref('refs/heads/%s' % from_name, 'refs/heads/%s' % to_name)
if get_head_file() == from_name:
set_head_file(to_name)
- rename(os.path.join(basedir.get(), 'refs', 'heads'),
- from_name, to_name)
-
reflog_dir = os.path.join(basedir.get(), 'logs', 'refs', 'heads')
if os.path.exists(reflog_dir) \
and os.path.exists(os.path.join(reflog_dir, from_name)):
class Patch(StgitObject):
"""Basic patch implementation
"""
- def __init__(self, name, series_dir, refs_dir):
+ def __init_refs(self):
+ self.__top_ref = self.__refs_base + '/' + self.__name
+ self.__log_ref = self.__top_ref + '.log'
+
+ def __init__(self, name, series_dir, refs_base):
self.__series_dir = series_dir
self.__name = name
self._set_dir(os.path.join(self.__series_dir, self.__name))
- self.__refs_dir = refs_dir
- self.__top_ref_file = os.path.join(self.__refs_dir, self.__name)
- self.__log_ref_file = os.path.join(self.__refs_dir,
- self.__name + '.log')
+ self.__refs_base = refs_base
+ self.__init_refs()
def create(self):
os.mkdir(self._dir())
for f in os.listdir(self._dir()):
os.remove(os.path.join(self._dir(), f))
os.rmdir(self._dir())
- os.remove(self.__top_ref_file)
- if os.path.exists(self.__log_ref_file):
- os.remove(self.__log_ref_file)
+ git.delete_ref(self.__top_ref)
+ if git.ref_exists(self.__log_ref):
+ git.delete_ref(self.__log_ref)
def get_name(self):
return self.__name
def rename(self, newname):
olddir = self._dir()
- old_top_ref_file = self.__top_ref_file
- old_log_ref_file = self.__log_ref_file
+ old_top_ref = self.__top_ref
+ old_log_ref = self.__log_ref
self.__name = newname
self._set_dir(os.path.join(self.__series_dir, self.__name))
- self.__top_ref_file = os.path.join(self.__refs_dir, self.__name)
- self.__log_ref_file = os.path.join(self.__refs_dir,
- self.__name + '.log')
+ self.__init_refs()
+ git.rename_ref(old_top_ref, self.__top_ref)
+ if git.ref_exists(old_log_ref):
+ git.rename_ref(old_log_ref, self.__log_ref)
os.rename(olddir, self._dir())
- os.rename(old_top_ref_file, self.__top_ref_file)
- if os.path.exists(old_log_ref_file):
- os.rename(old_log_ref_file, self.__log_ref_file)
def __update_top_ref(self, ref):
- write_string(self.__top_ref_file, ref)
+ git.set_ref(self.__top_ref, ref)
def __update_log_ref(self, ref):
- write_string(self.__log_ref_file, ref)
+ git.set_ref(self.__log_ref, ref)
def update_top_ref(self):
top = self.get_top()
# initialized, but don't touch it if it isn't.
self.update_to_current_format_version()
- self.__refs_dir = os.path.join(self._basedir(), 'refs', 'patches',
- self.get_name())
+ self.__refs_base = 'refs/patches/%s' % self.get_name()
self.__applied_file = os.path.join(self._dir(), 'applied')
self.__unapplied_file = os.path.join(self._dir(), 'unapplied')
def rm(f):
if os.path.exists(f):
os.remove(f)
+ def rm_ref(ref):
+ if git.ref_exists(ref):
+ git.delete_ref(ref)
# Update 0 -> 1.
if get_format_version() == 0:
mkdir(os.path.join(branch_dir, 'trash'))
patch_dir = os.path.join(branch_dir, 'patches')
mkdir(patch_dir)
- refs_dir = os.path.join(self._basedir(), 'refs', 'patches', self.get_name())
- mkdir(refs_dir)
+ refs_base = 'refs/patches/%s' % self.get_name()
for patch in (file(os.path.join(branch_dir, 'unapplied')).readlines()
+ file(os.path.join(branch_dir, 'applied')).readlines()):
patch = patch.strip()
os.rename(os.path.join(branch_dir, patch),
os.path.join(patch_dir, patch))
- Patch(patch, patch_dir, refs_dir).update_top_ref()
+ Patch(patch, patch_dir, refs_base).update_top_ref()
set_format_version(1)
# Update 1 -> 2.
config.set('branch.%s.description' % self.get_name(), desc)
rm(desc_file)
rm(os.path.join(branch_dir, 'current'))
- rm(os.path.join(self._basedir(), 'refs', 'bases', self.get_name()))
+ rm_ref('refs/bases/%s' % self.get_name())
set_format_version(2)
# Make sure we're at the latest version.
def get_patch(self, name):
"""Return a Patch object for the given name
"""
- return Patch(name, self.__patch_dir, self.__refs_dir)
+ return Patch(name, self.__patch_dir, self.__refs_base)
def get_current_patch(self):
"""Return a Patch object representing the topmost patch, or
"""
if self.is_initialised():
raise StackException, '%s already initialized' % self.get_name()
- for d in [self._dir(), self.__refs_dir]:
+ for d in [self._dir()]:
if os.path.exists(d):
raise StackException, '%s already exists' % d
self.create_empty_field('applied')
self.create_empty_field('unapplied')
- os.makedirs(self.__refs_dir)
self._set_field('orig-base', git.get_head())
config.set(self.format_version_key(), str(FORMAT_VERSION))
if to_stack.is_initialised():
raise StackException, '"%s" already exists' % to_stack.get_name()
+ patches = self.get_applied() + self.get_unapplied()
+
git.rename_branch(self.get_name(), to_name)
+ for patch in patches:
+ git.rename_ref('refs/patches/%s/%s' % (self.get_name(), patch),
+ 'refs/patches/%s/%s' % (to_name, patch))
+ git.rename_ref('refs/patches/%s/%s.log' % (self.get_name(), patch),
+ 'refs/patches/%s/%s.log' % (to_name, patch))
if os.path.isdir(self._dir()):
rename(os.path.join(self._basedir(), 'patches'),
self.get_name(), to_stack.get_name())
- if os.path.exists(self.__refs_dir):
- rename(os.path.join(self._basedir(), 'refs', 'patches'),
- self.get_name(), to_stack.get_name())
# Rename the config section
for k in ['branch.%s', 'branch.%s.stgit']:
% self._dir())
try:
- os.removedirs(self.__refs_dir)
- except OSError:
- out.warn('Refs directory %s is not empty' % self.__refs_dir)
+ git.delete_branch(self.get_name())
+ except GitException:
+ out.warn('Could not delete branch "%s"' % self.get_name())
# Cleanup parent informations
# FIXME: should one day make use of git-config --section-remove,
~mdw / stgit / commitdiff