# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.lib.auth

~~~~~~~~~~~~~~~~~~

authentication and permission libraries

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 4, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import hashlib

import itertools

import logging

import os

import ipaddr

from decorator import decorator

from sqlalchemy.orm import joinedload

from sqlalchemy.orm.exc import ObjectDeletedError

from tg import request

from tg.i18n import ugettext as _

from webob.exc import HTTPForbidden, HTTPFound

from kallithea import __platform__, is_unix, is_windows

from kallithea.config.routing import url

from kallithea.lib.caching_query import FromCache

from kallithea.lib.utils import conditional_cache, get_repo_group_slug, get_repo_slug, get_user_group_slug

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.model.db import (

    Permission, RepoGroup, Repository, User, UserApiKeys, UserGroup, UserGroupMember, UserGroupRepoGroupToPerm, UserGroupRepoToPerm, UserGroupToPerm, UserGroupUserGroupToPerm, UserIpMap, UserToPerm)

from kallithea.model.meta import Session

from kallithea.model.user import UserModel

log = logging.getLogger(__name__)

class PasswordGenerator(object):

    """

    This is a simple class for generating password from different sets of

    characters

    usage::

        passwd_gen = PasswordGenerator()

        #print 8-letter password containing only big and small letters

            of alphabet

        passwd_gen.gen_password(8, passwd_gen.ALPHABETS_BIG_SMALL)

    """

    ALPHABETS_NUM = r'''1234567890'''

    ALPHABETS_SMALL = r'''qwertyuiopasdfghjklzxcvbnm'''

    ALPHABETS_BIG = r'''QWERTYUIOPASDFGHJKLZXCVBNM'''

    ALPHABETS_SPECIAL = r'''`-=[]\;',./~!@#$%^&*()_+{}|:"<>?'''

    ALPHABETS_FULL = ALPHABETS_BIG + ALPHABETS_SMALL \

        + ALPHABETS_NUM + ALPHABETS_SPECIAL

    ALPHABETS_ALPHANUM = ALPHABETS_BIG + ALPHABETS_SMALL + ALPHABETS_NUM

    ALPHABETS_BIG_SMALL = ALPHABETS_BIG + ALPHABETS_SMALL

    ALPHABETS_ALPHANUM_BIG = ALPHABETS_BIG + ALPHABETS_NUM

    ALPHABETS_ALPHANUM_SMALL = ALPHABETS_SMALL + ALPHABETS_NUM

    def gen_password(self, length, alphabet=ALPHABETS_FULL):

        assert len(alphabet) <= 256, alphabet

        l = []

        while len(l) < length:

            i = ord(os.urandom(1))

            if i < len(alphabet):

                l.append(alphabet[i])

        return ''.join(l)

def get_crypt_password(password):

    """

    Cryptographic function used for password hashing based on pybcrypt

    or Python's own OpenSSL wrapper on windows

    :param password: password to hash

    """

    if is_windows:

        return hashlib.sha256(password).hexdigest()

    elif is_unix:

        import bcrypt

    else:

        raise Exception('Unknown or unsupported platform %s'

                        % __platform__)

def check_password(password, hashed):

    """

    Checks matching password with it's hashed value, runs different

    implementation based on platform it runs on

    :param password: password

    :param hashed: password in hashed form

    """

    if is_windows:

        return hashlib.sha256(password).hexdigest() == hashed

    elif is_unix:

        import bcrypt

        try:

        except ValueError as e:

            # bcrypt will throw ValueError 'Invalid hashed_password salt' on all password errors

            log.error('error from bcrypt checking password: %s', e)

            return False

    else:

        raise Exception('Unknown or unsupported platform %s'

                        % __platform__)

