elif hasattr(repository, 'repo_type'):

        _type = repository.repo_type

    else:

        _type = repository

    return _type == 'hg'

def email_or_none(author):

    _email = email(author)

    if _email != '':

        return _email

    # See if it contains a username we can get an email from

    user = User.get_by_username(author_name(author), case_insensitive=True,

                                cache=True)

    if user is not None:

        return user.email

    # No valid email, not a valid user in the system, none!

    return None

def person(author):

    # attr to return from fetched user

    person_getter = lambda usr: usr.username

    # Valid email in the attribute passed, see if they're in the system

    _email = email(author)

    if _email != '':

        user = User.get_by_email(_email, case_insensitive=True, cache=True)

        if user is not None:

            return person_getter(user)

        return _email

    # Maybe it's a username?

    _author = author_name(author)

    user = User.get_by_username(_author, case_insensitive=True,

                                cache=True)

    if user is not None:

        return person_getter(user)

    # Still nothing?  Just pass back the author name then

    return _author

def bool2icon(value):

    """Returns True/False values represented as small html image of true/false

    icons

    :param value: bool value

    """

    if value is True:

        return HTML.tag('img', src=url("/images/icons/accept.png"),

                        alt=_('True'))

    if value is False:

        return HTML.tag('img', src=url("/images/icons/cancel.png"),

                        alt=_('False'))

    return value

