#########################################################

# SQLITE [default]

# POSTGRESQL

# MySQL

# see sqlalchemy docs for others

################################

### ALEMBIC CONFIGURATION   ####

If using MySQL, please consult the documentation for the ``mysqldump``

utility.

database type, settings, location, etc.

kallithea

~~~~~~~~~

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

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

CELERY_ON = False

CELERY_EAGER = False

CONFIG = {}

# Linked module for extensions

# [alembic] sqlalchemy.url.

database_url = (

    config.get_main_option('sqlalchemy.url') or

)

# Configure default logging for Alembic. (This can be overriden by the

%if database_engine == 'sqlite':

# SQLITE [default]

%elif database_engine == 'postgres':

# POSTGRESQL

%elif database_engine == 'mysql':

# MySQL

%endif

# see sqlalchemy docs for others

<%text>################################</%text>

<%text>### ALEMBIC CONFIGURATION   ####</%text>

#########################################################

# SQLITE [default]

# POSTGRESQL

# MySQL

# see sqlalchemy docs for others

################################

### ALEMBIC CONFIGURATION   ####

            test_index = not int(os.environ.get('KALLITHEA_WHOOSH_TEST_DISABLE', 0))

        if os.environ.get('TEST_DB'):

            # swap config if we pass enviroment variable

        from kallithea.lib.utils import create_test_env, create_test_index

        from kallithea.tests import TESTS_TMP_PATH

    # MULTIPLE DB configs

    # Setup the SQLAlchemy database engine

    set_available_permissions(config)

    repos_path = make_ui('db').configitems('paths')[0][1]

refer to the routes manual at http://routes.groovie.org/docs/