def _cached_perms_data(user_id, user_is_admin):

    RK = 'repositories'

    GK = 'repositories_groups'

    UK = 'user_groups'

    GLOBAL = 'global'

    PERM_WEIGHTS = Permission.PERM_WEIGHTS

    permissions = {RK: {}, GK: {}, UK: {}, GLOBAL: set()}

    def bump_permission(kind, key, new_perm):

        """Add a new permission for kind and key.

        Assuming the permissions are comparable, set the new permission if it

        has higher weight, else drop it and keep the old permission.

        """

        cur_perm = permissions[kind][key]

        new_perm_val = PERM_WEIGHTS[new_perm]

        cur_perm_val = PERM_WEIGHTS[cur_perm]

        if new_perm_val > cur_perm_val:

            permissions[kind][key] = new_perm

    #======================================================================

    # fetch default permissions

    #======================================================================

    default_user = User.get_by_username('default', cache=True)

    default_user_id = default_user.user_id

    default_repo_perms = Permission.get_default_perms(default_user_id)

    default_repo_groups_perms = Permission.get_default_group_perms(default_user_id)

    default_user_group_perms = Permission.get_default_user_group_perms(default_user_id)

    if user_is_admin:

        #==================================================================

        # admin users have all rights;

        # based on default permissions, just set everything to admin

        #==================================================================

        permissions[GLOBAL].add('hg.admin')

        permissions[GLOBAL].add('hg.create.write_on_repogroup.true')

        # repositories

        for perm in default_repo_perms:

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.lib.celerylib

~~~~~~~~~~~~~~~~~~~~~~~

celery libs for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Nov 27, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import os

from hashlib import md5

from decorator import decorator

from tg import config

from kallithea import CELERY_EAGER, CELERY_ON

from kallithea.lib.pidlock import DaemonLock, LockHeld

from kallithea.model import meta

log = logging.getLogger(__name__)

class FakeTask(object):

    """Fake a sync result to make it look like a finished task"""

    def __init__(self, result):

        self.result = result

    def failed(self):

        return False

    traceback = None # if failed

    task_id = None

def task(f_org):

    """Wrapper of celery.task.task, running async if CELERY_ON

    """

    if CELERY_ON:

        def f_async(*args, **kwargs):

            log.info('executing %s task', f_org.__name__)

            try:

                f_org(*args, **kwargs)

            finally:

                log.info('executed %s task', f_org.__name__)

        f_async.__name__ = f_org.__name__

        from kallithea.lib import celerypylons

        runner = celerypylons.task(ignore_result=True)(f_async)

        def f_wrapped(*args, **kwargs):

            t = runner.apply_async(args=args, kwargs=kwargs)

            log.info('executing task %s in async mode - id %s', f_org, t.task_id)

            return t

    else:

        def f_wrapped(*args, **kwargs):

            log.info('executing task %s in sync', f_org.__name__)

            try:

                result = f_org(*args, **kwargs)

            except Exception as e:

                log.error('exception executing sync task %s in sync: %r', f_org.__name__, e)

                raise # TODO: return this in FakeTask as with async tasks?

            return FakeTask(result)

    return f_wrapped

def __get_lockkey(func, *fargs, **fkwargs):

    params = list(fargs)

    params.extend(['%s-%s' % ar for ar in fkwargs.items()])

    func_name = str(func.__name__) if hasattr(func, '__name__') else str(func)

    lockkey = 'task_%s.lock' % \

    return lockkey

def locked_task(func):

    def __wrapper(func, *fargs, **fkwargs):

        lockkey = __get_lockkey(func, *fargs, **fkwargs)

        lockkey_path = config.get('cache_dir') or config['app_conf']['cache_dir']  # Backward compatibility for TurboGears < 2.4

        log.info('running task with lockkey %s', lockkey)

        try:

            l = DaemonLock(os.path.join(lockkey_path, lockkey))

            ret = func(*fargs, **fkwargs)

            l.release()

            return ret

        except LockHeld:

            log.info('LockHeld')

            return 'Task with key %s already running' % lockkey

    return decorator(__wrapper, func)

def get_session():

    sa = meta.Session()

    return sa

def dbsession(func):

    def __wrapper(func, *fargs, **fkwargs):

        try:

            ret = func(*fargs, **fkwargs)

            return ret

        finally:

            if CELERY_ON and not CELERY_EAGER:

                meta.Session.remove()

    return decorator(__wrapper, func)

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

