"""Methods with this decorator raise InvalidGitRepositoryError if they

def wrapper(self, *args, **kwargs):

if self.repo.bare:

raise InvalidGitRepositoryError("Method '%s' cannot operate on bare repositories" % func.__name__)

# END bare method

return func(self, *args, **kwargs)

# END wrapper

wrapper.__name__ = func.__name__

"""Remove the given recursively.

def onerror(func, path, exc_info):

if not os.access(path, os.W_OK):

# Is the error an access error ?

os.chmod(path, stat.S_IWUSR)

func(path)

else:

raise

# END end onerror

"""Copy all data from the source stream into the destination stream in chunks

br = 0

while True:

chunk = source.read(chunk_size)

destination.write(chunk)

br += len(chunk)

if len(chunk) < chunk_size:

break

# END reading output stream

"""Join path tokens together similar to os.path.join, but always use

path = a

for b in p:

if len(b) == 0:

continue

if b.startswith('/'):

path += b[1:]

elif path == '' or path.endswith('/'):

path += b

else:

path += '/' + b

# END for each path token to add

"""

"""Assure that the directory pointed to by path exists.

if is_file:

path = os.path.dirname(path)

# END handle file

if not os.path.isdir(path):

os.makedirs(path)

return True

"""

_num_op_codes = 8

BEGIN, END, COUNTING, COMPRESSING, WRITING, RECEIVING, RESOLVING, FINDING_SOURCES = \

[1 << x for x in range(_num_op_codes)]

STAGE_MASK = BEGIN | END

OP_MASK = ~STAGE_MASK

__slots__ = ("_cur_line", "_seen_ops")

re_op_absolute = re.compile("(remote: )?([\w\s]+):\s+()(\d+)()(.*)")

re_op_relative = re.compile("(remote: )?([\w\s]+):\s+(\d+)% \((\d+)/(\d+)\)(.*)")

def __init__(self):

self._seen_ops = list()

def _parse_progress_line(self, line):

"""Parse progress information from the given line as retrieved by git-push

# handle

# Counting objects: 4, done.

# Compressing objects: 50% (1/2) \rCompressing objects: 100% (2/2) \rCompressing objects: 100% (2/2), done.

self._cur_line = line

sub_lines = line.split('\r')

failed_lines = list()

for sline in sub_lines:

# find esacpe characters and cut them away - regex will not work with

# them as they are non-ascii. As git might expect a tty, it will send them

last_valid_index = None

for i, c in enumerate(reversed(sline)):

if ord(c) < 32:

# its a slice index

last_valid_index = -i - 1

# END character was non-ascii

# END for each character in sline

if last_valid_index is not None:

sline = sline[:last_valid_index]

# END cut away invalid part

sline = sline.rstrip()

cur_count, max_count = None, None

match = self.re_op_relative.match(sline)

if match is None:

match = self.re_op_absolute.match(sline)

if not match:

self.line_dropped(sline)

failed_lines.append(sline)

continue

# END could not get match

op_code = 0

remote, op_name, percent, cur_count, max_count, message = match.groups()

# get operation id

if op_name == "Counting objects":

op_code |= self.COUNTING

elif op_name == "Compressing objects":

op_code |= self.COMPRESSING

elif op_name == "Writing objects":

op_code |= self.WRITING

elif op_name == 'Receiving objects':

op_code |= self.RECEIVING

elif op_name == 'Resolving deltas':

op_code |= self.RESOLVING

elif op_name == 'Finding sources':

op_code |= self.FINDING_SOURCES

else:

# Note: On windows it can happen that partial lines are sent

# Hence we get something like "CompreReceiving objects", which is

# a blend of "Compressing objects" and "Receiving objects".

# This can't really be prevented, so we drop the line verbosely

# to make sure we get informed in case the process spits out new

# commands at some point.

self.line_dropped(sline)

sys.stderr.write("Operation name %r unknown - skipping line '%s'" % (op_name, sline))

# Note: Don't add this line to the failed lines, as we have to silently

# drop it

return failed_lines

# END handle op code

# figure out stage

if op_code not in self._seen_ops:

self._seen_ops.append(op_code)

op_code |= self.BEGIN

# END begin opcode

if message is None:

message = ''

# END message handling

message = message.strip()

done_token = ', done.'

if message.endswith(done_token):

op_code |= self.END

message = message[:-len(done_token)]

# END end message handling

self.update(op_code,

cur_count and float(cur_count),

max_count and float(max_count),

message)

