## api access to raw_files put `FilesController:raw`, to enable access to patches

## add `ChangesetController:changeset_patch`. This list should be "," separated

## Syntax is <ControllerClass>:<function>. Check debug logs for generated names

## Recommended settings below are commented out:

api_access_controllers_whitelist =

#    ChangesetController:changeset_patch,

#    ChangesetController:changeset_raw,

#    FilesController:raw,

#    FilesController:archivefile

## default encoding used to convert from and to unicode

## can be also a comma separated list of encoding in case of mixed encodings

## Set Mercurial encoding, similar to setting HGENCODING before launching Kallithea

hgencoding = utf-8

## issue tracker for Kallithea (leave blank to disable, absent for default)

#bugtracker = https://bitbucket.org/conservancy/kallithea/issues

## issue tracking mapping for commit messages, comments, PR descriptions, ...

## Refer to the documentation ("Integration with issue trackers") for more details.

## regular expression to match issue references

## This pattern may/should contain parenthesized groups, that can

    def_len = safe_int(CONFIG.get('show_sha_length', 12))

    show_rev = str2bool(CONFIG.get('show_revision_number', False))

    raw_id = cs.raw_id[:def_len]

    if show_rev:

        return 'r%s:%s' % (cs.revision, raw_id)

    else:

        return raw_id

def fmt_date(date):

    if date:

    return ""

def is_git(repository):

    if hasattr(repository, 'alias'):

        _type = repository.alias

    elif hasattr(repository, 'repo_type'):

        _type = repository.repo_type

    else:

        _type = repository

    return _type == 'git'

            raise exc.HTTPExpectationFailed()

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

            # updating refs manually after each push.

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

            from kallithea.lib.vcs import get_repo

            from dulwich.server import update_server_info

            repo = get_repo(self.content_path)

            if repo:

                update_server_info(repo._repo)

        resp = Response()

        resp.charset = None

        resp.app_iter = out

        return resp

    def __call__(self, environ, start_response):

        req = Request(environ)

        _path = self._get_fixedpath(req.path_info)

        if _path.startswith('info/refs'):

            app = self.inforefs

        elif [a for a in self.valid_accepts if a in req.accept]:

            app = self.backend

        try:

<%text>## api access to raw_files put `FilesController:raw`, to enable access to patches</%text>

<%text>## add `ChangesetController:changeset_patch`. This list should be "," separated</%text>

<%text>## Syntax is <ControllerClass>:<function>. Check debug logs for generated names</%text>

<%text>## Recommended settings below are commented out:</%text>

api_access_controllers_whitelist =

#    ChangesetController:changeset_patch,

#    ChangesetController:changeset_raw,

#    FilesController:raw,

#    FilesController:archivefile

<%text>## default encoding used to convert from and to unicode</%text>

<%text>## can be also a comma separated list of encoding in case of mixed encodings</%text>

<%text>## Set Mercurial encoding, similar to setting HGENCODING before launching Kallithea</%text>

hgencoding = utf-8

<%text>## issue tracker for Kallithea (leave blank to disable, absent for default)</%text>

#bugtracker = https://bitbucket.org/conservancy/kallithea/issues

<%text>## issue tracking mapping for commit messages, comments, PR descriptions, ...</%text>

<%text>## Refer to the documentation ("Integration with issue trackers") for more details.</%text>

<%text>## regular expression to match issue references</%text>

