import kallithea

from kallithea.lib.utils2 import ascii_bytes

log = logging.getLogger(__name__)

        if git_command in ['git-receive-pack']:

            # updating refs manually after each push.

            # Needed for pre-1.7.0.4 git clients using regular HTTP mode.

            repo = get_repo(self.content_path)

            if repo:

                update_server_info(repo._repo)

from tg.i18n import ugettext as _

from webob.exc import HTTPFound

from kallithea.lib import webutils

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.base import BaseController, render

        defaults = db.Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        c.ini = kallithea.CONFIG

        return htmlfill.render(

        defaults = db.Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        c.ini = kallithea.CONFIG

        server_info = db.Setting.get_server_info()

        for key, val in server_info.items():

from kallithea.lib.auth import AuthUser, HasPermissionAnyDecorator

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

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.webutils import url

from kallithea.model import db, meta

from kallithea.model.forms import LoginForm, PasswordResetConfirmationForm, PasswordResetRequestForm, RegisterForm

                form_result['active'] = c.auto_active

                if c.captcha_active:

                    response = submit(request.POST.get('g-recaptcha-response'),

                                      private_key=captcha_private_key,

                                      remoteip=request.ip_addr)

            try:

                form_result = password_reset_form.to_python(dict(request.POST))

                if c.captcha_active:

                    response = submit(request.POST.get('g-recaptcha-response'),

                                      private_key=captcha_private_key,

                                      remoteip=request.ip_addr)

import routes

import kallithea

from kallithea.lib.utils2 import safe_str

    rmap.minimization = False

    rmap.explicit = False

    def check_repo(environ, match_dict):

        """

        Check for valid repository for proper 404 handling.

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 _

import kallithea

    and '_' changed to '-' and be used as attributes on the div. The default

    class is 'gravatar'.

    """

    if not c.visual.use_gravatar:

        return ''

    if 'div_class' not in div_attributes:

    empty then we fallback to using an icon.

    """

    if not c.visual.use_gravatar:

        return ''

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

    if not c.visual.use_gravatar:

        return ""

import time

import mercurial.scmutil

import kallithea

from kallithea.lib import webutils

    they thus need enough info to be able to create an app environment and

    connect to the database.

    """

    import kallithea.config.application

    extras = get_hook_environment()

from dateutil import relativedelta

from sqlalchemy.engine import url as sa_url

from sqlalchemy.exc import ArgumentError

from tg.i18n import ugettext as _

from tg.i18n import ungettext

from tg.support.converters import asbool, aslist

    Gets kallithea user from threadlocal tmpl_context variable if it's

    defined, else returns None.

    """

    try:

        return getattr(tmpl_context, 'authuser', None)

    except TypeError:  # No object (name: context) has been registered for this thread

from kallithea.lib.vcs.exceptions import RepositoryError

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

class GitInMemoryChangeset(BaseInMemoryChangeset):

        """

        self.check_integrity(parents)

        if branch is None:

        repo = self.repository._repo

        object_store = repo.object_store

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

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

SHA_PATTERN = re.compile(r'^([0-9a-fA-F]{12}|[0-9a-fA-F]{40})$')

        Returns ``GitChangeset`` object representing commit from git repository

        at the given revision or head (most recent commit) if None given.

        """

            return revision

    def get_changesets(self, start=None, end=None, start_date=None,

           end_date=None, branch_name=None, reverse=False, max_revisions=None):

        """

        Returns ``GitInMemoryChangeset`` object for this repository.

        """

    def clone(self, url, update_after_clone=True, bare=False):

        """

        """

        Returns ``Workdir`` instance for this repository.

        """

    def get_config_value(self, section, name, config_file=None):

        """

from kallithea.lib.vcs.exceptions import RepositoryError

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

class MercurialInMemoryChangeset(BaseInMemoryChangeset):

        if not isinstance(author, str):

            raise RepositoryError('author must be a str - got %r' % type(author))

        if branch is None:

        kwargs[b'branch'] = safe_bytes(branch)

        def filectxfn(_repo, memctx, bytes_path):

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

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

log = logging.getLogger(__name__)

    @LazyProperty

    def in_memory_changeset(self):

    @LazyProperty

    def description(self):

        Returns ``MercurialChangeset`` object representing repository's

        changeset at the given ``revision``.

        """

    def get_changesets(self, start=None, end=None, start_date=None,

                       end_date=None, branch_name=None, reverse=False, max_revisions=None):

        """

        Returns ``Workdir`` instance for this repository.

        """

    def get_config_value(self, section, name=None, config_file=None):

        """

from pygments.formatters import TerminalFormatter

from pygments.lexers import ClassNotFound, guess_lexer_for_filename

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

from kallithea.lib.vcs.utils import safe_str

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

    :raises VCSError: if given ``path`` is not a directory

    """

    if hasattr(path, '__call__'):

        path = path()

    if not os.path.isdir(path):

        # We still need to check if it's not bare repository as

        # bare repos don't have working directories

        try:

            result.append(key)

            continue

        except RepositoryError:

import ipaddr

import sqlalchemy

from sqlalchemy import Boolean, Column, DateTime, Float, ForeignKey, Index, Integer, LargeBinary, String, Unicode, UnicodeText, UniqueConstraint

from sqlalchemy.ext.hybrid import hybrid_property

from sqlalchemy.orm import class_mapper, joinedload, relationship, validates

from kallithea.lib.exceptions import DefaultUserException

from kallithea.lib.utils2 import asbool, ascii_bytes, aslist, get_changeset_safe, get_clone_url, remove_prefix, safe_bytes, safe_int, safe_str, urlreadable

from kallithea.lib.vcs import get_backend, get_repo

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

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

from kallithea.model import meta

    def clone_uri_hidden(self):

        clone_uri = self.clone_uri

        if clone_uri:

            url_obj = urlobject.URLObject(self.clone_uri)

            if url_obj.password:

                clone_uri = url_obj.with_password('*****')

        :param cs_cache:

        """

        if cs_cache is None:

            cs_cache = EmptyChangeset()

            # use no-cache version here

from kallithea.lib import webutils

from kallithea.lib.exceptions import DefaultUserException, UserOwnsReposException

from kallithea.lib.utils2 import generate_api_key, get_current_authuser

log = logging.getLogger(__name__)

        :param user:

        :param email:

        """

        form = forms.UserExtraEmailForm()()

        data = form.to_python(dict(email=email))

        user = db.User.guess_instance(user)

        :param user:

        :param ip:

        """

        form = forms.UserExtraIpForm()()

        data = form.to_python(dict(ip=ip))

        user = db.User.guess_instance(user)

from tg.i18n import ugettext as _

import kallithea

from kallithea.lib.compat import OrderedSet

from kallithea.lib.exceptions import InvalidCloneUriException, LdapImportError

from kallithea.lib.utils import is_valid_repo_uri

            gr_name = gr.group_name if gr is not None else None # None means ROOT location

            # create repositories with write permission on group is set to true

                                            'can write into group validator')

                                            'can write into group validator')

            forbidden = not (group_admin or group_write)

            gid = (old_data['repo_group'].get('group_id')

                   if (old_data and 'repo_group' in old_data) else None)

            value_changed = gid != value

                return

            forbidden_in_root = gr is None and not can_create_in_root

            if forbidden_in_root or forbidden:

                msg = self.message('permission_denied', state)

                raise formencode.Invalid(msg, value, state,

import os

import random

import re

import mock

import pytest

        assert response.status == '200 OK'

    def test_api_args_different_args(self):

        expected = {

            'ascii_letters': string.ascii_letters,

            'ws': string.whitespace,

import time

import pytest

from webtest import TestApp

from kallithea.lib.utils2 import ascii_str

    effect immediately.

    Note: Any use of this function is probably a workaround - it should be

    replaced with a more specific cache invalidation in code or test."""

    for cache in cache_managers.values():

        cache.clear()

from kallithea.model.scm import ScmModel

from kallithea.model.user import UserModel

from kallithea.tests.base import TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS, TEST_USER_REGULAR_LOGIN, TESTS_TMP_PATH, invalidate_all_caches

def pytest_configure():

    inifile.create(test_ini_file, None, ini_settings)

    context = loadwsgi.loadcontext(loadwsgi.APP, 'config:%s' % test_ini_file)

    # set KALLITHEA_NO_TMP_PATH=1 to disable re-creating the database and test repos

    if not int(os.environ.get('KALLITHEA_NO_TMP_PATH', 0)):

from kallithea.lib.auth import AuthUser

from kallithea.lib.db_manage import DbManage

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

from kallithea.model import db, meta

from kallithea.model.changeset_status import ChangesetStatusModel

from kallithea.tests.base import (GIT_REPO, HG_REPO, IP_ADDR, TEST_USER_ADMIN_EMAIL, TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS, TEST_USER_REGULAR2_EMAIL,

                                  TEST_USER_REGULAR2_LOGIN, TEST_USER_REGULAR2_PASS, TEST_USER_REGULAR_EMAIL, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS,

                                  TESTS_TMP_PATH, invalidate_all_caches)

log = logging.getLogger(__name__)

    tar.close()

    # LOAD VCS test stuff

    setup_package()

    Makes default test index

    """

    index_location = os.path.join(config['index_dir'])

    if not os.path.exists(index_location):

        os.makedirs(index_location)

from tg.util.webtest import test_context

from kallithea.lib import webutils

from kallithea.model.user import UserModel

from kallithea.tests import base

from kallithea.tests.fixture import Fixture

                                            _session_csrf_secret_token=self.session_csrf_secret_token()))

        response.mustcontain('An email address must contain a single @')

        with test_context(self.app):

            msg = validators.ValidUsername(edit=False, old_data={}) \

                    ._messages['username_exists']

import datetime

import hashlib

import mock

from tg.util.webtest import test_context

import kallithea.lib.helpers as h

from kallithea.lib import webutils

from kallithea.model import db

from kallithea.tests import base

        (dict(years= -3, months= -2), '3 years and 2 months ago'),

    ])

    def test_age(self, age_args, expected):

        from kallithea.lib.utils2 import age

        with test_context(self.app):

            n = datetime.datetime(year=2012, month=5, day=17)

        (dict(years= -4, months= -8), '5 years ago'),

    ])

    def test_age_short(self, age_args, expected):

        from kallithea.lib.utils2 import age

        with test_context(self.app):

            n = datetime.datetime(year=2012, month=5, day=17)

        (dict(years=1, months=1), 'in 1 year and 1 month')

    ])

    def test_age_in_future(self, age_args, expected):

        from kallithea.lib.utils2 import age

        with test_context(self.app):

            n = datetime.datetime(year=2012, month=5, day=17)

        with mock.patch('kallithea.lib.webutils.url.current', lambda *a, **b: 'https://example.com'):

            fake = fake_tmpl_context(_url='http://example.com/{email}')

                    grav = h.gravatar_url(email_address='test@example.com', size=24)

                    assert grav == 'http://example.com/test@example.com'

            fake = fake_tmpl_context(_url='http://example.com/{email}')

                grav = h.gravatar_url(email_address='test@example.com', size=24)

                assert grav == 'http://example.com/test@example.com'

            fake = fake_tmpl_context(_url='http://example.com/{md5email}')

                em = 'test@example.com'

                grav = h.gravatar_url(email_address=em, size=24)

                assert grav == 'http://example.com/%s' % (_md5(em))

            fake = fake_tmpl_context(_url='http://example.com/{md5email}/{size}')

                em = 'test@example.com'

                grav = h.gravatar_url(email_address=em, size=24)

                assert grav == 'http://example.com/%s/%s' % (_md5(em), 24)

            fake = fake_tmpl_context(_url='{scheme}://{netloc}/{md5email}/{size}')

                em = 'test@example.com'

                grav = h.gravatar_url(email_address=em, size=24)

                assert grav == 'https://example.com/%s/%s' % (_md5(em), 24)

        ('https://proxy1.example.com/{user}/{repo}', 'group/repo1', 'username', '', 'https://proxy1.example.com/username/group/repo1'),

    ])

    def test_clone_url_generator(self, clone_uri_tmpl, repo_name, username, prefix, expected):

        clone_url = get_clone_url(clone_uri_tmpl=clone_uri_tmpl, prefix_url='http://vps1:8000' + prefix,

                                  repo_name=repo_name, repo_id=23, username=username)

        assert clone_url == expected

        :param text:

        """

        # quickly change expected url[] into a link

        url_pattern = re.compile(r'(?:url\[)(.+?)(?:\])')

    ])

    def test_canonical_url(self, canonical, test, expected):

        # setup url(), used by canonical_url

        m = routes.Mapper()

        m.connect('about', '/about-page')

        url = routes.URLGenerator(m, {'HTTP_HOST': 'http_host.example.org'})

        ('http://www.example.org/kallithea/repos/', 'www.example.org'),

    ])

    def test_canonical_hostname(self, canonical, expected):

        # setup url(), used by canonical_hostname

        m = routes.Mapper()

        url = routes.URLGenerator(m, {'HTTP_HOST': 'http_host.example.org'})