# END for each sub line

return failed_lines

def new_message_handler(self):

"""

def handler(line):

return self._parse_progress_line(line.rstrip())

# end

return handler

def line_dropped(self, line):

"""Called whenever a line could not be understood and was therefore dropped."""

pass

def update(self, op_code, cur_count, max_count=None, message=''):

"""Called whenever the progress changes

"""Actors hold information about a person acting on the repository. They

# PRECOMPILED REGEX

name_only_regex = re.compile(r'<(.+)>')

name_email_regex = re.compile(r'(.*) <(.+?)>')

# ENVIRONMENT VARIABLES

# read when creating new commits

env_author_name = "GIT_AUTHOR_NAME"

env_author_email = "GIT_AUTHOR_EMAIL"

env_committer_name = "GIT_COMMITTER_NAME"

env_committer_email = "GIT_COMMITTER_EMAIL"

# CONFIGURATION KEYS

conf_name = 'name'

conf_email = 'email'

__slots__ = ('name', 'email')

def __init__(self, name, email):

self.name = name

self.email = email

def __eq__(self, other):

return self.name == other.name and self.email == other.email

def __ne__(self, other):

return not (self == other)

def __hash__(self):

return hash((self.name, self.email))

def __str__(self):

return self.name

def __repr__(self):

return u'<git.Actor "%s <%s>">' % (self.name, self.email)

@classmethod

def _from_string(cls, string):

"""Create an Actor from a string.

m = cls.name_email_regex.search(string)

if m:

name, email = m.groups()

return Actor(name, email)

else:

m = cls.name_only_regex.search(string)

if m:

return Actor(m.group(1), None)

else:

# assume best and use the whole string as name

return Actor(string, None)

# END special case name

# END handle name/email matching

@classmethod

def _main_actor(cls, env_name, env_email, config_reader=None):

actor = Actor('', '')

default_email = get_user_id()

default_name = default_email.split('@')[0]

for attr, evar, cvar, default in (('name', env_name, cls.conf_name, default_name),

('email', env_email, cls.conf_email, default_email)):

try:

val = os.environ[evar]

if not PY3:

val = val.decode(defenc)

# end assure we don't get 'invalid strings'

setattr(actor, attr, val)

except KeyError:

if config_reader is not None:

setattr(actor, attr, config_reader.get_value('user', cvar, default))

# END config-reader handling

if not getattr(actor, attr):

setattr(actor, attr, default)

# END handle name

# END for each item to retrieve

return actor

@classmethod

def committer(cls, config_reader=None):

"""

return cls._main_actor(cls.env_committer_name, cls.env_committer_email, config_reader)

@classmethod

def author(cls, config_reader=None):

"""Same as committer(), but defines the main author. It may be specified in the environment,

"""

__slots__ = ("total", "files")

def __init__(self, total, files):

self.total = total

self.files = files

@classmethod

def _list_from_string(cls, repo, text):

"""Create a Stat object from output retrieved by git-diff.

hsh = {'total': {'insertions': 0, 'deletions': 0, 'lines': 0, 'files': 0}, 'files': dict()}

for line in text.splitlines():

(raw_insertions, raw_deletions, filename) = line.split("\t")

insertions = raw_insertions != '-' and int(raw_insertions) or 0

deletions = raw_deletions != '-' and int(raw_deletions) or 0

hsh['total']['insertions'] += insertions

hsh['total']['deletions'] += deletions

hsh['total']['lines'] += insertions + deletions

hsh['total']['files'] += 1

hsh['files'][filename.strip()] = {'insertions': insertions,

'deletions': deletions,

'lines': insertions + deletions}

"""Wrapper around a file-like object that remembers the SHA1 of

__slots__ = ("f", "sha1")

def __init__(self, f):

self.f = f

self.sha1 = make_sha(b"")

def write(self, data):

self.sha1.update(data)

return self.f.write(data)

def write_sha(self):

sha = self.sha1.digest()

self.f.write(sha)

return sha

def close(self):

sha = self.write_sha()

self.f.close()

return sha

def tell(self):

"""Provides methods to obtain, check for, and release a file based lock which

__slots__ = ("_file_path", "_owns_lock")

def __init__(self, file_path):

self._file_path = file_path

self._owns_lock = False

def __del__(self):

self._release_lock()

def _lock_file_path(self):

""":return: Path to lockfile"""

return "%s.lock" % (self._file_path)

def _has_lock(self):

