import logging

import re

from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.graphmod import graph_data

from kallithea.lib.utils2 import ascii_bytes, ascii_str, safe_int, safe_str

from kallithea.model.db import Repository

        elif alias == 'hg':

            # case two independent repos

            if org_repo != other_repo:

                                                       other_repo.path,

                                                       org_repo.path)

                # all ancestors of other_rev will be in other_repo and

import traceback

import formencode

from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from kallithea.lib.page import Page

from kallithea.lib.utils2 import ascii_bytes, safe_bytes, safe_int, safe_str

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, EmptyRepositoryError

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.model.comment import ChangesetCommentsModel

from kallithea.model.db import ChangesetStatus, PullRequest, PullRequestReviewer, Repository, User

                            # Note: org_scm_instance.path must come first so all

                            # valid revision numbers are 100% org_scm compatible

                            # - both for avail_revs and for revset results

                                                                   org_scm_instance.path,

                                                                   other_scm_instance.path)

                        else:

import os

import time

from kallithea.lib import helpers as h

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.utils import action_logger, make_ui, setup_cache_regions

from kallithea.lib.utils2 import ascii_str, get_hook_environment, safe_str, safe_unicode

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

from kallithea.model.db import Repository, User

    Note: This hook is not only logging, but also the side effect invalidating

    cahes! The function should perhaps be renamed.

    """

    process_pushed_raw_ids(revs)

    return 0

import os

import urllib

from kallithea.lib.base import BaseVCSController, get_path_info

from kallithea.lib.utils import make_ui

from kallithea.lib.utils2 import safe_str, safe_unicode

log = logging.getLogger(__name__)

        str_repo_name = safe_str(parsed_request.repo_name)

        repo_path = os.path.join(safe_str(self.basepath), str_repo_name)

        baseui = make_ui(repo_path=repo_path)

        def wrapper_app(environ, start_response):

            return hgweb_app(environ, start_response)

        return wrapper_app

from distutils.version import StrictVersion

import beaker

from beaker.cache import _cache_decorate

from tg.i18n import ugettext as _

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

from kallithea.model import meta

from kallithea.model.db import RepoGroup, Repository, Setting, Ui, User, UserGroup, UserLog

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

    augmenting with content from a hgrc file.

    """

    # clean the baseui object

    sa = meta.Session()

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

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

        if os.path.isfile(hgrc_path):

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

            cfg.read(hgrc_path)

            for section in ui_sections:

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

import urllib2

from collections import OrderedDict

from dulwich.config import ConfigFile

from dulwich.objects import Tag

from dulwich.repo import NotGitRepository, Repo

from kallithea.lib.vcs.exceptions import (

    BranchDoesNotExistError, ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError, TagAlreadyExistError, TagDoesNotExistError)

from kallithea.lib.vcs.utils import ascii_str, date_fromtimestamp, makedate, safe_str, safe_unicode

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

from kallithea.lib.vcs.utils.paths import abspath, get_user_home

            url = url[url.find('+') + 1:]

        handlers = []

        test_uri, authinfo = url_obj.authinfo()

        if not test_uri.endswith('info/refs'):

            test_uri = test_uri.rstrip('/') + '/info/refs'

            passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()

            passmgr.add_password(*authinfo)

        o = urllib2.build_opener(*handlers)

        o.addheaders = [('User-Agent', 'git/1.7.8.0')]  # fake some git

    :copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.