def action_parser(user_log, feed=False):

    """

    This helper will action_map the specified string action into translated

    fancy names with icons and links

    :param user_log: user log instance

    :param feed: use output for feeds (no html and fancy icons)

    """

    action = user_log.action

    action_params = ' '

    x = action.split(':')

    if len(x) > 1:

        action, action_params = x

    def get_cs_links():

        revs_limit = 3  # display this amount always

        revs_top_limit = 50  # show upto this amount of changesets hidden

        revs_ids = action_params.split(',')

        deleted = user_log.repository is None

        if deleted:

            return ','.join(revs_ids)

        repo_name = user_log.repository.repo_name

        repo = user_log.repository.scm_instance

        def lnk(rev, repo_name):

            if isinstance(rev, BaseChangeset):

                lbl = 'r%s:%s' % (rev.revision, rev.short_id)

                           revision=rev.raw_id)

                title = tooltip(rev.message)

            else:

                lbl = '%s' % rev

                _url = '#'

                title = _('Changeset not found')

            return link_to(lbl, _url, title=title, class_='tooltip',)

        revs = []

        if len(filter(lambda v: v != '', revs_ids)) > 0:

            for rev in revs_ids[:revs_top_limit]:

                try:

                    rev = repo.get_changeset(rev)

                    revs.append(rev)

                except ChangesetDoesNotExistError:

                    log.error('cannot find revision %s in this repo' % rev)

                    revs.append(rev)

                    continue

        cs_links = []

        cs_links.append(" " + ', '.join(

            [lnk(rev, repo_name) for rev in revs[:revs_limit]]

            )

        )

        compare_view = (

            ' <div class="compare_view tooltip" title="%s">'

            '<a href="%s">%s</a> </div>' % (

                _('Show all combined changesets %s->%s') % (

                    revs_ids[0], revs_ids[-1]

                ),

                url('changeset_home', repo_name=repo_name,

                    revision='%s...%s' % (revs_ids[0], revs_ids[-1])

                ),

                _('compare view')

            )

        )

        # if we have exactly one more than normally displayed

        # just display it, takes less space than displaying

        # "and 1 more revisions"

        if len(revs_ids) == revs_limit + 1:

            rev = revs[revs_limit]

            cs_links.append(", " + lnk(rev, repo_name))

        # hidden-by-default ones

        if len(revs_ids) > revs_limit + 1:

            uniq_id = revs_ids[0]

            html_tmpl = (

                '<span> %s <a class="show_more" id="_%s" '

                'href="#more">%s</a> %s</span>'

            )

            if not feed:

                cs_links.append(html_tmpl % (

                      _('and'),

                      uniq_id, _('%s more') % (len(revs_ids) - revs_limit),

                      _('revisions')

                    )

                )

            if not feed:

                html_tmpl = '<span id="%s" style="display:none">, %s </span>'

            else:

                html_tmpl = '<span id="%s"> %s </span>'

            morelinks = ', '.join(

              [lnk(rev, repo_name) for rev in revs[revs_limit:]]

            )

            if len(revs_ids) > revs_top_limit:

                morelinks += ', ...'

            cs_links.append(html_tmpl % (uniq_id, morelinks))

        if len(revs) > 1:

            cs_links.append(compare_view)

        return ''.join(cs_links)

    def get_fork_name():

        repo_name = action_params

        return _('fork name ') + str(link_to(action_params, url('summary_home',

                                          repo_name=repo_name,)))

    action_map = {'user_deleted_repo': (_('[deleted] repository'), None),

           'user_created_repo': (_('[created] repository'), None),

           'user_created_fork': (_('[created] repository as fork'), None),

           'user_forked_repo': (_('[forked] repository'), get_fork_name),

           'user_updated_repo': (_('[updated] repository'), None),

           'admin_deleted_repo': (_('[delete] repository'), None),

           'admin_created_repo': (_('[created] repository'), None),

           'admin_forked_repo': (_('[forked] repository'), None),

           'admin_updated_repo': (_('[updated] repository'), None),

           'push': (_('[pushed] into'), get_cs_links),

           'push_local': (_('[committed via RhodeCode] into'), get_cs_links),

           'push_remote': (_('[pulled from remote] into'), get_cs_links),

           'pull': (_('[pulled] from'), None),

           'started_following_repo': (_('[started following] repository'), None),

    try:

        import chardet

        encoding = chardet.detect(unicode_)['encoding']

        if encoding is None:

            raise UnicodeEncodeError()

        return unicode_.encode(encoding)

    except (ImportError, UnicodeEncodeError):

        return unicode_.encode(to_encoding, 'replace')

    return safe_str

def engine_from_config(configuration, prefix='sqlalchemy.', **kwargs):

    """

    Custom engine_from_config functions that makes sure we use NullPool for

    file based sqlite databases. This prevents errors on sqlite. This only

    applies to sqlalchemy versions < 0.7.0

    """

    import sqlalchemy

    from sqlalchemy import engine_from_config as efc

    import logging

    if int(sqlalchemy.__version__.split('.')[1]) < 7:

        # This solution should work for sqlalchemy < 0.7.0, and should use

        # proxy=TimerProxy() for execution time profiling

        from sqlalchemy.pool import NullPool

        url = configuration[prefix + 'url']

        if url.startswith('sqlite'):

            kwargs.update({'poolclass': NullPool})

        return efc(configuration, prefix, **kwargs)

    else:

        import time

        from sqlalchemy import event

        from sqlalchemy.engine import Engine

        log = logging.getLogger('sqlalchemy.engine')

        BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = xrange(30, 38)

        engine = efc(configuration, prefix, **kwargs)

        def color_sql(sql):

            COLOR_SEQ = "\033[1;%dm"

            COLOR_SQL = YELLOW

            normal = '\x1b[0m'

            return ''.join([COLOR_SEQ % COLOR_SQL, sql, normal])

        if configuration['debug']:

            #attach events only for debug configuration

            def before_cursor_execute(conn, cursor, statement,

                                    parameters, context, executemany):

                context._query_start_time = time.time()

                log.info(color_sql(">>>>> STARTING QUERY >>>>>"))

            def after_cursor_execute(conn, cursor, statement,

                                    parameters, context, executemany):

                total = time.time() - context._query_start_time

                log.info(color_sql("<<<<< TOTAL TIME: %f <<<<<" % total))

            event.listen(engine, "before_cursor_execute",

                         before_cursor_execute)

            event.listen(engine, "after_cursor_execute",

                         after_cursor_execute)

    return engine

def age(prevdate):

    """

    turns a datetime into an age string.

    :param prevdate: datetime object

    :rtype: unicode

    :returns: unicode words describing age

    """

    order = ['year', 'month', 'day', 'hour', 'minute', 'second']

    deltas = {}

    # Get date parts deltas

    now = datetime.now()

    for part in order:

        deltas[part] = getattr(now, part) - getattr(prevdate, part)

    # Fix negative offsets (there is 1 second between 10:59:59 and 11:00:00,

    # not 1 hour, -59 minutes and -59 seconds)

    for num, length in [(5, 60), (4, 60), (3, 24)]:  # seconds, minutes, hours

        part = order[num]

        carry_part = order[num - 1]

        if deltas[part] < 0:

            deltas[part] += length

            deltas[carry_part] -= 1

    # Same thing for days except that the increment depends on the (variable)

    # number of days in the month

    month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

    if deltas['day'] < 0:

        if prevdate.month == 2 and (prevdate.year % 4 == 0 and

            (prevdate.year % 100 != 0 or prevdate.year % 400 == 0)):

            deltas['day'] += 29

        else:

            deltas['day'] += month_lengths[prevdate.month - 1]

        deltas['month'] -= 1

    if deltas['month'] < 0:

        deltas['month'] += 12

        deltas['year'] -= 1

    # Format the result

    fmt_funcs = {

        'year': lambda d: ungettext(u'%d year', '%d years', d) % d,

        'month': lambda d: ungettext(u'%d month', '%d months', d) % d,

        'day': lambda d: ungettext(u'%d day', '%d days', d) % d,

        'hour': lambda d: ungettext(u'%d hour', '%d hours', d) % d,

        'minute': lambda d: ungettext(u'%d minute', '%d minutes', d) % d,

        'second': lambda d: ungettext(u'%d second', '%d seconds', d) % d,

    }

    for i, part in enumerate(order):

        value = deltas[part]

        if value == 0:

            continue

        if i < 5:

            sub_part = order[i + 1]

            sub_value = deltas[sub_part]

        else:

            sub_value = 0

        if sub_value == 0:

            return _(u'%s ago') % fmt_funcs[part](value)

        return _(u'%s and %s ago') % (fmt_funcs[part](value),

            fmt_funcs[sub_part](sub_value))

    return _(u'just now')

def uri_filter(uri):

    """

    Removes user:password from given url string

    :param uri:

    :rtype: unicode

    :returns: filtered list of strings

    """

    if not uri:

        return ''

    proto = ''

    for pat in ('https://', 'http://'):

        if uri.startswith(pat):

            uri = uri[len(pat):]

            proto = pat

            break

    # remove passwords and username

    uri = uri[uri.find('@') + 1:]

    # get the port

    cred_pos = uri.find(':')

    if cred_pos == -1:

        host, port = uri, None

    else:

        host, port = uri[:cred_pos], uri[cred_pos + 1:]

    return filter(None, [proto, host, port])

def credentials_filter(uri):

    """

    Returns a url with removed credentials

    :param uri:

    """

    uri = uri_filter(uri)

    #check if we have port

    if len(uri) > 2 and uri[2]:

        uri[2] = ':' + uri[2]

    return ''.join(uri)

def get_changeset_safe(repo, rev):

    """

    Safe version of get_changeset if this changeset doesn't exists for a

    repo it returns a Dummy one instead

    :param repo:

    :param rev:

    """

    from rhodecode.lib.vcs.backends.base import BaseRepository

    from rhodecode.lib.vcs.exceptions import RepositoryError

    if not isinstance(repo, BaseRepository):

        raise Exception('You must pass an Repository '

                        'object as first argument got %s', type(repo))

    try:

        cs = repo.get_changeset(rev)

    except RepositoryError:

        from rhodecode.lib.utils import EmptyChangeset

        cs = EmptyChangeset(requested_revision=rev)

    return cs

MENTIONS_REGEX = r'(?:^@|\s@)([a-zA-Z0-9]{1}[a-zA-Z0-9\-\_\.]+)(?:\s{1})'

def extract_mentioned_users(s):

    """

    Returns unique usernames from given string s that have @mention

    :param s: string to get mentions

    """

    usrs = set()

    for username in re.findall(MENTIONS_REGEX, s):

        usrs.add(username)

    return sorted(list(usrs), key=lambda k: k.lower())

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

"""

    vcs.backends.git

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

    Git backend implementation.

    :created_on: Apr 8, 2010

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

"""

import os

import re

import time

import posixpath

from dulwich.repo import Repo, NotGitRepository

#from dulwich.config import ConfigFile

from string import Template

from subprocess import Popen, PIPE

from rhodecode.lib.vcs.backends.base import BaseRepository

from rhodecode.lib.vcs.exceptions import BranchDoesNotExistError

from rhodecode.lib.vcs.exceptions import ChangesetDoesNotExistError

from rhodecode.lib.vcs.exceptions import EmptyRepositoryError

from rhodecode.lib.vcs.exceptions import RepositoryError

from rhodecode.lib.vcs.exceptions import TagAlreadyExistError

from rhodecode.lib.vcs.exceptions import TagDoesNotExistError

from rhodecode.lib.vcs.utils import safe_unicode, makedate, date_fromtimestamp

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

from rhodecode.lib.vcs.utils.ordered_dict import OrderedDict

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

from rhodecode.lib.vcs.utils.paths import get_user_home

from .workdir import GitWorkdir

from .changeset import GitChangeset

from .inmemory import GitInMemoryChangeset

from .config import ConfigFile

class GitRepository(BaseRepository):

    """

    Git repository backend.

    """

    DEFAULT_BRANCH_NAME = 'master'

    scm = 'git'

    def __init__(self, repo_path, create=False, src_url=None,

                 update_after_clone=False, bare=False):

        self.path = abspath(repo_path)

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

        #temporary set that to now at later we will move it to constructor

        baseui = None

        if baseui is None:

            from mercurial.ui import ui

            baseui = ui()

        # patch the instance of GitRepo with an "FAKE" ui object to add

        # compatibility layer with Mercurial

        setattr(self._repo, 'ui', baseui)

        try:

            self.head = self._repo.head()

        except KeyError:

            self.head = None

        self._config_files = [

            bare and abspath(self.path, 'config') or abspath(self.path, '.git',

                'config'),

            abspath(get_user_home(), '.gitconfig'),

        ]

        self.bare = self._repo.bare

    @LazyProperty

    def revisions(self):

        """

        Returns list of revisions' ids, in ascending order.  Being lazy

        attribute allows external tools to inject shas from cache.

        """

        return self._get_all_revisions()

    def run_git_command(self, cmd):

        """

        Runs given ``cmd`` as git command and returns tuple

        (returncode, stdout, stderr).

        .. note::

           This method exists only until log/blame functionality is implemented

           at Dulwich (see https://bugs.launchpad.net/bugs/645142). Parsing

           os command's output is road to hell...

        :param cmd: git command to be executed

        """

        _copts = ['-c', 'core.quotepath=false', ]

        _str_cmd = False

        if isinstance(cmd, basestring):

            cmd = [cmd]

            _str_cmd = True

        gitenv = os.environ

        gitenv['GIT_CONFIG_NOGLOBAL'] = '1'

        cmd = ['git'] + _copts + cmd

        if _str_cmd:

            cmd = ' '.join(cmd)

        try:

            opts = dict(

                shell=isinstance(cmd, basestring),

                stdout=PIPE,

                stderr=PIPE,

                env=gitenv,

            )

            if os.path.isdir(self.path):

                opts['cwd'] = self.path

            p = Popen(cmd, **opts)

        except OSError, err:

            raise RepositoryError("Couldn't run git command (%s).\n"

                "Original error was:%s" % (cmd, err))

        so, se = p.communicate()

        if not se.startswith("fatal: bad default revision 'HEAD'") and \

            p.returncode != 0:

            raise RepositoryError("Couldn't run git command (%s).\n"

                "stderr:\n%s" % (cmd, se))

        return so, se

    def _check_url(self, url):

        """

        Functon will check given url and try to verify if it's a valid

        link. Sometimes it may happened that mercurial will issue basic

        auth request that can cause whole API to hang when used from python

        or other external calls.

        On failures it'll raise urllib2.HTTPError

        """

        #TODO: implement this

        pass

    def _get_repo(self, create, src_url=None, update_after_clone=False,

            bare=False):

        if create and os.path.exists(self.path):

            raise RepositoryError("Location already exist")

        if src_url and not create:

            raise RepositoryError("Create should be set to True if src_url is "

                                  "given (clone operation creates repository)")

        try:

            if create and src_url:

                self._check_url(src_url)

                self.clone(src_url, update_after_clone, bare)

                return Repo(self.path)

            elif create:

                os.mkdir(self.path)

                if bare:

                    return Repo.init_bare(self.path)

                else:

                    return Repo.init(self.path)

            else:

                return Repo(self.path)

        except (NotGitRepository, OSError), err:

            raise RepositoryError(err)

    def _get_all_revisions(self):

        cmd = 'rev-list --all --date-order'

        try:

            so, se = self.run_git_command(cmd)

        except RepositoryError:

            # Can be raised for empty repositories

            return []

        revisions = so.splitlines()

        revisions.reverse()

        return revisions

    def _get_revision(self, revision):

        """

        For git backend we always return integer here. This way we ensure

        that changset's revision attribute would become integer.

        """

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

        is_bstr = lambda o: isinstance(o, (str, unicode))

        is_null = lambda o: len(o) == revision.count('0')

        if len(self.revisions) == 0:

            raise EmptyRepositoryError("There are no changesets yet")

        if revision in (None, '', 'tip', 'HEAD', 'head', -1):

            revision = self.revisions[-1]

        if ((is_bstr(revision) and revision.isdigit() and len(revision) < 12)

            or isinstance(revision, int) or is_null(revision)):

            try:

                revision = self.revisions[int(revision)]

            except:

                raise ChangesetDoesNotExistError("Revision %r does not exist "

                    "for this repository %s" % (revision, self))

<div>

    ${h.form(url('admin_settings_my_account_update'),method='put')}

        <div class="form">

             <div class="field">

                <div class="gravatar_box">

                    <div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(c.user.email)}"/></div>

                    <p>

                    %if c.use_gravatar:

                    <strong>${_('Change your avatar at')} <a href="http://gravatar.com">gravatar.com</a></strong>

                    <br/>${_('Using')} ${c.user.email}

                    %else:

                    <br/>${c.user.email}

                    %endif

                    </p>

                </div>

             </div>

            <div class="field">

                <div class="label">

                    <label>${_('API key')}</label> ${c.user.api_key}

                </div>

            </div>

            <div class="fields">

                 <div class="field">

                    <div class="label">

                        <label for="username">${_('Username')}:</label>

                    </div>

                    <div class="input">

                        ${h.text('username',class_="medium")}

                    </div>

                 </div>

                 <div class="field">

                    <div class="label">

                        <label for="new_password">${_('New password')}:</label>

                    </div>

                    <div class="input">

                        ${h.password('new_password',class_="medium",autocomplete="off")}

                    </div>

                 </div>

                 <div class="field">

                    <div class="label">

                        <label for="password_confirmation">${_('New password confirmation')}:</label>

                    </div>

                    <div class="input">

                        ${h.password('password_confirmation',class_="medium",autocomplete="off")}

                    </div>

                 </div>

                 <div class="field">

                    <div class="label">

                        <label for="name">${_('First Name')}:</label>

                    </div>

                    <div class="input">

                        ${h.text('name',class_="medium")}

                    </div>

                 </div>

                 <div class="field">

                    <div class="label">

                        <label for="lastname">${_('Last Name')}:</label>

                    </div>

                    <div class="input">

                        ${h.text('lastname',class_="medium")}

                    </div>

                 </div>

                 <div class="field">

                    <div class="label">

                        <label for="email">${_('Email')}:</label>

                    </div>

                    <div class="input">

                        ${h.text('email',class_="medium")}

                    </div>

                 </div>

                <div class="buttons">

                  ${h.submit('save',_('Save'),class_="ui-button")}

                  ${h.reset('reset',_('Reset'),class_="ui-button")}

                </div>

            </div>

        </div>

    ${h.end_form()}