""":return: True if we have a lock and if the lockfile still exists

return self._owns_lock

def _obtain_lock_or_raise(self):

"""Create a lock file as flag for other instances, mark our instance as lock-holder

if self._has_lock():

return

lock_file = self._lock_file_path()

if os.path.isfile(lock_file):

raise IOError("Lock for file %r did already exist, delete %r in case the lock is illegal" %

(self._file_path, lock_file))

try:

fd = os.open(lock_file, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0)

os.close(fd)

except OSError as e:

raise IOError(str(e))

self._owns_lock = True

def _obtain_lock(self):

"""The default implementation will raise if a lock cannot be obtained.

return self._obtain_lock_or_raise()

def _release_lock(self):

"""Release our lock if we have one"""

if not self._has_lock():

return

# if someone removed our file beforhand, lets just flag this issue

# instead of failing, to make it more usable.

lfp = self._lock_file_path()

try:

# on bloody windows, the file needs write permissions to be removable.

# Why ...

if os.name == 'nt':

os.chmod(lfp, 0o777)

# END handle win32

os.remove(lfp)

except OSError:

pass

"""The lock file will block until a lock could be obtained, or fail after

__slots__ = ("_check_interval", "_max_block_time")

def __init__(self, file_path, check_interval_s=0.3, max_block_time_s=MAXSIZE):

"""Configure the instance

super(BlockingLockFile, self).__init__(file_path)

self._check_interval = check_interval_s

self._max_block_time = max_block_time_s

def _obtain_lock(self):

"""This method blocks until it obtained the lock, or raises IOError if

starttime = time.time()

maxtime = starttime + float(self._max_block_time)

while True:

try:

super(BlockingLockFile, self)._obtain_lock()

except IOError:

# synity check: if the directory leading to the lockfile is not

# readable anymore, raise an execption

curtime = time.time()

if not os.path.isdir(os.path.dirname(self._lock_file_path())):

msg = "Directory containing the lockfile %r was not readable anymore after waiting %g seconds" % (

self._lock_file_path(), curtime - starttime)

raise IOError(msg)

# END handle missing directory

if curtime >= maxtime:

msg = "Waited %g seconds for lock at %r" % (maxtime - starttime, self._lock_file_path())

raise IOError(msg)

# END abort if we wait too long

time.sleep(self._check_interval)

else:

break

"""

__slots__ = ('_id_attr', '_prefix')

def __new__(cls, id_attr, prefix=''):

return super(IterableList, cls).__new__(cls)

def __init__(self, id_attr, prefix=''):

self._id_attr = id_attr

self._prefix = prefix

def __contains__(self, attr):

# first try identy match for performance

rval = list.__contains__(self, attr)

if rval:

return rval

# END handle match

# otherwise make a full name search

try:

getattr(self, attr)

return True

except (AttributeError, TypeError):

return False

# END handle membership

def __getattr__(self, attr):

attr = self._prefix + attr

for item in self:

if getattr(item, self._id_attr) == attr:

return item

# END for each item

return list.__getattribute__(self, attr)

def __getitem__(self, index):

if isinstance(index, int):

return list.__getitem__(self, index)

try:

return getattr(self, index)

except AttributeError:

raise IndexError("No item found with id %r" % (self._prefix + index))

# END handle getattr

def __delitem__(self, index):

delindex = index

if not isinstance(index, int):

delindex = -1

name = self._prefix + index

for i, item in enumerate(self):

if getattr(item, self._id_attr) == name:

delindex = i

break

# END search index

# END for each item

if delindex == -1:

raise IndexError("Item with name %s not found" % name)

# END handle error

# END get index to delete

"""Defines an interface for iterable items which is to assure a uniform

__slots__ = tuple()

_id_attribute_ = "attribute that most suitably identifies your instance"

@classmethod

def list_items(cls, repo, *args, **kwargs):

"""

out_list = IterableList(cls._id_attribute_)

out_list.extend(cls.iter_items(repo, *args, **kwargs))

return out_list

@classmethod

def iter_items(cls, repo, *args, **kwargs):

"""For more information about the arguments, see list_items

"""WaitGroup is like Go sync.WaitGroup.

def __init__(self):

self.count = 0

self.cv = threading.Condition()

def add(self, n):

self.cv.acquire()

self.count += n

self.cv.release()

def done(self):

self.cv.acquire()

self.count -= 1

if self.count == 0:

self.cv.notify_all()

self.cv.release()

def wait(self):

self.cv.acquire()

while self.count > 0:

self.cv.wait()