import pytest

from kallithea.model import db

from kallithea.tests import base

    def graphmod(self, repo):

        """ Simple test for running the graph_data function for profiling/testing performance. """

        dbr = db.Repository.get_by_repo_name(repo)

        scm_inst = dbr.scm_instance

        collection = scm_inst.get_changesets(start=0, end=None, branch_name=None)

from kallithea.lib.auth import get_crypt_password

from kallithea.model import db, meta

from kallithea.model.base import init_model

from kallithea.tests.base import HG_REPO, TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS

def create_test_repo(force=True):

    print('creating test repo')

    sa = get_session()

    user = sa.query(db.User).filter(db.User.username == USER).scalar()

import datetime

import pytest

        assert self.repo == self.repo

    def test_repo_equality_broken_object(self):

        _repo = copy.copy(self.repo)

        delattr(_repo, 'path')

        assert self.repo != _repo

import pytest

from kallithea.lib.vcs.nodes import FileNode

from kallithea.tests.vcs.base import _BackendTestMixin

        assert self.repo.workdir.get_changeset() == old_head

    def test_checkout_branch(self):

        # first, 'foobranch' does not exist.

        with pytest.raises(BranchDoesNotExistError):

            self.repo.workdir.checkout_branch(branch='foobranch')

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

import os

import platform

import sys

import setuptools

def _get_meta_var(name, data, callback_handler=None):

    matches = re.compile(r'(?:%s)\s*=\s*(.*)' % name).search(data)

    if matches:

        s = eval(matches.groups()[0])