<option value="9bb326a04ae5d98d437dece54be04f830cf1edd9">r26:9bb326a04ae5 (default)</option>

<option value="536c1a19428381cfea92ac44985304f6a8049569">r24:536c1a194283 (default)</option>

<option value="dc5d2c0661b61928834a785d3e64a3f80d3aad9c">r8:dc5d2c0661b6 (default)</option>

<option value="3803844fdbd3b711175fc3da9bdacfcd6d29a6fb">r7:3803844fdbd3 (default)</option>

</optgroup>

<optgroup label="Branches">

<option selected="selected" value="27cd5cce30c96924232dffcd24178a07ffeb5dfc">default</option>

<option value="97e8b885c04894463c51898e14387d80c30ed1ee">git</option>

<option value="2e6a2bf9356ca56df08807f4ad86d480da72a8f4">web</option>

</optgroup>

<optgroup label="Tags">

<option selected="selected" value="27cd5cce30c96924232dffcd24178a07ffeb5dfc">tip</option>

<option value="fd4bdb5e9b2a29b4393a4ac6caef48c17ee1a200">0.1.4</option>

<option value="17544fbfcd33ffb439e2b728b5d526b1ef30bfcf">0.1.3</option>

<option value="a7e60bff65d57ac3a1a1ce3b12a70f8a9e8a7720">0.1.2</option>

