##// END OF EJS Templates
Changed affected to changed, sounds better, and added ungettext translations for this
Changed affected to changed, sounds better, and added ungettext translations for this

File last commit:

r2995:32471bd1 beta
r3014:02bbd574 beta
Show More
repository.py
659 lines | 23.3 KiB | text/x-python | PythonLexer
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 # -*- coding: utf-8 -*-
"""
vcs.backends.git
~~~~~~~~~~~~~~~~
Git backend implementation.
:created_on: Apr 8, 2010
:copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.
"""
import os
import re
import time
import posixpath
switched git_command to subprocession for non-blocking Popen.
r2676 import logging
import traceback
Added url validator for git
r2704 import urllib
import urllib2
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 from dulwich.repo import Repo, NotGitRepository
fixes #625 Git-Tags are not displayed in Shortlog...
r2975 from dulwich.objects import Tag
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 from string import Template
from subprocess import Popen, PIPE
from rhodecode.lib.vcs.backends.base import BaseRepository
from rhodecode.lib.vcs.exceptions import BranchDoesNotExistError
from rhodecode.lib.vcs.exceptions import ChangesetDoesNotExistError
from rhodecode.lib.vcs.exceptions import EmptyRepositoryError
from rhodecode.lib.vcs.exceptions import RepositoryError
from rhodecode.lib.vcs.exceptions import TagAlreadyExistError
from rhodecode.lib.vcs.exceptions import TagDoesNotExistError
from rhodecode.lib.vcs.utils import safe_unicode, makedate, date_fromtimestamp
from rhodecode.lib.vcs.utils.lazy import LazyProperty
from rhodecode.lib.vcs.utils.ordered_dict import OrderedDict
from rhodecode.lib.vcs.utils.paths import abspath
from rhodecode.lib.vcs.utils.paths import get_user_home
from .workdir import GitWorkdir
from .changeset import GitChangeset
from .inmemory import GitInMemoryChangeset
from .config import ConfigFile
switched git_command to subprocession for non-blocking Popen.
r2676 from rhodecode.lib import subprocessio
log = logging.getLogger(__name__)
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007
class GitRepository(BaseRepository):
"""
Git repository backend.
"""
DEFAULT_BRANCH_NAME = 'master'
scm = 'git'
def __init__(self, repo_path, create=False, src_url=None,
update_after_clone=False, bare=False):
self.path = abspath(repo_path)
self._repo = self._get_repo(create, src_url, update_after_clone, bare)
Implemented pull command for remote repos for git...
r2209 #temporary set that to now at later we will move it to constructor
baseui = None
if baseui is None:
from mercurial.ui import ui
baseui = ui()
changelog update + whitespace cleanup
r2235 # patch the instance of GitRepo with an "FAKE" ui object to add
Implemented pull command for remote repos for git...
r2209 # compatibility layer with Mercurial
setattr(self._repo, 'ui', baseui)
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 try:
self.head = self._repo.head()
except KeyError:
self.head = None
self._config_files = [
bare and abspath(self.path, 'config') or abspath(self.path, '.git',
'config'),
abspath(get_user_home(), '.gitconfig'),
]
fixed issues with support of bare-repos by vcs lib
r2320 self.bare = self._repo.bare
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007
@LazyProperty
def revisions(self):
"""
Returns list of revisions' ids, in ascending order. Being lazy
attribute allows external tools to inject shas from cache.
"""
return self._get_all_revisions()
def run_git_command(self, cmd):
"""
Runs given ``cmd`` as git command and returns tuple
(returncode, stdout, stderr).
.. note::
This method exists only until log/blame functionality is implemented
at Dulwich (see https://bugs.launchpad.net/bugs/645142). Parsing
os command's output is road to hell...
:param cmd: git command to be executed
"""
Extend GIT command wrapper with GIT_CONFIG_NOGLOBAL=1 to bypass gitconfig global
r2183
various fixes for git and mercurial with InMemoryCommit backend and non-ascii files...
r2199 _copts = ['-c', 'core.quotepath=false', ]
fixed git-command wrapper
r2200 _str_cmd = False
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 if isinstance(cmd, basestring):
various fixes for git and mercurial with InMemoryCommit backend and non-ascii files...
r2199 cmd = [cmd]
fixed git-command wrapper
r2200 _str_cmd = True
white space cleanup
r2367
fix for issue #417, git execution was broken on windows for certain commands....
r2325 gitenv = os.environ
Remove GIT_DIT from environ on calling git_command, it can break a lot of stuff
r2616 # need to clean fix GIT_DIR !
if 'GIT_DIR' in gitenv:
del gitenv['GIT_DIR']
fix for issue #417, git execution was broken on windows for certain commands....
r2325 gitenv['GIT_CONFIG_NOGLOBAL'] = '1'
various fixes for git and mercurial with InMemoryCommit backend and non-ascii files...
r2199
fix for issue #417, git execution was broken on windows for certain commands....
r2325 cmd = ['git'] + _copts + cmd
fixed git-command wrapper
r2200 if _str_cmd:
cmd = ' '.join(cmd)
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 try:
opts = dict(
fix for issue #417, git execution was broken on windows for certain commands....
r2325 env=gitenv,
get stderr also for git commands, pass in shell = False
r2760 shell=False,
fix for issue #417, git execution was broken on windows for certain commands....
r2325 )
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 if os.path.isdir(self.path):
opts['cwd'] = self.path
switched git_command to subprocession for non-blocking Popen.
r2676 p = subprocessio.SubprocessIOChunker(cmd, **opts)
except (EnvironmentError, OSError), err:
log.error(traceback.format_exc())
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 raise RepositoryError("Couldn't run git command (%s).\n"
switched git_command to subprocession for non-blocking Popen.
r2676 "Original error was:%s" % (cmd, err))
get stderr also for git commands, pass in shell = False
r2760 return ''.join(p.output), ''.join(p.error)
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007
Added url validator for git
r2704 @classmethod
def _check_url(cls, url):
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 """
Functon will check given url and try to verify if it's a valid
link. Sometimes it may happened that mercurial will issue basic
auth request that can cause whole API to hang when used from python
or other external calls.
On failures it'll raise urllib2.HTTPError
"""
Added url validator for git
r2704 from mercurial.util import url as Url
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007
Added url validator for git
r2704 # those authnadlers are patched for python 2.6.5 bug an
# infinit looping when given invalid resources
from mercurial.url import httpbasicauthhandler, httpdigestauthhandler
# check first if it's not an local url
if os.path.isdir(url) or url.startswith('file:'):
return True
if('+' in url[:url.find('://')]):
url = url[url.find('+') + 1:]
handlers = []
test_uri, authinfo = Url(url).authinfo()
if not test_uri.endswith('info/refs'):
test_uri = test_uri.rstrip('/') + '/info/refs'
if authinfo:
#create a password manager
passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
passmgr.add_password(*authinfo)
handlers.extend((httpbasicauthhandler(passmgr),
httpdigestauthhandler(passmgr)))
o = urllib2.build_opener(*handlers)
o.addheaders = [('User-Agent', 'git/1.7.8.0')] # fake some git
q = {"service": 'git-upload-pack'}
qs = '?%s' % urllib.urlencode(q)
cu = "%s%s" % (test_uri, qs)
req = urllib2.Request(cu, None, {})
try:
resp = o.open(req)
return resp.code == 200
except Exception, e:
# means it cannot be cloned
Fixed validators for remote repos...
r2706 raise urllib2.URLError("[%s] %s" % (url, e))
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007
def _get_repo(self, create, src_url=None, update_after_clone=False,
git forks were not created as bare repos
r2807 bare=False):
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 if create and os.path.exists(self.path):
raise RepositoryError("Location already exist")
if src_url and not create:
raise RepositoryError("Create should be set to True if src_url is "
"given (clone operation creates repository)")
try:
if create and src_url:
Added url validator for git
r2704 GitRepository._check_url(src_url)
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 self.clone(src_url, update_after_clone, bare)
return Repo(self.path)
elif create:
os.mkdir(self.path)
if bare:
return Repo.init_bare(self.path)
else:
return Repo.init(self.path)
else:
return Repo(self.path)
except (NotGitRepository, OSError), err:
raise RepositoryError(err)
def _get_all_revisions(self):
switched git_command to subprocession for non-blocking Popen.
r2676 # we must check if this repo is not empty, since later command
# fails if it is. And it's cheaper to ask than throw the subprocess
# errors
try:
self._repo.head()
except KeyError:
return []
Get tags and branches using _parsed_refs
r2535 cmd = 'rev-list --all --reverse --date-order'
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 try:
so, se = self.run_git_command(cmd)
except RepositoryError:
# Can be raised for empty repositories
return []
Get tags and branches using _parsed_refs
r2535 return so.splitlines()
def _get_all_revisions2(self):
#alternate implementation using dulwich
includes = [x[1][0] for x in self._parsed_refs.iteritems()
if x[1][1] != 'T']
return [c.commit.id for c in self._repo.get_walker(include=includes)]
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007
def _get_revision(self, revision):
"""
For git backend we always return integer here. This way we ensure
that changset's revision attribute would become integer.
"""
pattern = re.compile(r'^[[0-9a-fA-F]{12}|[0-9a-fA-F]{40}]$')
is_bstr = lambda o: isinstance(o, (str, unicode))
is_null = lambda o: len(o) == revision.count('0')
if len(self.revisions) == 0:
raise EmptyRepositoryError("There are no changesets yet")
if revision in (None, '', 'tip', 'HEAD', 'head', -1):
revision = self.revisions[-1]
if ((is_bstr(revision) and revision.isdigit() and len(revision) < 12)
or isinstance(revision, int) or is_null(revision)):
try:
revision = self.revisions[int(revision)]
except:
raise ChangesetDoesNotExistError("Revision %r does not exist "
"for this repository %s" % (revision, self))
elif is_bstr(revision):
Fixed lookup by Tag sha in git backend
r2536 # get by branch/tag name
added discovery by branches and tags for git
r2449 _ref_revision = self._parsed_refs.get(revision)
Fixed lookup by Tag sha in git backend
r2536 _tags_shas = self.tags.values()
added discovery by branches and tags for git
r2449 if _ref_revision: # and _ref_revision[1] in ['H', 'RH', 'T']:
return _ref_revision[0]
Fixed lookup by Tag sha in git backend
r2536 # maybe it's a tag ? we don't have them in self.revisions
elif revision in _tags_shas:
return _tags_shas[_tags_shas.index(revision)]
added discovery by branches and tags for git
r2449 elif not pattern.match(revision) or revision not in self.revisions:
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 raise ChangesetDoesNotExistError("Revision %r does not exist "
"for this repository %s" % (revision, self))
# Ensure we return full id
if not pattern.match(str(revision)):
raise ChangesetDoesNotExistError("Given revision %r not recognized"
% revision)
return revision
def _get_archives(self, archive_name='tip'):
for i in [('zip', '.zip'), ('gz', '.tar.gz'), ('bz2', '.tar.bz2')]:
yield {"type": i[0], "extension": i[1], "node": archive_name}
def _get_url(self, url):
"""
Returns normalized url. If schema is not given, would fall to
filesystem (``file:///``) schema.
"""
url = str(url)
if url != 'default' and not '://' in url:
url = ':///'.join(('file', url))
return url
@LazyProperty
def name(self):
return os.path.basename(self.path)
@LazyProperty
def last_change(self):
"""
Returns last change made on this repository as datetime object
"""
return date_fromtimestamp(self._get_mtime(), makedate()[1])
def _get_mtime(self):
try:
return time.mktime(self.get_changeset().date.timetuple())
except RepositoryError:
fixed issues with support of bare-repos by vcs lib
r2320 idx_loc = '' if self.bare else '.git'
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 # fallback to filesystem
fixed issues with support of bare-repos by vcs lib
r2320 in_path = os.path.join(self.path, idx_loc, "index")
he_path = os.path.join(self.path, idx_loc, "HEAD")
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 if os.path.exists(in_path):
return os.stat(in_path).st_mtime
else:
return os.stat(he_path).st_mtime
@LazyProperty
def description(self):
fixed issues with support of bare-repos by vcs lib
r2320 idx_loc = '' if self.bare else '.git'
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 undefined_description = u'unknown'
fixed issues with support of bare-repos by vcs lib
r2320 description_path = os.path.join(self.path, idx_loc, 'description')
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 if os.path.isfile(description_path):
return safe_unicode(open(description_path).read())
else:
return undefined_description
@LazyProperty
def contact(self):
undefined_contact = u'Unknown'
return undefined_contact
@property
def branches(self):
if not self.revisions:
return {}
sortkey = lambda ctx: ctx[0]
Get tags and branches using _parsed_refs
r2535 _branches = [(x[0], x[1][0])
for x in self._parsed_refs.iteritems() if x[1][1] == 'H']
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 return OrderedDict(sorted(_branches, key=sortkey, reverse=False))
added discovery by branches and tags for git
r2449 @LazyProperty
def tags(self):
return self._get_tags()
display current heads of branches for git in changelog and shortlog
r2198
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 def _get_tags(self):
if not self.revisions:
return {}
Get tags and branches using _parsed_refs
r2535
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 sortkey = lambda ctx: ctx[0]
Get tags and branches using _parsed_refs
r2535 _tags = [(x[0], x[1][0])
for x in self._parsed_refs.iteritems() if x[1][1] == 'T']
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 return OrderedDict(sorted(_tags, key=sortkey, reverse=True))
def tag(self, name, user, revision=None, message=None, date=None,
**kwargs):
"""
Creates and returns a tag for the given ``revision``.
:param name: name for new tag
:param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"
:param revision: changeset id for which new tag would be created
:param message: message of the tag's commit
:param date: date of tag's commit
:raises TagAlreadyExistError: if tag with same name already exists
"""
if name in self.tags:
raise TagAlreadyExistError("Tag %s already exists" % name)
changeset = self.get_changeset(revision)
message = message or "Added tag %s for commit %s" % (name,
changeset.raw_id)
self._repo.refs["refs/tags/%s" % name] = changeset._commit.id
Invalidate gits parsed_refs cache after commit, tagging or tag remove
r2539 self._parsed_refs = self._get_parsed_refs()
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 self.tags = self._get_tags()
return changeset
def remove_tag(self, name, user, message=None, date=None):
"""
Removes tag with the given ``name``.
:param name: name of the tag to be removed
:param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"
:param message: message of the tag's removal commit
:param date: date of tag's removal commit
:raises TagDoesNotExistError: if tag with given name does not exists
"""
if name not in self.tags:
raise TagDoesNotExistError("Tag %s does not exist" % name)
tagpath = posixpath.join(self._repo.refs.path, 'refs', 'tags', name)
try:
os.remove(tagpath)
Invalidate gits parsed_refs cache after commit, tagging or tag remove
r2539 self._parsed_refs = self._get_parsed_refs()
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 self.tags = self._get_tags()
except OSError, e:
raise RepositoryError(e.strerror)
added discovery by branches and tags for git
r2449 @LazyProperty
def _parsed_refs(self):
Invalidate gits parsed_refs cache after commit, tagging or tag remove
r2539 return self._get_parsed_refs()
def _get_parsed_refs(self):
added discovery by branches and tags for git
r2449 refs = self._repo.get_refs()
whitespace cleanup
r2453 keys = [('refs/heads/', 'H'),
added discovery by branches and tags for git
r2449 ('refs/remotes/origin/', 'RH'),
('refs/tags/', 'T')]
_refs = {}
for ref, sha in refs.iteritems():
for k, type_ in keys:
if ref.startswith(k):
_key = ref[len(k):]
fixes #625 Git-Tags are not displayed in Shortlog...
r2975 if type_ == 'T':
obj = self._repo.get_object(sha)
if isinstance(obj, Tag):
sha = self._repo.get_object(sha).object[1]
added discovery by branches and tags for git
r2449 _refs[_key] = [sha, type_]
break
return _refs
def _heads(self, reverse=False):
refs = self._repo.get_refs()
heads = {}
for key, val in refs.items():
for ref_key in ['refs/heads/', 'refs/remotes/origin/']:
if key.startswith(ref_key):
n = key[len(ref_key):]
if n not in ['HEAD']:
heads[n] = val
return heads if reverse else dict((y, x) for x, y in heads.iteritems())
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 def get_changeset(self, revision=None):
"""
Returns ``GitChangeset`` object representing commit from git repository
at the given revision or head (most recent commit) if None given.
"""
if isinstance(revision, GitChangeset):
return revision
revision = self._get_revision(revision)
changeset = GitChangeset(repository=self, revision=revision)
return changeset
def get_changesets(self, start=None, end=None, start_date=None,
end_date=None, branch_name=None, reverse=False):
"""
Returns iterator of ``GitChangeset`` objects from start to end (both
are inclusive), in ascending date order (unless ``reverse`` is set).
:param start: changeset ID, as str; first returned changeset
:param end: changeset ID, as str; last returned changeset
:param start_date: if specified, changesets with commit date less than
``start_date`` would be filtered out from returned set
:param end_date: if specified, changesets with commit date greater than
``end_date`` would be filtered out from returned set
:param branch_name: if specified, changesets not reachable from given
branch would be filtered out from returned set
:param reverse: if ``True``, returned generator would be reversed
(meaning that returned changesets would have descending date order)
:raise BranchDoesNotExistError: If given ``branch_name`` does not
exist.
:raise ChangesetDoesNotExistError: If changeset for given ``start`` or
``end`` could not be found.
"""
if branch_name and branch_name not in self.branches:
raise BranchDoesNotExistError("Branch '%s' not found" \
% branch_name)
# %H at format means (full) commit hash, initial hashes are retrieved
# in ascending date order
cmd_template = 'log --date-order --reverse --pretty=format:"%H"'
cmd_params = {}
if start_date:
cmd_template += ' --since "$since"'
cmd_params['since'] = start_date.strftime('%m/%d/%y %H:%M:%S')
if end_date:
cmd_template += ' --until "$until"'
cmd_params['until'] = end_date.strftime('%m/%d/%y %H:%M:%S')
if branch_name:
cmd_template += ' $branch_name'
cmd_params['branch_name'] = branch_name
else:
cmd_template += ' --all'
cmd = Template(cmd_template).safe_substitute(**cmd_params)
revs = self.run_git_command(cmd)[0].splitlines()
start_pos = 0
end_pos = len(revs)
if start:
_start = self._get_revision(start)
try:
start_pos = revs.index(_start)
except ValueError:
pass
if end is not None:
_end = self._get_revision(end)
try:
end_pos = revs.index(_end)
except ValueError:
pass
if None not in [start, end] and start_pos > end_pos:
raise RepositoryError('start cannot be after end')
if end_pos is not None:
end_pos += 1
revs = revs[start_pos:end_pos]
if reverse:
revs = reversed(revs)
for rev in revs:
yield self.get_changeset(rev)
def get_diff(self, rev1, rev2, path=None, ignore_whitespace=False,
fixed issues with gitsubmodule diffs
r2233 context=3):
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 """
Returns (git like) *diff*, as plain text. Shows changes introduced by
``rev2`` since ``rev1``.
:param rev1: Entry point from which diff is shown. Can be
``self.EMPTY_CHANGESET`` - in this case, patch showing all
the changes since empty state of the repository until ``rev2``
:param rev2: Until which revision changes should be shown.
:param ignore_whitespace: If set to ``True``, would not show whitespace
changes. Defaults to ``False``.
:param context: How many lines before/after changed lines should be
shown. Defaults to ``3``.
"""
Implemented generation of changesets based...
r2995 flags = ['-U%s' % context, '--full-index', '--binary', '-p', '-M', '--abbrev=40']
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 if ignore_whitespace:
flags.append('-w')
Added diff option into git and hg changeset objects, representing git formated patch against parent1
r2384 if hasattr(rev1, 'raw_id'):
rev1 = getattr(rev1, 'raw_id')
if hasattr(rev2, 'raw_id'):
rev2 = getattr(rev2, 'raw_id')
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 if rev1 == self.EMPTY_CHANGESET:
rev2 = self.get_changeset(rev2).raw_id
cmd = ' '.join(['show'] + flags + [rev2])
else:
rev1 = self.get_changeset(rev1).raw_id
rev2 = self.get_changeset(rev2).raw_id
cmd = ' '.join(['diff'] + flags + [rev1, rev2])
if path:
cmd += ' -- "%s"' % path
Implemented generation of changesets based...
r2995
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 stdout, stderr = self.run_git_command(cmd)
# If we used 'show' command, strip first few lines (until actual diff
# starts)
if rev1 == self.EMPTY_CHANGESET:
lines = stdout.splitlines()
x = 0
for line in lines:
if line.startswith('diff'):
break
x += 1
# Append new line just like 'diff' command do
stdout = '\n'.join(lines[x:]) + '\n'
return stdout
@LazyProperty
def in_memory_changeset(self):
"""
Returns ``GitInMemoryChangeset`` object for this repository.
"""
return GitInMemoryChangeset(self)
def clone(self, url, update_after_clone=True, bare=False):
"""
Tries to clone changes from external location.
:param update_after_clone: If set to ``False``, git won't checkout
working directory
:param bare: If set to ``True``, repository would be cloned into
*bare* git repository (no working directory at all).
"""
url = self._get_url(url)
cmd = ['clone']
if bare:
cmd.append('--bare')
elif not update_after_clone:
cmd.append('--no-checkout')
cmd += ['--', '"%s"' % url, '"%s"' % self.path]
cmd = ' '.join(cmd)
# If error occurs run_git_command raises RepositoryError already
self.run_git_command(cmd)
Implemented pull command for remote repos for git...
r2209 def pull(self, url):
"""
Tries to pull changes from external location.
"""
url = self._get_url(url)
cmd = ['pull']
cmd.append("--ff-only")
pass in url for remote pull in git
r2210 cmd.append(url)
Implemented pull command for remote repos for git...
r2209 cmd = ' '.join(cmd)
# If error occurs run_git_command raises RepositoryError already
self.run_git_command(cmd)
Don't do git pull on remote repos since they are bare now, we need to use git fetch on them
r2383 def fetch(self, url):
"""
Tries to pull changes from external location.
"""
url = self._get_url(url)
cmd = ['fetch']
cmd.append(url)
cmd = ' '.join(cmd)
# If error occurs run_git_command raises RepositoryError already
self.run_git_command(cmd)
Added VCS into rhodecode core for faster and easier deployments of new versions
r2007 @LazyProperty
def workdir(self):
"""
Returns ``Workdir`` instance for this repository.
"""
return GitWorkdir(self)
def get_config_value(self, section, name, config_file=None):
"""
Returns configuration value for a given [``section``] and ``name``.
:param section: Section we want to retrieve value from
:param name: Name of configuration we want to retrieve
:param config_file: A path to file which should be used to retrieve
configuration from (might also be a list of file paths)
"""
if config_file is None:
config_file = []
elif isinstance(config_file, basestring):
config_file = [config_file]
def gen_configs():
for path in config_file + self._config_files:
try:
yield ConfigFile.from_path(path)
except (IOError, OSError, ValueError):
continue
for config in gen_configs():
try:
return config.get(section, name)
except KeyError:
continue
return None
def get_user_name(self, config_file=None):
"""
Returns user's name from global configuration file.
:param config_file: A path to file which should be used to retrieve
configuration from (might also be a list of file paths)
"""
return self.get_config_value('user', 'name', config_file)
def get_user_email(self, config_file=None):
"""
Returns user's email from global configuration file.
:param config_file: A path to file which should be used to retrieve
configuration from (might also be a list of file paths)
"""
return self.get_config_value('user', 'email', config_file)