from kallithea.lib.middleware.https_fixup import HttpsFixup

from kallithea.lib.middleware.permanent_repo_url import PermanentRepoUrl

from kallithea.lib.middleware.simplegit import SimpleGit

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__)

class KallitheaAppConfig(AppConfig):

    kallithea.CELERY_ON = str2bool(config.get('use_celery'))

    kallithea.CELERY_EAGER = str2bool(config.get('celery.always.eager'))

    kallithea.CONFIG = config

    load_rcextensions(root_path=config['here'])

    config['base_path'] = repos_path

    set_app_settings(config)

    instance_id = kallithea.CONFIG.get('instance_id', '*')

    if instance_id == '*':

        instance_id = '%s-%s' % (platform.uname()[1], os.getpid())

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest

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

log = logging.getLogger(__name__)

        repo = Repository.get_by_repo_name(repo_name).scm_instance

        res = []

        _branches = repo.branches.items()

        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,

            'results': res

        }

        return data

        authorization = paste.httpheaders.AUTHORIZATION(environ)

        if not authorization:

            return self.build_authentication(environ)

        (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

            if self.authfunc(username, password, environ) is not None:

                return username

        return self.build_authentication(environ)

    if vcs == 'git':

        match = _git_header_re.match(diff_chunk)

    elif vcs == 'hg':

        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

_chunk_re = re.compile(r'^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)')

_newline_marker = re.compile(r'^\\ No newline at end of file')

import mercurial.scmutil

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 _get_scm_size(alias, root_path):

    if not alias.startswith('.'):

    return size_scm_f, size_root_f, size_total_f

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

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

    last_cs = repo[len(repo) - 1]

    msg = ('Repository size .hg: %s Checkout: %s Total: %s\n'

           'Last revision is now r%s:%s\n') % (

        size_hg_f, size_root_f, size_total_f, last_cs.rev(), ascii_str(last_cs.hex())[:12]

import mercurial.config

import mercurial.ui

from tg.i18n import ugettext as _

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

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

from kallithea.lib.vcs.utils.fakemod import create_module

from kallithea.lib.vcs.utils.helpers import get_scm

    except RepositoryError as e:

        # message will already have been logged as error

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

        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))

        log.debug('Git executable: "%s", version %s (parsed from: "%s")',

                  settings.GIT_EXECUTABLE_PATH, ver, output)

        if ver < git_req_ver:

        if ref:

            return safe_str(ref)

    @LazyProperty

    def branches(self):

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

    def _fix_path(self, path):

        """

        Paths are stored without trailing slash so we need to get rid off it if

        needed.

        """

            splitted = path.split('/')

            dirs, name = splitted[:-1], splitted[-1]

            curdir = ''

            # initially extract things from root dir

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

                if curdir:

                self._paths[name] = id

                self._stat_modes[name] = stat

            for dir in dirs:

                if curdir:

                    curdir = '/'.join((curdir, dir))

                else:

                    curdir = dir

                dir_id = None

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

                        dir_id = id

                if dir_id:

                    # Update tree

                    tree = self.repository._repo[dir_id]

                    if not isinstance(tree, objects.Tree):

                        raise ChangesetError('%s is not a directory' % curdir)

                else:

                    raise ChangesetError('%s have not been found' % curdir)

                # 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:

                raise NodeDoesNotExistError("There is no file nor directory "

                    "at the given path '%s' at revision %s"

                    % (path, self.short_id))

        id = self._get_id_for_path(path)

        tree = self.repository._repo[id]

        dirnodes = []

        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))

                url = ascii_str(cf.get(('submodule', obj_path), 'url'))

                dirnodes.append(SubModuleNode(obj_path, url=url, changeset=ascii_str(id),

                                              alias=als))

                oid = None

            else:

                oid = _r[parent._commit.id].tree

            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):

        """

        Returns sorted list of paths for given ``status``.

    @property

    def branches(self):

        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))

    @LazyProperty

    def closed_branches(self):

        return {}

    def _get_tags(self):

        if not self.revisions:

            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))

    def tag(self, name, user, revision=None, message=None, date=None,

            **kwargs):

        """

        :raises TagDoesNotExistError: if tag with given name does not exists

        """

        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()

            self.tags = self._get_tags()

        except OSError as e:

            raise RepositoryError(e.strerror)

                    yield ConfigFile.from_path(path)

                except (IOError, OSError, ValueError):

                    continue

        for config in gen_configs():

            try:

            except KeyError:

                continue

        return None

    def get_user_name(self, config_file=None):

        """

        Returns user's name from global configuration file.

import re

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

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

class GitWorkdir(BaseWorkdir):

    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']

            else:

                raise RepositoryError("Couldn't compute workdir's branch")

        except IOError:

        """

        return self.repository._repo.status(self._ctx.p1().node(),

                                            self._ctx.node())

    @LazyProperty

    def _file_paths(self):

    @LazyProperty

    def _dir_paths(self):

        p = list(set(get_dirs_for_path(*self._file_paths)))

        p.insert(0, '')

        return p

    @property

    def added(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):

        return self._ctx.extra()

import mercurial.context

import mercurial.node

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

from kallithea.lib.vcs.exceptions import RepositoryError

class MercurialInMemoryChangeset(BaseInMemoryChangeset):

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

               **kwargs):

        def filectxfn(_repo, memctx, bytes_path):

            """

            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):

                return None

            # check if this path is added

        allowed = self.baseui.configlist(b"web", b"allow_archive",

                                         untrusted=True)

        for name, ext in [(b'zip', '.zip'), (b'gz', '.tar.gz'), (b'bz2', '.tar.bz2')]:

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

                                                           b"allow" + name,

                                                           untrusted=True):

    def _get_url(self, url):

        """

        Returns normalized url. If schema is not given, fall back to

        filesystem (``file:///``) schema.

        """

        config = self._repo.ui

        if config_file:

            config = mercurial.ui.ui()

            for path in config_file:

                config.readconfig(safe_bytes(path))

    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

import mercurial.merge

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())

        return self.repository.get_changeset(wk_dir_id)

    def checkout_branch(self, branch=None):