<option value="eb3a60fc964309c1a318b8dfe26aa2d1586c85ae">0.1.1</option>

</optgroup>

""")

        response.mustcontain("""<div class="commit">merge</div>""")

        response.mustcontain("""<span style="text-transform: uppercase;"><a href="#">branch: default</a></span>""")

    def test_file_annotation(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='index',

                                    repo_name=HG_REPO,

                                    revision='27cd5cce30c96924232dffcd24178a07ffeb5dfc',

                                    f_path='vcs/nodes.py',

                                    annotate=True))

        response.mustcontain("""<optgroup label="Changesets">

<option value="8911406ad776fdd3d0b9932a2e89677e57405a48">r167:8911406ad776 (default)</option>

<option value="aa957ed78c35a1541f508d2ec90e501b0a9e3167">r165:aa957ed78c35 (default)</option>

<option value="48e11b73e94c0db33e736eaeea692f990cb0b5f1">r140:48e11b73e94c (default)</option>

<option value="adf3cbf483298563b968a6c673cd5bde5f7d5eea">r126:adf3cbf48329 (default)</option>

<option value="6249fd0fb2cfb1411e764129f598e2cf0de79a6f">r113:6249fd0fb2cf (git)</option>

<option value="75feb4c33e81186c87eac740cee2447330288412">r109:75feb4c33e81 (default)</option>