Helper functions

Consists of functions to typically be used within templates, but also

available to Controllers. This module is available to both as 'h'.

"""

import hashlib

import json

import logging

import random

import re

import textwrap

import urlparse

from beaker.cache import cache_region

from pygments import highlight as code_highlight

from pygments.formatters.html import HtmlFormatter

from tg.i18n import ugettext as _

from webhelpers2.html import HTML, escape, literal

from webhelpers2.html.tags import NotGiven, Option, Options, _input, _make_safe_id_component, checkbox, end_form

from webhelpers2.html.tags import form as insecure_form

from webhelpers2.html.tags import hidden, link_to, password, radio

from webhelpers2.html.tags import select as webhelpers2_select

from webhelpers2.html.tags import submit, text, textarea

from webhelpers2.number import format_byte_size

from webhelpers2.text import chop_at, truncate, wrap_paragraphs

from kallithea.config.routing import url

from kallithea.lib.annotate import annotate_highlight

#==============================================================================

# PERMS

#==============================================================================

from kallithea.lib.auth import HasPermissionAny, HasRepoGroupPermissionLevel, HasRepoPermissionLevel

from kallithea.lib.markup_renderer import url_re

from kallithea.lib.pygmentsutils import get_custom_lexer

from kallithea.lib.utils2 import MENTIONS_REGEX, AttributeDict

from kallithea.lib.utils2 import age as _age

from kallithea.lib.vcs.backends.base import BaseChangeset, EmptyChangeset

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError

#==============================================================================

# SCM FILTERS available via h.

#==============================================================================

from kallithea.lib.vcs.utils import author_email, author_name

log = logging.getLogger(__name__)

def canonical_url(*args, **kargs):

    '''Like url(x, qualified=True), but returns url that not only is qualified

    but also canonical, as configured in canonical_url'''

    from kallithea import CONFIG

    try:

        parts = CONFIG.get('canonical_url', '').split('://', 1)

        kargs['host'] = parts[1]

        kargs['protocol'] = parts[0]

    except IndexError:

        kargs['qualified'] = True

    return url(*args, **kargs)

def canonical_hostname():

    '''Return canonical hostname of system'''

    from kallithea import CONFIG

    try:

        parts = CONFIG.get('canonical_url', '').split('://', 1)

        return parts[1].split('/', 1)[0]

    except IndexError:

        parts = url('home', qualified=True).split('://', 1)

        return parts[1].split('/', 1)[0]

def html_escape(s):

    """Return string with all html escaped.

    This is also safe for javascript in html but not necessarily correct.

    """

    return (s

        .replace('&', '&')

        .replace(">", ">")

        .replace("<", "&lt;")

        .replace('"', """)

        .replace("'", "'") # Note: this is HTML5 not HTML4 and might not work in mails

        )

def js(value):

def reset(name, value, id=NotGiven, **attrs):

    """Create a reset button, similar to webhelpers2.html.tags.submit ."""

    return _input("reset", name, value, id, attrs)

def select(name, selected_values, options, id=NotGiven, **attrs):

    """Convenient wrapper of webhelpers2 to let it accept options as a tuple list"""

    if isinstance(options, list):

        option_list = options

        # Handle old value,label lists ... where value also can be value,label lists

        options = Options()

        for x in option_list:

            if isinstance(x, tuple) and len(x) == 2:

                value, label = x

            elif isinstance(x, basestring):

                value = label = x

            else:

                log.error('invalid select option %r', x)

                raise

            if isinstance(value, list):

                og = options.add_optgroup(label)

                for x in value:

                    if isinstance(x, tuple) and len(x) == 2:

                        group_value, group_label = x

                    elif isinstance(x, basestring):

                        group_value = group_label = x

                    else:

                        log.error('invalid select option %r', x)

                        raise

                    og.add_option(group_label, group_value)

            else:

                options.add_option(label, value)

    return webhelpers2_select(name, selected_values, options, id=id, **attrs)