"""

from .changeset import MercurialChangeset

from .inmemory import MercurialInMemoryChangeset

from .repository import MercurialRepository

    'MercurialRepository', 'MercurialChangeset',

    'MercurialInMemoryChangeset', 'MercurialWorkdir',

]

import os

import posixpath

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

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, ChangesetError, ImproperArchiveTypeError, NodeDoesNotExistError, VCSError

from kallithea.lib.vcs.nodes import (

    AddedFileNodesGenerator, ChangedFileNodesGenerator, DirNode, FileNode, NodeKind, RemovedFileNodesGenerator, RootNode, SubModuleNode)

from kallithea.lib.vcs.utils import ascii_bytes, ascii_str, date_fromtimestamp, safe_str, safe_unicode

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

from kallithea.lib.vcs.utils.paths import get_dirs_for_path

    @LazyProperty

    def successors(self):

        if successors:

            # flatten the list here handles both divergent (len > 1)

            # and the usual case (len = 1)

        return successors

    @LazyProperty

    def predecessors(self):

    @LazyProperty

    def bookmarks(self):

        cnt = 0

        for cs in reversed([x for x in fctx.filelog()]):

            cnt += 1

            if limit is not None and cnt == limit:

                break

        elif prefix.strip() == '':

            raise VCSError("Prefix cannot be empty")

                         kind, prefix=prefix, subrepos=subrepos)

    def get_nodes(self, path):

import datetime

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

from kallithea.lib.vcs.exceptions import RepositoryError

from kallithea.lib.vcs.utils import ascii_str, safe_bytes

class MercurialInMemoryChangeset(BaseInMemoryChangeset):

            # check if this path is added

            for node in self.added:

                if node.path == path:

                        data=node.content,

                        islink=False,

                        isexec=node.is_executable,

            # or changed

            for node in self.changed:

                if node.path == path:

                        data=node.content,

                        islink=False,

                        isexec=node.is_executable,

        if date and isinstance(date, datetime.datetime):

            date = date.strftime('%a, %d %b %Y %H:%M:%S')

            parents=parents,

            text=b'',

            files=self.get_paths(),

        # Update vcs repository object & recreate mercurial _repo

        # new_ctx = self.repository._repo[node]

        # new_tip = ascii_str(self.repository.get_changeset(new_ctx.hex()))

        self._repo = self.repository._get_repo(create=False)

        self.repository.branches = self.repository._get_branches()

        tip = self.repository.get_changeset()

import urllib2

from collections import OrderedDict

from kallithea.lib.vcs.backends.base import BaseRepository, CollectionGenerator

from kallithea.lib.vcs.exceptions import (

    BranchDoesNotExistError, ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError, TagAlreadyExistError, TagDoesNotExistError, VCSError)

from kallithea.lib.vcs.utils import ascii_str, author_email, author_name, date_fromtimestamp, makedate, safe_bytes, safe_str, safe_unicode

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

from kallithea.lib.vcs.utils.paths import abspath

                           type(repo_path))

        self.path = abspath(repo_path)

        # We've set path and ui, now we can set _repo itself

        self._repo = self._get_repo(create, src_url, update_after_clone)

        for bn, _heads, node, isclosed in sorted(self._repo.branchmap().iterbranches()):

            if isclosed:

                if closed:

            else:

                if normal:

        return bt

    @LazyProperty

            return {}

        return OrderedDict(sorted(

            reverse=True,

            key=lambda x: x[0],  # sort by name

        ))

            date = datetime.datetime.now().strftime('%a, %d %b %Y %H:%M:%S')

        try:

            raise RepositoryError(e.message)

        # Reinitialize tags

        local = False

        try:

            self.tags = self._get_tags()

            raise RepositoryError(e.message)

    @LazyProperty

            self.get_changeset(rev1)

        self.get_changeset(rev2)

        if path:

        else:

            file_filter = None

                                        showfunc=True,

                                        ignorews=ignore_whitespace,

                                        context=context)))

        if url.startswith(b'ssh:'):

            # in case of invalid uri or authentication issues, sshpeer will

            # throw an exception.

            return True

        url_prefix = None

            url_prefix, url = url.split(b'+', 1)

        handlers = []

        test_uri, authinfo = url_obj.authinfo()

        url_obj.passwd = b'*****'

        cleaned_uri = str(url_obj)

            passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()

            passmgr.add_password(*authinfo)

        o = urllib2.build_opener(*handlers)

        o.addheaders = [('Content-Type', 'application/mercurial-0.1'),

        if not url_prefix: # skip svn+http://... (and git+... too)

            # now check if it's a proper hg repo

            try:

            except Exception as e:

                raise urllib2.URLError(

                    "url [%s] does not look like an hg repo org_exc: %s"

                if not update_after_clone:

                    opts.update({'noupdate': True})

                MercurialRepository._check_url(url, self.baseui)

                # Don't try to create if we've already cloned repo

                create = False

            if create:

                msg = "Cannot create repository at %s. Original error was %s" \

                    % (self.path, err)

    @LazyProperty

    def contact(self):

                            or b'Unknown')

    @LazyProperty

        try:

            if isinstance(revision, int):

                return ascii_str(self._repo[revision].hex())

            msg = ("Revision %s does not exist for %s" % (revision, self))

            raise ChangesetDoesNotExistError(msg)

        except (LookupError, ):

        except LookupError:

            msg = ("Ambiguous identifier %s:%s for %s" % (ref_type, ref_name, self.name))

            raise ChangesetDoesNotExistError(msg)

            msg = ("Revision %s:%s does not exist for %s" % (ref_type, ref_name, self.name))

            raise ChangesetDoesNotExistError(msg)

        if revs:

                revspec = b'all()'

            if max_revisions:

                revspec = b'limit(%s, %d)' % (revspec, max_revisions)

        else:

            revisions = self.revisions

        Tries to pull changes from external location.

        """

        url = self._get_url(url)

        try:

            # Propagate error but with vcs's type

            raise RepositoryError(str(err))

        config = self._repo.ui

        if config_file:

            for path in config_file:

                config.readconfig(path)

        return config.config(section, name)

import logging

from kallithea.lib.utils import make_ui

from kallithea.lib.vcs.backends.ssh import BaseSshHandler

            baseui.setconfig(b'hooks', b'pretxnopen._ssh_reject', b'python:kallithea.lib.hooks.rejectpush')

            baseui.setconfig(b'hooks', b'prepushkey._ssh_reject', b'python:kallithea.lib.hooks.rejectpush')

        log.debug("Starting Mercurial sshserver for %s", self.db_repo.repo_full_path)

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

from kallithea.lib.vcs.exceptions import BranchDoesNotExistError

from kallithea.lib.vcs.utils import ascii_bytes, ascii_str

class MercurialWorkdir(BaseWorkdir):

            raise BranchDoesNotExistError

        raw_id = self.repository.branches[branch]

Mercurial libs compatibility

"""

# workaround for 3.3 94ac64bcf6fe and not calling largefiles reposetup correctly, and test_archival failing

# 3.5 7699d3212994 added the invariant that repo.lfstatus must exist before hitting overridearchive

        assert node.kind == NodeKind.FILE

        assert node.content == readme

    def test_get_diff_does_not_sanitize_zero_context(self, mock_diffopts):

        zero_context = 0

        mock_diffopts.assert_called_once_with(git=True, showfunc=True, ignorews=False, context=zero_context)

    def test_get_diff_sanitizes_negative_context(self, mock_diffopts):

        negative_context = -10

        zero_context = 0