<option value="9a4dc232ecdc763ef2e98ae2238cfcbba4f6ad8d">r108:9a4dc232ecdc (default)</option>

<option value="595cce4efa21fda2f2e4eeb4fe5f2a6befe6fa2d">r107:595cce4efa21 (default)</option>

<option value="4a8bd421fbc2dfbfb70d85a3fe064075ab2c49da">r104:4a8bd421fbc2 (default)</option>

<option value="57be63fc8f85e65a0106a53187f7316f8c487ffa">r102:57be63fc8f85 (default)</option>

<option value="5530bd87f7e2e124a64d07cb2654c997682128be">r101:5530bd87f7e2 (git)</option>

<option value="e516008b1c93f142263dc4b7961787cbad654ce1">r99:e516008b1c93 (default)</option>

<option value="41f43fc74b8b285984554532eb105ac3be5c434f">r93:41f43fc74b8b (default)</option>

<option value="cc66b61b8455b264a7a8a2d8ddc80fcfc58c221e">r92:cc66b61b8455 (default)</option>

<option value="73ab5b616b3271b0518682fb4988ce421de8099f">r91:73ab5b616b32 (default)</option>

<option value="e0da75f308c0f18f98e9ce6257626009fdda2b39">r82:e0da75f308c0 (default)</option>

<option value="fb2e41e0f0810be4d7103bc2a4c7be16ee3ec611">r81:fb2e41e0f081 (default)</option>

<option value="602ae2f5e7ade70b3b66a58cdd9e3e613dc8a028">r76:602ae2f5e7ad (default)</option>

<option value="a066b25d5df7016b45a41b7e2a78c33b57adc235">r73:a066b25d5df7 (default)</option>

<option value="637a933c905958ce5151f154147c25c1c7b68832">r61:637a933c9059 (web)</option>

<option value="0c21004effeb8ce2d2d5b4a8baf6afa8394b6fbc">r60:0c21004effeb (web)</option>

<option value="a1f39c56d3f1d52d5fb5920370a2a2716cd9a444">r59:a1f39c56d3f1 (web)</option>

<option value="97d32df05c715a3bbf936bf3cc4e32fb77fe1a7f">r58:97d32df05c71 (web)</option>

<option value="08eaf14517718dccea4b67755a93368341aca919">r57:08eaf1451771 (web)</option>

<option value="22f71ad265265a53238359c883aa976e725aa07d">r56:22f71ad26526 (web)</option>

<option value="97501f02b7b4330924b647755663a2d90a5e638d">r49:97501f02b7b4 (web)</option>

<option value="86ede6754f2b27309452bb11f997386ae01d0e5a">r47:86ede6754f2b (web)</option>

