c.changelog_for_path = f_path

        try:

            if f_path:

                log.debug('generating changelog for path %s' % f_path)

                # get the history for the file !

                tip_cs = c.rhodecode_repo.get_changeset()

                try:

                    collection = tip_cs.get_file_history(f_path)

                except (NodeDoesNotExistError, ChangesetError):

                    #this node is not present at tip !

                    try:

                        cs = self.__get_cs_or_redirect(revision, repo_name)

                        collection = cs.get_file_history(f_path)

                    except RepositoryError, e:

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

                        redirect(h.url('changelog_home', repo_name=repo_name))

                collection = list(reversed(collection))

            else:

                collection = c.rhodecode_repo.get_changesets(start=0,

                                                        branch_name=branch_name)

            c.total_cs = len(collection)

            c.pagination = RepoPage(collection, page=p, item_count=c.total_cs,

            collection = list(c.pagination)

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

            c.comments = c.rhodecode_db_repo.get_comments(page_revisions)

            c.statuses = c.rhodecode_db_repo.statuses(page_revisions)

        except (EmptyRepositoryError), e:

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

            return redirect(url('summary_home', repo_name=c.repo_name))

        except (RepositoryError, ChangesetDoesNotExistError, Exception), e:

            log.error(traceback.format_exc())

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

            return redirect(url('changelog_home', repo_name=c.repo_name))

        c.branch_name = branch_name

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

            [(k, k) for k in c.rhodecode_repo.branches.keys()]

        _revs = []

        if not f_path:

            _revs = [x.revision for x in c.pagination]

        self._graph(c.rhodecode_repo, _revs, c.total_cs, c.size, p)

        return render('changelog/changelog.html')

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                text = '%s' % (thispage,)

                # Wrap in a SPAN tag if nolink_attr is set

                if self.curpage_attr:

                    text = HTML.span(c=text, **self.curpage_attr)

                nav_items.append(text)

            # Otherwise create just a link to that page

            else:

                text = '%s' % (thispage,)

                nav_items.append(self._pagerlink(thispage, text))

        # Insert dots if there are pages between the displayed

        # page numbers and the end of the page range

        if self.last_page - rightmost_page > 1:

            text = '..'

            # Wrap in a SPAN tag if nolink_attr is set

            if self.dotdot_attr:

                text = HTML.span(c=text, **self.dotdot_attr)

            nav_items.append(text)

        # Create a link to the very last page (unless we are on the last

        # page or there would be no need to insert '..' spacers)

        if self.page != self.last_page and rightmost_page < self.last_page:

            nav_items.append(self._pagerlink(self.last_page, self.last_page))

        return self.separator.join(nav_items)

    def pager(self, format='~2~', page_param='page', partial_param='partial',

        show_if_single_page=False, separator=' ', onclick=None,

        symbol_first='<<', symbol_last='>>',

        symbol_previous='<', symbol_next='>',

        curpage_attr={'class': 'pager_curpage'},

        dotdot_attr={'class': 'pager_dotdot'}, **kwargs):

        self.curpage_attr = curpage_attr

        self.separator = separator

        self.pager_kwargs = kwargs

        self.page_param = page_param

        self.partial_param = partial_param

        self.onclick = onclick

        self.link_attr = link_attr

        self.dotdot_attr = dotdot_attr

        # Don't show navigator if there is no more than one page

        if self.page_count == 0 or (self.page_count == 1 and not show_if_single_page):

            return ''

        from string import Template

        # Replace ~...~ in token format by range of pages

        result = re.sub(r'~(\d+)~', self._range, format)

        # Interpolate '%' variables

        result = Template(result).safe_substitute({

            'first_page': self.first_page,

            'last_page': self.last_page,

    rhodecode.lib.indexers.__init__

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

    Whoosh indexing module for RhodeCode

    :created_on: Aug 17, 2010

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

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

import os

import sys

import logging

from os.path import dirname as dn, join as jn

#to get the rhodecode import

sys.path.append(dn(dn(dn(os.path.realpath(__file__)))))

from whoosh.analysis import RegexTokenizer, LowercaseFilter, StopFilter

from whoosh.fields import TEXT, ID, STORED, NUMERIC, BOOLEAN, Schema, FieldType, DATETIME

from whoosh.formats import Characters

from rhodecode.lib.utils2 import LazyProperty

log = logging.getLogger(__name__)

# CUSTOM ANALYZER wordsplit + lowercase filter

ANALYZER = RegexTokenizer(expression=r"\w+") | LowercaseFilter()

#INDEX SCHEMA DEFINITION

SCHEMA = Schema(

    fileid=ID(unique=True),

    owner=TEXT(),

    repository=TEXT(stored=True),

    path=TEXT(stored=True),

    content=FieldType(format=Characters(), analyzer=ANALYZER,

                      scorable=True, stored=True),

    modtime=STORED(),

    extension=TEXT(stored=True)

)

IDX_NAME = 'HG_INDEX'

FORMATTER = HtmlFormatter('span', between='\n<span class="break">...</span>\n')

FRAGMENTER = ContextFragmenter(200)

CHGSETS_SCHEMA = Schema(

    raw_id=ID(unique=True, stored=True),

    last=BOOLEAN(),

    owner=TEXT(),

    repository=ID(unique=True, stored=True),

    author=TEXT(stored=True),

    message=FieldType(format=Characters(), analyzer=ANALYZER,

                      scorable=True, stored=True),

    parents=TEXT(),

    added=TEXT(),

    removed=TEXT(),

    changed=TEXT(),

)

CHGSET_IDX_NAME = 'CHGSET_INDEX'

# used only to generate queries in journal

JOURNAL_SCHEMA = Schema(

    username=TEXT(),

    date=DATETIME(),

    action=TEXT(),

    repository=TEXT(),

    ip=TEXT(),

)

class WhooshResultWrapper(object):

    def __init__(self, search_type, searcher, matcher, highlight_items,

                 repo_location):

        self.search_type = search_type

        self.searcher = searcher

        self.matcher = matcher

        self.highlight_items = highlight_items

        self.fragment_size = 200

        self.repo_location = repo_location

    @LazyProperty

    def doc_ids(self):

        docs_id = []

        while self.matcher.is_active():

            docnum = self.matcher.id()

            chunks = [offsets for offsets in self.get_chunks()]

            docs_id.append([docnum, chunks])

            self.matcher.next()

        return docs_id

    def __str__(self):

        return '<%s at %s>' % (self.__class__.__name__, len(self.doc_ids))

    def __repr__(self):

                        'content_short_hl': self.highlight(content_short),

                        'f_path': f_path

                      })

        elif self.search_type == 'path':

            full_repo_path = jn(self.repo_location, res['repository'])

            f_path = res['path'].split(full_repo_path)[-1]

            f_path = f_path.lstrip(os.sep)

            res.update({'f_path': f_path})

        elif self.search_type == 'message':

            res.update({'message_hl': self.highlight(res['message'])})

        log.debug('result: %s' % res)

        return res

    def get_short_content(self, res, chunks):

        return ''.join([res['content'][chunk[0]:chunk[1]] for chunk in chunks])

    def get_chunks(self):

        """

        Smart function that implements chunking the content

        but not overlap chunks so it doesn't highlight the same

        close occurrences twice.

        """

        memory = [(0, 0)]

        if self.matcher.supports('positions'):

            for span in self.matcher.spans():

                start = span.startchar or 0

                end = span.endchar or 0

                start_offseted = max(0, start - self.fragment_size)

                end_offseted = end + self.fragment_size

                if start_offseted < memory[-1][1]:

                    start_offseted = memory[-1][1]

                memory.append((start_offseted, end_offseted,))

                yield (start_offseted, end_offseted,)

    def highlight(self, content, top=5):

        if self.search_type not in ['content', 'message']:

            return ''

            text=content,

            terms=self.highlight_items,

            analyzer=ANALYZER,

            fragmenter=FRAGMENTER,

            formatter=FORMATTER,

            top=top

        )

        return hl

    :created_on: mar 27, 2013

    :author: marcink

    :copyright: (C) 2010-2013 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

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