safeid = _make_safe_id_component

def FID(raw_id, path):

    """

    Creates a unique ID for filenode based on it's hash of path and revision

    it's safe to use in urls

    :param raw_id:

    :param path:

    """

class _FilesBreadCrumbs(object):

    def __call__(self, repo_name, rev, paths):

        if isinstance(paths, str):

            paths = safe_unicode(paths)

        url_l = [link_to(repo_name, url('files_home',

                                        repo_name=repo_name,

                                        revision=rev, f_path=''),

                         class_='ypjax-link')]

        paths_l = paths.split('/')

        for cnt, p in enumerate(paths_l):

            if p != '':

                url_l.append(link_to(p,

                                     url('files_home',

                                         repo_name=repo_name,

                                         revision=rev,

                                         f_path='/'.join(paths_l[:cnt + 1])

                                         ),

                                     class_='ypjax-link'

                                     )

                             )

        return literal('/'.join(url_l))

files_breadcrumbs = _FilesBreadCrumbs()

class CodeHtmlFormatter(HtmlFormatter):

    """

    My code Html Formatter for source codes

    """

    def wrap(self, source, outfile):

        return self._wrap_div(self._wrap_pre(self._wrap_code(source)))

    def _wrap_code(self, source):

        for cnt, it in enumerate(source):

            i, t = it

            t = '<span id="L%s">%s</span>' % (cnt + 1, t)

            yield i, t

    def _wrap_tablelinenos(self, inner):

        inner_lines = []

        lncount = 0

        for t, line in inner:

def gravatar(email_address, cls='', size=30):

    """return html element of the gravatar

    This method will return an <img> with the resolution double the size (for

    retina screens) of the image. If the url returned from gravatar_url is

    empty then we fallback to using an icon.

    """

    from tg import tmpl_context as c

    if not c.visual.use_gravatar:

        return ''

    src = gravatar_url(email_address, size * 2)

    if src:

        # here it makes sense to use style="width: ..." (instead of, say, a

        # stylesheet) because we using this to generate a high-res (retina) size

        html = ('<i class="icon-gravatar {cls}"'

                ' style="font-size: {size}px;background-size: {size}px;background-image: url(\'{src}\')"'

                '></i>').format(cls=cls, size=size, src=src)

    else:

        # if src is empty then there was no gravatar, so we use a font icon

        html = ("""<i class="icon-user {cls}" style="font-size: {size}px;"></i>"""

            .format(cls=cls, size=size, src=src))

    return literal(html)

def gravatar_url(email_address, size=30, default=''):

    # doh, we need to re-import those to mock it later

    from kallithea.config.routing import url

    from kallithea.model.db import User

    from tg import tmpl_context as c

    if not c.visual.use_gravatar:

        return ""

    _def = 'anonymous@kallithea-scm.org'  # default gravatar

    email_address = email_address or _def

    if email_address == _def:

        return default

    parsed_url = urlparse.urlparse(url.current(qualified=True))

    url = (c.visual.gravatar_url or User.DEFAULT_GRAVATAR_URL) \

               .replace('{email}', email_address) \

               .replace('{netloc}', parsed_url.netloc) \

               .replace('{scheme}', parsed_url.scheme) \

               .replace('{size}', str(size))

    return url

def changed_tooltip(nodes):

    """

    Generates a html string for changed nodes in changeset page.

    It limits the output to 30 entries

    :param nodes: LazyNodesGenerator

    """

    if nodes:

        pref = ': <br/> '

        suf = ''

        if len(nodes) > 30:

            suf = '<br/>' + _(' and %s more') % (len(nodes) - 30)

        return literal(pref + '<br/> '.join([safe_unicode(x.path)

                                             for x in nodes[:30]]) + suf)

    else:

        return ': ' + _('No files')