<%text>## This pattern may/should contain parenthesized groups, that can</%text>

    :param config: kallithea.CONFIG

    """

    from kallithea.lib.vcs import conf

    from kallithea.lib.utils2 import aslist

    conf.settings.BACKENDS = {

        'hg': 'kallithea.lib.vcs.backends.hg.MercurialRepository',

        'git': 'kallithea.lib.vcs.backends.git.GitRepository',

    }

    conf.settings.GIT_EXECUTABLE_PATH = config.get('git_path', 'git')

    conf.settings.GIT_REV_FILTER = config.get('git_rev_filter', '--all').strip()

    conf.settings.DEFAULT_ENCODINGS = aslist(config.get('default_encoding',

def set_indexer_config(config):

    """

    Update Whoosh index mapping

    :param config: kallithea.CONFIG

    """

    from kallithea.config import conf

    log.debug('adding extra into INDEX_EXTENSIONS')

    conf.INDEX_EXTENSIONS.extend(re.split('\s+', config.get('index.extensions', '')))

    by chardet library if it fails fallback to unicode with errors replaced

    :param str_: string to decode

    :rtype: unicode

    :returns: unicode object

    """

    if isinstance(str_, unicode):

        return str_

    if not from_encoding:

        import kallithea

        DEFAULT_ENCODINGS = aslist(kallithea.CONFIG.get('default_encoding',

        from_encoding = DEFAULT_ENCODINGS

    if not isinstance(from_encoding, (list, tuple)):

        from_encoding = [from_encoding]

    try:

        return unicode(str_)

    except UnicodeDecodeError:

        pass

    for enc in from_encoding:

        try:

    """

    # if it's not basestr cast to str

    if not isinstance(unicode_, basestring):

        return str(unicode_)

    if isinstance(unicode_, str):

        return unicode_

    if not to_encoding:

        import kallithea

        DEFAULT_ENCODINGS = aslist(kallithea.CONFIG.get('default_encoding',

        to_encoding = DEFAULT_ENCODINGS

    if not isinstance(to_encoding, (list, tuple)):

        to_encoding = [to_encoding]

    for enc in to_encoding:

        try:

            return unicode_.encode(enc)

        except UnicodeEncodeError:

            pass

    try:

            Marks given path as added/changed/removed in a given _repo. This is

            for internal mercurial commit function.

            """

            # check if this path is removed

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

                return None

            # check if this path is added

            for node in self.added:

                if node.path == path:

                    return memfilectx(_repo, memctx, path=node.path,

                              if not node.is_binary else node.content),

                        islink=False,

                        isexec=node.is_executable,

                        copied=False)

            # or changed

            for node in self.changed:

                if node.path == path:

                    return memfilectx(_repo, memctx, path=node.path,

                              if not node.is_binary else node.content),

                        islink=False,

                        isexec=node.is_executable,

                        copied=False)

            raise RepositoryError("Given path haven't been marked as added,"

                                  "changed or removed (%s)" % path)

        parents = [None, None]

        for i, parent in enumerate(self.parents):

            if parent is not None:

                parents[i] = parent._ctx.node()

VCSRC_PATH = os.environ.get('VCSRC_PATH')

if not VCSRC_PATH:

    HOME_ = get_user_home()

    if not HOME_:

        HOME_ = tempfile.gettempdir()

VCSRC_PATH = VCSRC_PATH or abspath(HOME_, '.vcsrc')

if os.path.isdir(VCSRC_PATH):

    VCSRC_PATH = os.path.join(VCSRC_PATH, '__init__.py')

# list of default encoding used in safe_unicode/safe_str methods

# path to git executable run by run_git_command function

GIT_EXECUTABLE_PATH = 'git'

# can be also --branches --tags

GIT_REV_FILTER = '--all'

BACKENDS = {

    'hg': 'kallithea.lib.vcs.backends.hg.MercurialRepository',

    'git': 'kallithea.lib.vcs.backends.git.GitRepository',

}

ARCHIVE_SPECS = {

import time

import datetime

import pytest

from kallithea.lib import vcs

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

from kallithea.lib.vcs.nodes import (

    FileNode, AddedFileNodesGenerator,

    ChangedFileNodesGenerator, RemovedFileNodesGenerator

import datetime

from kallithea.lib.vcs.nodes import FileNode

from kallithea.tests.vcs.base import _BackendTestMixin

class FileNodeUnicodePathTestsMixin(_BackendTestMixin):

    fname = 'ąśðąęłąć.txt'

    ufname = (fname).decode('utf-8')

"""

Tests so called "in memory changesets" commit API of vcs.

"""

import time

import datetime

import pytest

from kallithea.lib import vcs

from kallithea.lib.vcs.exceptions import EmptyRepositoryError

from kallithea.lib.vcs.exceptions import NodeAlreadyAddedError

def sortkey(x):

    """Return key for sorting contributors "fairly":

    * latest contribution

    * first contribution

    * number of contribution years

    * name (with some unicode normalization)

    The entries must be 2-tuples of a list of string years and the unicode name"""

    return (x[0] and -int(x[0][-1]),

            x[0] and int(x[0][0]),

            -len(x[0]),

        )

def nice_years(l, dash='-', join=' '):

    """Convert a list of years into brief range like '1900-1901, 1921'."""

    if not l:

        return ''

    start = end = int(l[0])

    ranges = []

    for year in l[1:] + [0]:

        year = int(year)

        if year == end + 1: