from kallithea.lib.middleware.simplehg import SimpleHg

from kallithea.lib.middleware.wrapper import RequestWrapper

from kallithea.lib.utils import check_git_version, load_rcextensions, make_ui, set_app_settings, set_indexer_config, set_vcs_config

log = logging.getLogger(__name__)

    load_rcextensions(root_path=config['here'])

    config['base_path'] = repos_path

    set_app_settings(config)

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseController, jsonify, render

from kallithea.model.db import RepoGroup, Repository, User, UserGroup

from kallithea.model.repo import RepoModel

from kallithea.model.scm import UserGroupList

        if _branches:

            res.append({

                'text': _('Branch'),

            })

        _closed_branches = repo.closed_branches.items()

        if _closed_branches:

            res.append({

                'text': _('Closed Branches'),

            })

        _tags = repo.tags.items()

        if _tags:

            res.append({

                'text': _('Tag'),

            })

        _bookmarks = repo.bookmarks.items()

        if _bookmarks:

            res.append({

                'text': _('Bookmark'),

            })

        data = {

            'more': False,

        (authmeth, auth) = authorization.split(' ', 1)

        if 'basic' != authmeth.lower():

            return self.build_authentication(environ)

        _parts = auth.split(':', 1)

        if len(_parts) == 2:

            username, password = _parts

        match = _hg_header_re.match(diff_chunk)

    if match is None:

        raise Exception('diff not recognized as valid %s diff' % vcs)

    rest = diff_chunk[match.end():]

    if rest and _header_next_check.match(rest):

    diff_lines = (_escaper(m.group(0)) for m in re.finditer(br'.*\n|.+$', rest)) # don't split on \r as str.splitlines do

    return meta_info, diff_lines

from kallithea.lib import helpers as h

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.utils import action_logger, make_ui

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

from kallithea.model.db import Repository, User

def repo_size(ui, repo, hooktype=None, **kwargs):

    """Show size of Mercurial repository, to be called after push."""

    last_cs = repo[len(repo) - 1]

import kallithea.config.conf

from kallithea.lib.exceptions import HgsubversionImportError

from kallithea.lib.vcs.backends.git.repository import GitRepository

from kallithea.lib.vcs.backends.hg.repository import MercurialRepository

from kallithea.lib.vcs.conf import settings

        return None

    if stderr:

    if not stdout:

        log.warning('No working git executable found - check "git_path" in the ini file.')

        return None

    m = re.search(r"\d+.\d+.\d+", output)

    if m:

        ver = StrictVersion(m.group(0))

    @LazyProperty

    def branches(self):

        heads = self.repository._heads(reverse=True)

    def _fix_path(self, path):

        """

            # initially extract things from root dir

            for item, stat, id in tree.items():

                if curdir:

                self._paths[name] = id

                self._stat_modes[name] = stat

                    curdir = dir

                dir_id = None

                for item, stat, id in tree.items():

                        dir_id = id

                if dir_id:

                    # Update tree

                # cache all items from the given traversed tree

                for item, stat, id in tree.items():

                    if curdir:

                    self._paths[name] = id

                    self._stat_modes[name] = stat

            if path not in self._paths:

        filenodes = []

        als = self.repository.alias

        for name, stat, id in tree.items():

            if path != '':

            if objects.S_ISGITLINK(stat):

                root_tree = self.repository._repo[self._tree_id]

                cf = ConfigFile.from_file(BytesIO(self.repository._repo.get_object(root_tree[b'.gitmodules'][1]).data))

            changes = _r.object_store.tree_changes(oid, _r[self._commit.id].tree)

            for (oldpath, newpath), (_, _), (_, _) in changes:

                if newpath and oldpath:

                elif newpath and not oldpath:

                elif not newpath and oldpath:

        return added, modified, deleted

    def _get_paths_for_status(self, status):

        if not self.revisions:

            return {}

        sortkey = lambda ctx: ctx[0]

                     for key, (sha, type_) in self._parsed_refs.items() if type_ == b'H']

        return OrderedDict(sorted(_branches, key=sortkey, reverse=False))

            return {}

        sortkey = lambda ctx: ctx[0]

                 for key, (sha, type_) in self._parsed_refs.items() if type_ == b'T']

        return OrderedDict(sorted(_tags, key=sortkey, reverse=True))

        if name not in self.tags:

            raise TagDoesNotExistError("Tag %s does not exist" % name)

        # self._repo.refs is a DiskRefsContainer, and .path gives the full absolute path of '.git'

        try:

            os.remove(tagpath)

            self._parsed_refs = self._get_parsed_refs()

        for config in gen_configs():

            try:

            except KeyError:

                continue

        return None

    def get_user_name(self, config_file=None):

import re

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

from kallithea.lib.vcs.exceptions import BranchDoesNotExistError, RepositoryError

    def get_branch(self):

        headpath = self.repository._repo.refs.refpath(b'HEAD')

        try:

            match = re.match(r'^ref: refs/heads/(?P<branch>.+)\n$', content)

            if match:

                return match.groupdict()['branch']

    @LazyProperty

    def _file_paths(self):

    @LazyProperty

    def _dir_paths(self):

        """

        Returns list of added ``FileNode`` objects.

        """

    @property

    def changed(self):

        """

        Returns list of modified ``FileNode`` objects.

        """

    @property

    def removed(self):

        """

        Returns list of removed ``FileNode`` objects.

        """

    @LazyProperty

    def extra(self):

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

from kallithea.lib.vcs.exceptions import RepositoryError

class MercurialInMemoryChangeset(BaseInMemoryChangeset):

            Callback from Mercurial, returning ctx to commit for the given

            path.

            """

            # check if this path is removed

            if path in (node.path for node in self.removed):

            if name in allowed or self._repo.ui.configbool(b"web",

                                                           b"allow" + name,

                                                           untrusted=True):

    def _get_url(self, url):

        """

            config = mercurial.ui.ui()

            for path in config_file:

                config.readconfig(safe_bytes(path))

    def get_user_name(self, config_file=None):

        """

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

from kallithea.lib.vcs.exceptions import BranchDoesNotExistError

class MercurialWorkdir(BaseWorkdir):

    def get_branch(self):

    def get_changeset(self):

        wk_dir_id = ascii_str(self.repository._repo[None].parents()[0].hex())