except RepositoryError as e:

                        h.flash(e, category='warning')

                        raise HTTPFound(location=h.url('changelog_home', repo_name=repo_name))

            else:

                collection = c.db_repo_scm_instance.get_changesets(start=0, end=revision,

                                                        branch_name=branch_name, reverse=True)

            c.total_cs = len(collection)

            c.cs_pagination = Page(collection, page=p, item_count=c.total_cs, items_per_page=c.size,

                                   branch=branch_name)

            page_revisions = [x.raw_id for x in c.cs_pagination]

            c.cs_comments = c.db_repo.get_comments(page_revisions)

            c.cs_statuses = c.db_repo.statuses(page_revisions)

        except EmptyRepositoryError as e:

            h.flash(e, category='warning')

            raise HTTPFound(location=url('summary_home', repo_name=c.repo_name))

        except (RepositoryError, ChangesetDoesNotExistError, Exception) as e:

            log.error(traceback.format_exc())

            h.flash(e, category='error')

            raise HTTPFound(location=url('changelog_home', repo_name=c.repo_name))

        c.branch_name = branch_name

        c.branch_filters = [('', _('None'))] + \

        if c.db_repo_scm_instance.closed_branches:

            prefix = _('(closed)') + ' '

            c.branch_filters += [('-', '-')] + \

        revs = []

        if not f_path:

            revs = [x.revision for x in c.cs_pagination]

        c.jsdata = graph_data(c.db_repo_scm_instance, revs)

        c.revision = revision # requested revision ref

        c.first_revision = c.cs_pagination[0] # pagination is never empty here!

        return render('changelog/changelog.html')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def changelog_details(self, cs):

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            c.cs = c.db_repo_scm_instance.get_changeset(cs)

            return render('changelog/changelog_details.html')

        raise HTTPNotFound()

                    if last_rev == 0 or num_of_revs > last_rev + 1:

                        # delete the docs in the index for the previous

                        # last changeset(s)

                        for hit in results:

                            q = qp.parse(u"last:t AND %s AND raw_id:%s" %

                                            (repo_name, hit['raw_id']))

                            writer.delete_by_query(q)

                        # index from the previous last changeset + all new ones

                        indexed_total += self.index_changesets(writer,

                                                repo_name, repo, start_id)

                        writer_is_dirty = True

                log.debug('indexed %s changesets for repo %s',

                          indexed_total, repo_name

                )

            finally:

                if writer_is_dirty:

                    log.debug('>> COMMITING CHANGES TO CHANGESET INDEX<<')

                    writer.commit(merge=True)

                    log.debug('>>> FINISHED REBUILDING CHANGESET INDEX <<<')

                else:

                    log.debug('>> NOTHING TO COMMIT TO CHANGESET INDEX<<')

    def update_file_index(self):

        idx = open_dir(self.index_location, indexname=self.indexname)

        # The set of all paths in the index

        indexed_paths = set()

        # The set of all paths we need to re-index

        to_index = set()

        writer = idx.writer()

        writer_is_dirty = False

        try:

            with idx.reader() as reader:

                # Loop over the stored fields in the index

                for fields in reader.all_stored_fields():

                    indexed_path = fields['path']

                    indexed_repo_path = fields['repository']

                    indexed_paths.add(indexed_path)

                    if indexed_repo_path not in self.filtered_repo_update_paths:

                        continue

                    repo = self.repo_paths[indexed_repo_path]

                    try:

        finally:

            if writer_is_dirty:

                log.debug('>> COMMITING CHANGES TO FILE INDEX <<')

                writer.commit(merge=True)

                log.debug('>>> FINISHED REBUILDING FILE INDEX <<<')

            else:

                log.debug('>> NOTHING TO COMMIT TO FILE INDEX <<')

                writer.cancel()

    def build_indexes(self):

        if os.path.exists(self.index_location):

            log.debug('removing previous index')

            rmtree(self.index_location)

        if not os.path.exists(self.index_location):

            os.mkdir(self.index_location)

        chgset_idx = create_in(self.index_location, CHGSETS_SCHEMA,

                               indexname=CHGSET_IDX_NAME)

        chgset_idx_writer = chgset_idx.writer()

        file_idx = create_in(self.index_location, SCHEMA, indexname=IDX_NAME)

        file_idx_writer = file_idx.writer()

        log.debug('BUILDING INDEX FOR EXTENSIONS %s '

        for repo_name, repo in sorted(self.repo_paths.items()):

            log.debug('Updating indices for repo %s', repo_name)

            # skip indexing if there aren't any revisions

            if len(repo) < 1:

                continue

            self.index_files(file_idx_writer, repo_name, repo)

            self.index_changesets(chgset_idx_writer, repo_name, repo)

        log.debug('>> COMMITING CHANGES <<')

        file_idx_writer.commit(merge=True)

        chgset_idx_writer.commit(merge=True)

        log.debug('>>> FINISHED BUILDING INDEX <<<')

    def update_indexes(self):

        self.update_file_index()

        self.update_changeset_index()

    def run(self, full_index=False):

        """Run daemon"""

        if full_index or self.initial:

            self.build_indexes()

        else:

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

"""

    vcs.backends

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

    Main package for scm backends

    :created_on: Apr 8, 2010

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

"""

import os

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import VCSError

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

from kallithea.lib.vcs.utils.imports import import_class

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

def get_repo(path=None, alias=None, create=False):

    """

    Returns ``Repository`` object of type linked with given ``alias`` at

    the specified ``path``. If ``alias`` is not given it will try to guess it

    using get_scm method

    """

    if create:

        if not (path or alias):

            raise TypeError("If create is specified, we need path and scm type")

        return get_backend(alias)(path, create=True)

    if path is None:

        path = abspath(os.path.curdir)

    try:

        scm, path = get_scm(path, search_up=True)

        path = abspath(path)

        alias = scm

    except VCSError:

        raise VCSError("No scm found at %s" % path)

    if alias is None:

        alias = get_scm(path)[0]

    backend = get_backend(alias)

    repo = backend(path, create=create)

    return repo

def get_backend(alias):

    """

    Returns ``Repository`` class identified by the given alias or raises

    VCSError if alias is not recognized or backend class cannot be imported.

    """

    if alias not in settings.BACKENDS:

        raise VCSError("Given alias '%s' is not recognized! Allowed aliases:\n"

    backend_path = settings.BACKENDS[alias]

    klass = import_class(backend_path)

    return klass

def get_supported_backends():

    """

    Returns list of aliases of supported backends.

    """

    return settings.BACKENDS.keys()

        elif '=' in part:

            # Process a palette defining string

            definition = {}

            # Break the definition into the role,

            # plus the list of specific instructions.

            # The role must be in upper case

            role, instructions = part.split('=')

            role = role.upper()

            styles = instructions.split(',')

            styles.reverse()

            # The first instruction can contain a slash

            # to break apart fg/bg.

            colors = styles.pop().split('/')

            colors.reverse()

            fg = colors.pop()

            if fg in color_names:

                definition['fg'] = fg

            if colors and colors[-1] in color_names:

                definition['bg'] = colors[-1]

            # All remaining instructions are options

            if opts:

                definition['opts'] = opts

            # The nocolor palette has all available roles.

            # Use that palette as the basis for determining

            # if the role is valid.

            if role in PALETTES[NOCOLOR_PALETTE] and definition:

                palette[role] = definition

    # If there are no colors specified, return the empty palette.

    if palette == PALETTES[NOCOLOR_PALETTE]:

        return None

    return palette

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

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

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

from kallithea.model.meta import Base, Session

URL_SEP = '/'

log = logging.getLogger(__name__)

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

# BASE CLASSES

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

_hash_key = lambda k: hashlib.md5(safe_str(k)).hexdigest()

class BaseDbModel(object):

    """

    Base Model for all classes

    """

    @classmethod

    def _get_keys(cls):

        """return column names for this model """

        return class_mapper(cls).c.keys()

    def get_dict(self):

        """

        return dict with keys and values corresponding

        to this model data """

        d = {}

        for k in self._get_keys():

            d[k] = getattr(self, k)

        # also use __json__() if present to get additional fields

        _json_attr = getattr(self, '__json__', None)

        if _json_attr:

            # update with attributes from __json__

            if callable(_json_attr):

                _json_attr = _json_attr()

            for k, val in _json_attr.iteritems():

                d[k] = val

        return d

    def get_appstruct(self):

        """return list with keys and values tuples corresponding

        to this model data """

            self.TYPE_PASSWORD_RESET: 'password_reset',

            self.TYPE_REGISTRATION: 'registration',

            self.TYPE_DEFAULT: 'default',

            self.TYPE_PULL_REQUEST: 'pull_request',

            self.TYPE_PULL_REQUEST_COMMENT: 'pull_request_comment',

        }

        self._subj_map = {

            self.TYPE_CHANGESET_COMMENT: _('[Comment] %(repo_name)s changeset %(short_id)s "%(message_short)s" on %(branch)s'),

            self.TYPE_MESSAGE: 'Test Message',

            # self.TYPE_PASSWORD_RESET

            self.TYPE_REGISTRATION: _('New user %(new_username)s registered'),

            # self.TYPE_DEFAULT

            self.TYPE_PULL_REQUEST: _('[Review] %(repo_name)s PR %(pr_nice_id)s "%(pr_title_short)s" from %(pr_source_branch)s by %(pr_owner_username)s'),

            self.TYPE_PULL_REQUEST_COMMENT: _('[Comment] %(repo_name)s PR %(pr_nice_id)s "%(pr_title_short)s" from %(pr_source_branch)s by %(pr_owner_username)s'),

        }

    def get_email_description(self, type_, **kwargs):

        """

        return subject for email based on given type

        """

        tmpl = self._subj_map[type_]

        try:

            subj = tmpl % kwargs

        except KeyError as e:

            raise

        # gmail doesn't do proper threading but will ignore leading square

        # bracket content ... so that is where we put status info

        bracket_tags = []

        status_change = kwargs.get('status_change')

        if status_change:

            bracket_tags.append(unicode(status_change))  # apply unicode to evaluate LazyString before .join

        if kwargs.get('closing_pr'):

            bracket_tags.append(_('Closing'))

        if bracket_tags:

            if subj.startswith('['):

                subj = '[' + ', '.join(bracket_tags) + ': ' + subj[1:]

            else:

                subj = '[' + ', '.join(bracket_tags) + '] ' + subj

        return subj

    def get_email_tmpl(self, type_, content_type, **kwargs):

        """

        return generated template for email based on given type

        """

        base = 'email_templates/' + self.email_types.get(type_, self.email_types[self.TYPE_DEFAULT]) + '.' + content_type

        email_template = self._tmpl_lookup.get_template(base)

        # translator and helpers inject

## snippet for displaying permissions overview for users

## usage:

##    <%namespace name="p" file="/base/perms_summary.html"/>

##    ${p.perms_summary(c.perm_user.permissions)}

<%def name="perms_summary(permissions, show_all=False, actions=True)">

<div id="perms">

        <div class="perms_section_head">

            <h4>${section.replace("_"," ").capitalize()}</h4>

            %if section != 'global':

              <div class="pull-right checkbox">

                ${_('Show')}:

                <label>${h.checkbox('perms_filter_none_%s' % section, 'none', 'checked', class_='perm_filter filter_%s' % section, **{'data-section':section, 'data-perm_type':'none'})}<span class="label label-none">${_('None')}</span></label>

                <label>${h.checkbox('perms_filter_read_%s' % section, 'read', 'checked', class_='perm_filter filter_%s' % section, **{'data-section':section, 'data-perm_type':'read'})}<span class="label label-read">${_('Read')}</span></label>

                <label>${h.checkbox('perms_filter_write_%s' % section, 'write', 'checked', class_='perm_filter filter_%s' % section, **{'data-section':section, 'data-perm_type':'write'})}<span class="label label-write">${_('Write')}</span></label>

                <label>${h.checkbox('perms_filter_admin_%s' % section, 'admin', 'checked', class_='perm_filter filter_%s' % section, **{'data-section':section, 'data-perm_type':'admin'})}<span class="label label-admin">${_('Admin')}</span></label>

              </div>

            %endif

        </div>

        %if not permissions[section]:

            <span class="text-muted">${_('No permissions defined yet')}</span>

        %else:

        <div id='tbl_list_wrap_${section}'>

         <table id="tbl_list_${section}" class="table">

          ## global permission box

          %if section == 'global':

              <thead>

                <tr>

                  <th class="left col-xs-9">${_('Permission')}</th>

                  %if actions:

                  <th class="left col-xs-3">${_('Edit Permission')}</th>