def fancy_file_stats(stats):

    """

    Displays a fancy two colored bar for number of added/deleted

    lines of code on file

    :param stats: two element list of added/deleted lines of code

    """

    from kallithea.lib.diffs import NEW_FILENODE, DEL_FILENODE, \

        MOD_FILENODE, RENAMED_FILENODE, CHMOD_FILENODE, BIN_FILENODE

    a, d = stats['added'], stats['deleted']

    width = 100

    if stats['binary']:

        # binary mode

        lbl = ''

        bin_op = 1

        if BIN_FILENODE in stats['ops']:

            lbl = 'bin+'

        if NEW_FILENODE in stats['ops']:

            lbl += _('new file')

            bin_op = NEW_FILENODE

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

kallithea.lib.middleware.permanent_repo_url

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

middleware to handle permanent repo URLs, replacing PATH_INFO '/_123/yada' with

'/name/of/repo/yada' after looking 123 up in the database.

"""

from kallithea.lib.utils import fix_repo_id_name

class PermanentRepoUrl(object):

    def __init__(self, app, config):

        self.application = app

        self.config = config

    def __call__(self, environ, start_response):

        # Extract path_info as get_path_info does, but do it explicitly because

        # we also have to do the reverse operation when patching it back in

        path_info = safe_unicode(environ['PATH_INFO'])

        if path_info.startswith('/'): # it must

        return self.application(environ, start_response)

    # check if it's not a repo

    if is_valid_repo(repo_group_name, base_path):

        return False

    try:

        # we need to check bare git repos at higher level

        # since we might match branches/hooks/info/objects or possible

        # other things inside bare git repo

        get_scm(os.path.dirname(full_path))

        return False

    except VCSError:

        pass

    # check if it's a valid path

    if skip_path_check or os.path.isdir(full_path):

        return True

    return False

# propagated from mercurial documentation

ui_sections = ['alias', 'auth',

                'decode/encode', 'defaults',

                'diff', 'email',

                'extensions', 'format',

                'merge-patterns', 'merge-tools',

                'hooks', 'http_proxy',

                'smtp', 'patch',

                'paths', 'profiling',

                'server', 'trusted',

                'ui', 'web', ]

def make_ui(repo_path=None):

    """

    Create an Mercurial 'ui' object based on database Ui settings, possibly

    augmenting with content from a hgrc file.

    """

    baseui = ui.ui()

    # clean the baseui object

    baseui._ocfg = config.config()

    baseui._ucfg = config.config()

    baseui._tcfg = config.config()

    sa = meta.Session()

    for ui_ in sa.query(Ui).all():

        if ui_.ui_active:

            log.debug('config from db: [%s] %s=%r', ui_.ui_section,

                      ui_.ui_key, ui_val)

            baseui.setconfig(ascii_bytes(ui_.ui_section), ascii_bytes(ui_.ui_key),

                             ui_val)

    # force set push_ssl requirement to False, Kallithea handles that

    baseui.setconfig(b'web', b'push_ssl', False)

    baseui.setconfig(b'web', b'allow_push', b'*')

    # prevent interactive questions for ssh password / passphrase

    ssh = baseui.config(b'ui', b'ssh', default=b'ssh')

    baseui.setconfig(b'ui', b'ssh', b'%s -oBatchMode=yes -oIdentitiesOnly=yes' % ssh)

    # push / pull hooks

    baseui.setconfig(b'hooks', b'changegroup.kallithea_log_push_action', b'python:kallithea.lib.hooks.log_push_action')

    baseui.setconfig(b'hooks', b'outgoing.kallithea_log_pull_action', b'python:kallithea.lib.hooks.log_pull_action')

    if repo_path is not None:

        hgrc_path = os.path.join(repo_path, '.hg', 'hgrc')

        if os.path.isfile(hgrc_path):

            log.debug('reading hgrc from %s', hgrc_path)

            cfg = config.config()

            cfg.read(hgrc_path)

            for section in ui_sections:

                for k, v in cfg.items(section):

                    log.debug('config from file: [%s] %s=%s', section, k, v)

                    baseui.setconfig(ascii_bytes(section), ascii_bytes(k), safe_bytes(v))

        else:

            log.debug('hgrc file is not present at %s, skipping...', hgrc_path)

    return baseui

def set_app_settings(config):

    """

    Updates app config with new settings from database

    :param config:

    """

    hgsettings = Setting.get_app_settings()

    for k, v in hgsettings.items():

        config[k] = v

def set_vcs_config(config):

    """

    Patch VCS config with some Kallithea specific stuff

    :param config: kallithea.CONFIG

    """

import datetime

import posixpath

import stat

import time

from dulwich import objects

from kallithea.lib.vcs.backends.base import BaseInMemoryChangeset

from kallithea.lib.vcs.exceptions import RepositoryError

class GitInMemoryChangeset(BaseInMemoryChangeset):

    def commit(self, message, author, parents=None, branch=None, date=None,

               **kwargs):

        """

        Performs in-memory commit (doesn't check workdir in any way) and

        returns newly created ``Changeset``. Updates repository's

        ``revisions``.

        :param message: message of the commit

        :param author: full username, i.e. "Joe Doe <joe.doe@example.com>"

        :param parents: single parent or sequence of parents from which commit

          would be derived

        :param date: ``datetime.datetime`` instance. Defaults to

          ``datetime.datetime.now()``.

        :param branch: branch name, as string. If none given, default backend's

          branch would be used.

        :raises ``CommitError``: if any error occurs while committing

        """

        self.check_integrity(parents)

        from .repository import GitRepository

        if branch is None:

            branch = GitRepository.DEFAULT_BRANCH_NAME

        repo = self.repository._repo

        object_store = repo.object_store

        ENCODING = b"UTF-8"  # TODO: should probably be kept in sync with safe_unicode/safe_bytes and vcs/conf/settings.py DEFAULT_ENCODINGS

        # Create tree and populates it with blobs

        commit_tree = self.parents[0] and repo[self.parents[0]._commit.tree] or \

            objects.Tree()

        for node in self.added + self.changed:

            # Compute subdirs if needed

            dirpath, nodename = posixpath.split(node.path)

            parent = commit_tree

            ancestors = [('', parent)]

            # Tries to dig for the deepest existing tree

            while dirnames:

                curdir = dirnames.pop(0)

                try:

                    dir_id = parent[curdir][1]

                except KeyError:

                    # put curdir back into dirnames and stops

                    dirnames.insert(0, curdir)

                    break

                else:

                    # If found, updates parent

                    parent = self.repository._repo[dir_id]

                    ancestors.append((curdir, parent))

            # Now parent is deepest existing tree and we need to create subtrees

            # for dirnames (in reverse order) [this only applies for nodes from added]

            new_trees = []

            blob = objects.Blob.from_string(node.content)

            node_path = safe_bytes(node.name)

            if dirnames:

                # If there are trees which should be created we need to build

                # them now (in reverse order)

                reversed_dirnames = list(reversed(dirnames))

                curtree = objects.Tree()

                curtree[node_path] = node.mode, blob.id

                new_trees.append(curtree)

                for dirname in reversed_dirnames[:-1]:

                    newtree = objects.Tree()

                    #newtree.add(stat.S_IFDIR, dirname, curtree.id)

                    newtree[dirname] = stat.S_IFDIR, curtree.id

                    new_trees.append(newtree)

                    curtree = newtree

                parent[reversed_dirnames[-1]] = stat.S_IFDIR, curtree.id

            else:

                parent.add(name=node_path, mode=node.mode, hexsha=blob.id)

            new_trees.append(parent)

            # Update ancestors

            for parent, tree, path in reversed([(a[1], b[1], b[0]) for a, b in

                zip(ancestors, ancestors[1:])]

            ):

                parent[path] = stat.S_IFDIR, tree.id

                object_store.add_object(tree)

            object_store.add_object(blob)

            for tree in new_trees:

                object_store.add_object(tree)

        for node in self.removed:

            paths = node.path.split(b'/')

            tree = commit_tree

            trees = [tree]

            # Traverse deep into the forest...