from __future__ import with_statement

import os

import sys

import logging

from rhodecode.model.meta import Session

rc_path = dn(dn(dn(os.path.realpath(__file__))))

sys.path.append(rc_path)

log = logging.getLogger(__name__)

class Command(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    group_name = "RhodeCode"

    takes_config_file = -1

    parser = BasePasterCommand.standard_parser(verbose=True)

    summary = "Cache keys utils"

    def command(self):

        #get SqlAlchemy session

        self._init_session()

        _caches = CacheInvalidation.query().order_by(CacheInvalidation.cache_key).all()

        if self.options.show:

            for c_obj in _caches:

                print 'key:%s active:%s' % (c_obj.cache_key, c_obj.cache_active)

        elif self.options.cleanup:

            for c_obj in _caches:

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

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

from __future__ import with_statement

import os

import sys

import re

import shutil

import logging

import datetime

from rhodecode.lib.utils import BasePasterCommand, ask_ok, REMOVED_REPO_PAT

from rhodecode.lib.utils2 import safe_str

from rhodecode.model.db import RhodeCodeUi

log = logging.getLogger(__name__)

class Command(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    group_name = "RhodeCode"

    takes_config_file = -1

    parser = BasePasterCommand.standard_parser(verbose=True)

    summary = "Cleanup deleted repos"

    def _parse_older_than(self, val):

        regex = re.compile(r'((?P<days>\d+?)d)?((?P<hours>\d+?)h)?((?P<minutes>\d+?)m)?((?P<seconds>\d+?)s)?')

        parts = regex.match(val)

        if not parts:

            return

        parts = parts.groupdict()

        time_params = {}

        for (name, param) in parts.iteritems():

            if param:

    :created_on: Apr 4, 2013

    :author: marcink

    :copyright: (C) 2010-2013 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

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

from __future__ import with_statement

import os

import sys

import logging

rc_path = dn(dn(dn(os.path.realpath(__file__))))

sys.path.append(rc_path)

log = logging.getLogger(__name__)

class Command(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    group_name = "RhodeCode"

    takes_config_file = -1

    parser = BasePasterCommand.standard_parser(verbose=True)

    summary = "Interactive shell"

    def command(self):

        #get SqlAlchemy session

        self._init_session()

        # imports, used in ipython shell

        import os

        import sys

        import time

        import shutil

    make-rcext paster command for RhodeCode

    :created_on: Mar 6, 2012

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

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

from __future__ import with_statement

import os

import sys

import pkg_resources

rc_path = dn(dn(dn(os.path.realpath(__file__))))

sys.path.append(rc_path)

log = logging.getLogger(__name__)

class Command(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    group_name = "RhodeCode"

    takes_config_file = -1

    parser = BasePasterCommand.standard_parser(verbose=True)

    summary = "Creates additional extensions for rhodecode"

    def command(self):

        logging.config.fileConfig(self.path_to_ini_file)

        from pylons import config

        def _make_file(ext_file, tmpl):

            bdir = os.path.split(ext_file)[0]

            if not os.path.isdir(bdir):

                os.makedirs(bdir)

            with open(ext_file, 'wb') as f:

                f.write(tmpl)

                log.info('Writen new extensions file to %s' % ext_file)

        here = config['here']

        tmpl = pkg_resources.resource_string(

        )

        if os.path.exists(ext_file):

            msg = ('Extension file already exists, do you want '

                   'to overwrite it ? [y/n]')

            if ask_ok(msg):

                _make_file(ext_file, tmpl)

            else:

                log.info('nothing done...')

        else:

            _make_file(ext_file, tmpl)

    def update_parser(self):

        pass

    :created_on: Feb 9, 2013

    :author: marcink

    :copyright: (C) 2010-2013 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

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

from __future__ import with_statement

import os

import sys

import logging

from rhodecode.model.scm import ScmModel

rc_path = dn(dn(dn(os.path.realpath(__file__))))

sys.path.append(rc_path)

log = logging.getLogger(__name__)

class Command(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    group_name = "RhodeCode"

    takes_config_file = -1

    parser = BasePasterCommand.standard_parser(verbose=True)

    summary = "Rescan default location for new repositories"

    def command(self):

        #get SqlAlchemy session

        self._init_session()

        rm_obsolete = self.options.delete_obsolete

        log.info('Now scanning root location for new repos...')

        added, removed = repo2db_mapper(ScmModel().repo_scan(),

                                        remove_obsolete=rm_obsolete)

        added = ','.join(added) or '-'

        removed = ','.join(removed) or '-'

import os

import sys

from paste.script.appinstall import AbstractInstallCommand

from paste.script.command import BadCommand

from paste.deploy import appconfig

rc_path = dn(dn(dn(os.path.realpath(__file__))))

sys.path.append(rc_path)

class Command(AbstractInstallCommand):

    default_verbosity = 1

    max_args = 1

    min_args = 1

    summary = "Setup an application, given a config file"

    usage = "CONFIG_FILE"

    group_name = "RhodeCode"

    description = """\

    Setup RhodeCode according to its configuration file.  This is

    the second part of a two-phase web application installation

    process (the first phase is prepare-app).  The setup process

    consist of things like setting up databases, creating super user

    """

    parser = AbstractInstallCommand.standard_parser(

        simulate=True, quiet=True, interactive=True)

    parser.add_option('--user',

    :created_on: Jul 14, 2012

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

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

from __future__ import with_statement

import os

import sys

import logging

import string

from rhodecode.lib.utils import BasePasterCommand

from rhodecode.model.db import Repository

from rhodecode.model.repo import RepoModel

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

class Command(BasePasterCommand):

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    group_name = "RhodeCode"

    takes_config_file = -1

    parser = BasePasterCommand.standard_parser(verbose=True)

    summary = "Updates repositories caches for last changeset"

    def command(self):

        #get SqlAlchemy session

        self._init_session()

        repo_update_list = map(string.strip,

                               self.options.repo_update_list.split(',')) \

                               if self.options.repo_update_list else None

        if repo_update_list:

            repo_list = Repository.query()\

            ('templates/**.mako', 'mako', {'input_encoding': 'utf-8'}),

            ('templates/**.html', 'mako', {'input_encoding': 'utf-8'}),

            ('public/**', 'ignore', None)]},

    zip_safe=False,

    paster_plugins=['PasteScript', 'Pylons'],

    entry_points="""

    [console_scripts]

    rhodecode-api =  rhodecode.bin.rhodecode_api:main

    rhodecode-gist =  rhodecode.bin.rhodecode_gist:main

    [paste.app_factory]

    main = rhodecode.config.middleware:make_app

    [paste.app_install]

    main = pylons.util:PylonsInstaller

    [paste.global_paster_command]

    setup-rhodecode=rhodecode.lib.paster_commands.setup_rhodecode:Command

    cleanup-repos=rhodecode.lib.paster_commands.cleanup:Command

    update-repoinfo=rhodecode.lib.paster_commands.update_repoinfo:Command

    make-rcext=rhodecode.lib.paster_commands.make_rcextensions:Command

    repo-scan=rhodecode.lib.paster_commands.repo_scan:Command

    cache-keys=rhodecode.lib.paster_commands.cache_keys:Command

    ishell=rhodecode.lib.paster_commands.ishell:Command

    upgrade-db=rhodecode.lib.dbmigrate:UpgradeDb

    celeryd=rhodecode.lib.celerypylons.commands:CeleryDaemonCommand

    """,

)