"""

from routes import Mapper

# prefix for non repository related links needs to be prefixed with `/`

                 conditions=dict(function=check_repo))

    return rmap

import logging

from sqlalchemy.orm import joinedload

from whoosh.qparser.default import QueryParser

from whoosh.qparser.dateparse import DateParserPlugin

from whoosh import query

from sqlalchemy.sql.expression import or_, and_, func

from kallithea.model.db import UserLog

from kallithea.lib.auth import LoginRequired, HasPermissionAnyDecorator

from kallithea.lib.base import BaseController, render

import formencode.htmlfill

import traceback

from pylons.i18n.translation import _

from webob.exc import HTTPFound

from kallithea.lib import helpers as h

from kallithea.lib.compat import formatted_json

from kallithea.lib.base import BaseController, render

import formencode

from formencode import htmlfill

from pylons.i18n.translation import _

from webob.exc import HTTPFound

from kallithea.lib import helpers as h

from kallithea.lib.auth import LoginRequired, HasPermissionAnyDecorator

from kallithea.lib.base import BaseController, render

import traceback

import formencode.htmlfill

from pylons.i18n.translation import _

from webob.exc import HTTPFound, HTTPNotFound, HTTPForbidden

from kallithea.model.forms import GistForm

from kallithea.model.gist import GistModel

from kallithea.model.meta import Session

from sqlalchemy import func

from formencode import htmlfill

from pylons.i18n.translation import _

from webob.exc import HTTPFound

from kallithea.lib import helpers as h

from kallithea.lib import auth_modules

from kallithea.lib.auth import LoginRequired, NotAnonymous, AuthUser

import formencode

from formencode import htmlfill

from pylons.i18n.translation import _

from webob.exc import HTTPFound

from kallithea.lib import helpers as h

from kallithea.lib.auth import LoginRequired, HasPermissionAnyDecorator

from kallithea.lib.base import BaseController, render

from formencode import htmlfill

from pylons.i18n.translation import _, ungettext

from webob.exc import HTTPFound, HTTPForbidden, HTTPNotFound, HTTPInternalServerError

import kallithea

from kallithea.lib import helpers as h

from kallithea.lib.compat import json

from kallithea.lib.auth import LoginRequired, \

import traceback

import formencode

from formencode import htmlfill

from pylons.i18n.translation import _

from sqlalchemy.sql.expression import func

from webob.exc import HTTPFound, HTTPInternalServerError, HTTPForbidden, HTTPNotFound

from kallithea.lib import helpers as h

from kallithea.lib.auth import LoginRequired, \

    HasRepoPermissionAnyDecorator, NotAnonymous, HasPermissionAny

import formencode

from formencode import htmlfill

from pylons.i18n.translation import _

from webob.exc import HTTPFound

from kallithea.lib import helpers as h

from kallithea.lib.auth import LoginRequired, HasPermissionAnyDecorator

from kallithea.lib.base import BaseController, render

kallithea.controllers.admin.user_groups

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

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

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

import formencode

from formencode import htmlfill

from pylons.i18n.translation import _

from webob.exc import HTTPFound

from webob.exc import HTTPInternalServerError

import kallithea

from kallithea.lib import helpers as h

from kallithea.lib.exceptions import UserGroupsAssignedException, \

    RepoGroupAssignmentError

kallithea.controllers.admin.users

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

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

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

import formencode

from formencode import htmlfill

from pylons.i18n.translation import _

from sqlalchemy.sql.expression import func

from webob.exc import HTTPFound, HTTPNotFound

import kallithea

from kallithea.lib.exceptions import DefaultUserException, \

    UserOwnsReposException, UserCreationError

from kallithea.lib import helpers as h

import logging

import traceback

from pylons.i18n.translation import _

from webob.exc import HTTPFound, HTTPNotFound, HTTPBadRequest

import kallithea.lib.helpers as h

from kallithea.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.helpers import RepoPage

kallithea.controllers.changeset

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

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

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

kallithea.controllers.compare

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

repos, branches, bookmarks or tips

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

import logging

import re

from pylons.i18n.translation import _

from webob.exc import HTTPFound, HTTPBadRequest

from kallithea.lib.utils2 import safe_str, safe_int

from kallithea.lib.vcs.utils.hgcompat import unionrepo

from kallithea.lib import helpers as h

import tempfile

import shutil

from pylons.i18n.translation import _

from webob.exc import HTTPFound

from kallithea.lib.utils import jsonify, action_logger

from kallithea.lib import diffs

from kallithea.lib import helpers as h

import traceback

from formencode import htmlfill

from pylons.i18n.translation import _

from webob.exc import HTTPFound

import kallithea.lib.helpers as h

from kallithea.lib.helpers import Page

from kallithea.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator, \

    NotAnonymous, HasRepoPermissionAny, HasPermissionAnyDecorator, HasPermissionAny

kallithea.controllers.journal

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

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

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

from webhelpers.feedgenerator import Atom1Feed, Rss201rev2Feed

from webob.exc import HTTPBadRequest

from pylons.i18n.translation import _

from kallithea.controllers.admin.admin import _journal_filter

from kallithea.model.db import UserLog, UserFollowing, Repository, User

from kallithea.model.meta import Session

from formencode import htmlfill

from pylons.i18n.translation import _

from webob.exc import HTTPFound, HTTPBadRequest

import kallithea.lib.helpers as h

from kallithea.lib.auth import AuthUser, HasPermissionAnyDecorator

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

from kallithea.lib.exceptions import UserCreationError

import formencode

import re

from pylons.i18n.translation import _

from webob.exc import HTTPFound, HTTPNotFound, HTTPForbidden, HTTPBadRequest

from kallithea.lib.vcs.utils.hgcompat import unionrepo

from kallithea.lib.compat import json, OrderedDict

from kallithea.lib.base import BaseRepoController, render

from decorator import decorator

from pylons.i18n.translation import _

from webhelpers.pylonslib import secure_form

from sqlalchemy import or_

from webob.exc import HTTPFound, HTTPBadRequest, HTTPForbidden, HTTPMethodNotAllowed

from kallithea import __platform__, is_windows, is_unix

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

from kallithea.model import meta

from kallithea.model.meta import Session

def set_available_permissions(config):

    """

    permission given in db. We don't want to check each time from db for new

    permissions since adding a new permission also requires application restart

    ie. to decorate new views with the newly created permission

    """

    log.info('getting information about all available permissions')

import paste.auth.basic

import paste.httpheaders

from pylons.controllers import WSGIController

from pylons.templating import render_mako as render  # don't remove this import

from pylons.i18n.translation import _

from kallithea import __version__, BACKENDS

from kallithea.lib.utils2 import str2bool, safe_unicode, AttributeDict, \

    safe_str, safe_int

from kallithea.lib import auth_modules

def get_session():

    if CELERY_ON:

        init_model(engine)

    sa = meta.Session()

    return sa

from beaker.cache import cache_region

from pygments.formatters.html import HtmlFormatter

from pygments import highlight as code_highlight

from pylons.i18n.translation import _, ungettext

from webhelpers.html import literal, HTML, escape

from webhelpers.html.tags import _set_input_attrs, _set_id_attr, \

    convert_boolean_attrs, NotGiven, _make_safe_id_component

from kallithea.lib.annotate import annotate_highlight

from kallithea.lib.utils import repo_name_slug, get_custom_lexer

from kallithea.lib.utils2 import str2bool, safe_unicode, safe_str, \

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

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

    from pylons import tmpl_context as c

    if not c.visual.use_gravatar:

        return ""

            return '<b>%s</b>' % mention

        hash_ = match_obj.group('hash')

        if hash_ is not None and repo_name is not None:

            return '<a class="revision-link" href="%(url)s">%(hash)s</a>' % {

                 'url': url('changeset_home', repo_name=repo_name, revision=hash_),

                 'hash': hash_,

def handle_git_receive(repo_path, revs, env, hook_type):

    """

    A really hacky method that is run by git post-receive hook and logs

    connect to database and run the logging code. Hacky as sh*t but works.

    :param repo_path:

    load_environment(conf.global_conf, conf.local_conf, test_env=False,

                     test_index=False)

    init_model(engine)

    baseui = make_ui('db')

    def bootstrap_config(self, conf):

        """

        """

        from pylons import config as pylonsconfig

        from kallithea.model import init_model

        from kallithea.lib.utils2 import engine_from_config

        setup_cache_regions(config)

        init_model(engine)