<option value="014c40c0203c423dc19ecf94644f7cac9d4cdce0">r45:014c40c0203c (web)</option>

<option value="ee87846a61c12153b51543bf860e1026c6d3dcba">r30:ee87846a61c1 (default)</option>

<option value="9bb326a04ae5d98d437dece54be04f830cf1edd9">r26:9bb326a04ae5 (default)</option>

<option value="536c1a19428381cfea92ac44985304f6a8049569">r24:536c1a194283 (default)</option>

<option value="dc5d2c0661b61928834a785d3e64a3f80d3aad9c">r8:dc5d2c0661b6 (default)</option>

<option value="3803844fdbd3b711175fc3da9bdacfcd6d29a6fb">r7:3803844fdbd3 (default)</option>

</optgroup>

<optgroup label="Branches">

<option selected="selected" value="27cd5cce30c96924232dffcd24178a07ffeb5dfc">default</option>

<option value="97e8b885c04894463c51898e14387d80c30ed1ee">git</option>

<option value="2e6a2bf9356ca56df08807f4ad86d480da72a8f4">web</option>

</optgroup>

<optgroup label="Tags">

<option selected="selected" value="27cd5cce30c96924232dffcd24178a07ffeb5dfc">tip</option>

<option value="fd4bdb5e9b2a29b4393a4ac6caef48c17ee1a200">0.1.4</option>

<option value="17544fbfcd33ffb439e2b728b5d526b1ef30bfcf">0.1.3</option>

<option value="a7e60bff65d57ac3a1a1ce3b12a70f8a9e8a7720">0.1.2</option>

<option value="eb3a60fc964309c1a318b8dfe26aa2d1586c85ae">0.1.1</option>

</optgroup>""")

        response.mustcontain("""<span style="text-transform: uppercase;"><a href="#">branch: default</a></span>""")

    def test_archival(self):

        self.log_user()

        for arch_ext, info in ARCHIVE_SPECS.items():

            short = '27cd5cce30c9%s' % arch_ext

            fname = '27cd5cce30c96924232dffcd24178a07ffeb5dfc%s' % arch_ext

            filename = '%s-%s' % (HG_REPO, short)

            response = self.app.get(url(controller='files',

                                        action='archivefile',

                                        repo_name=HG_REPO,

                                        fname=fname))

            self.assertEqual(response.status, '200 OK')

            heads = [

                ('Content-Disposition', 'attachment; filename=%s' % filename),

                ('Content-Type', '%s; charset=utf-8' % info[0]),

            ]

            self.assertEqual(response.response._headers.items(), heads)

    def test_archival_wrong_ext(self):

        self.log_user()

        for arch_ext in ['tar', 'rar', 'x', '..ax', '.zipz']:

            fname = '27cd5cce30c96924232dffcd24178a07ffeb5dfc%s' % arch_ext

                                        action='archivefile',

                                        repo_name=HG_REPO,

                                        fname=fname))

            response.mustcontain('Unknown archive type')

    def test_archival_wrong_revision(self):

        self.log_user()

        for rev in ['00x000000', 'tar', 'wrong', '@##$@$42413232', '232dffcd']:

            fname = '%s.zip' % rev

            response = self.app.get(url(controller='files',

                                        action='archivefile',

                                        repo_name=HG_REPO,

                                        fname=fname))

            response.mustcontain('Unknown revision')

    #==========================================================================

    # RAW FILE

    #==========================================================================

    def test_raw_file_ok(self):

        self.log_user()

        response = self.app.get(url(controller='files', action='rawfile',

                                    repo_name=HG_REPO,

                                    revision='27cd5cce30c96924232dffcd24178a07ffeb5dfc',

                                    f_path='vcs/nodes.py'))

        self.assertEqual(response.content_disposition, "attachment; filename=nodes.py")

        self.assertEqual(response.content_type, "text/x-python")

    def test_raw_file_wrong_cs(self):

        self.log_user()