def set_app_settings(config):

    """

    :param config:

    """

    from kallithea.tests import HG_REPO, GIT_REPO, TESTS_TMP_PATH

    # PART ONE create db

    log.debug('making test db %s', dbconf)

    # create test dir if it doesn't exist

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

"""

Refer to docs/contributing.rst for details on running the test suite.

"""

     '%s://example.com:8080' % proto),

]

class TestLibs(TestController):

        from kallithea.lib.helpers import gravatar_url

        _md5 = lambda s: hashlib.md5(s).hexdigest()

        #mock pylons.tmpl_context

        def fake_tmpl_context(_url):

            _c = AttributeDict()

            return _c

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

            with mock.patch('pylons.tmpl_context', fake):

                    assert url.current() == 'https://example.com'

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

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

        def url_func(match_obj):

            _url = match_obj.groups()[0]

        return URL_PAT.sub(url_func, text)

    @parametrize('sample,expected', [

       """       sometimes !"""),

    ])

    def test_urlify_text(self, sample, expected):

        expected = self._quick_url(expected)

            from kallithea.lib.helpers import urlify_text

            assert urlify_text(sample, 'repo_name') == expected

      # tags are covered by test_tag_extractor

    ])

    def test_urlify_test(self, sample, expected, url_):

        expected = self._quick_url(expected,

                                   tmpl="""<a href="%s">%s</a>""", url_=url_)

    @parametrize('sample,expected', [

      ("deadbeefcafe @mention, and http://foo.bar/ yo",

       """<a class="message-link" href="#the-link"> yo</a>"""),

    ])

    def test_urlify_link(self, sample, expected):