Beaker==1.6.2

WebHelpers>=1.2

formencode==1.2.4

SQLAlchemy==0.7.4

Mako==0.5.0

pygments>=1.4

celery>=2.2.5,<2.3

babel

python-dateutil>=1.5.0,<2.0.0

dulwich>=0.8.0,<0.9.0

vcs>=0.2.3.dev

webob==1.0.8

    "Beaker==1.6.2",

    "WebHelpers>=1.2",

    "formencode==1.2.4",

    "SQLAlchemy==0.7.4",

    "Mako==0.5.0",

    "pygments>=1.4",

    "celery>=2.2.5,<2.3",

    "babel",

    "python-dateutil>=1.5.0,<2.0.0",

    "dulwich>=0.8.0,<0.9.0",

    "vcs>=0.2.3.dev",

    "webob==1.0.8",

# 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 logging

import traceback

from pylons.i18n.translation import _

from rhodecode.lib.auth import LoginRequired

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.indexers import SCHEMA, IDX_NAME, ResultWrapper

from webhelpers.paginate import Page

                qp = QueryParser(search_type, schema=SCHEMA)

                if c.repo_name:

                    cur_query = u'repository:%s %s' % (c.repo_name, cur_query)

                try:

                    query = qp.parse(unicode(cur_query))

                    if isinstance(query, Phrase):

                        highlight_items.update(query.words)

                    elif isinstance(query, Prefix):

                        highlight_items.add(query.text)

                    else:

                        for i in query.all_terms():

                    matcher = query.matcher(searcher)

                    log.debug(query)

                    log.debug(highlight_items)

                    results = searcher.search(query)

                    res_ln = len(results)

                    def url_generator(**kw):

                        return update_params("?q=%s&type=%s" \

                                           % (c.cur_query, c.cur_search), **kw)

                    c.formated_results = Page(

                                ResultWrapper(search_type, searcher, matcher,

                                              highlight_items),

                except QueryParserError:

                    c.runtime = _('Invalid search query. Try quoting it.')

                searcher.close()

            except (EmptyIndexError, IOError):

                log.error(traceback.format_exc())

                c.runtime = _('There is no index to search in. '

                              'Please run whoosh indexer')

            except (Exception):

                log.error(traceback.format_exc())

                c.runtime = _('An error occurred during this search operation')

        # Return a rendered template

        return render('/search/search.html')

from shutil import rmtree

from whoosh.analysis import RegexTokenizer, LowercaseFilter, StopFilter

from whoosh.fields import TEXT, ID, STORED, Schema, FieldType

from whoosh.index import create_in, open_dir

from whoosh.formats import Characters

from webhelpers.html.builder import escape

from sqlalchemy import engine_from_config

from rhodecode.model import init_model

from rhodecode.model.scm import ScmModel

from rhodecode.model.repo import RepoModel

from rhodecode.config.environment import load_environment

from rhodecode.lib.utils import BasePasterCommand, Command, add_cache

#EXTENSIONS WE WANT TO INDEX CONTENT OFF

INDEX_EXTENSIONS = LANGUAGES_EXTENSIONS_MAP.keys()

#CUSTOM ANALYZER wordsplit + lowercase filter

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

#INDEX SCHEMA DEFINITION

                repository=TEXT(stored=True),

                path=TEXT(stored=True),

                             scorable=True, stored=True),

IDX_NAME = 'HG_INDEX'

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

class MakeIndex(BasePasterCommand):

    max_args = 1

    min_args = 1

class ResultWrapper(object):

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

        self.search_type = search_type

        self.searcher = searcher

        self.matcher = matcher

        self.highlight_items = highlight_items

    @LazyProperty

    def doc_ids(self):

        docs_id = []

        while self.matcher.is_active():

            docnum = self.matcher.id()

    def __getitem__(self, key):

        """

        Slicing of resultWrapper

        """

        i, j = key.start, key.stop

        for docid in self.doc_ids[i:j]:

    def get_full_content(self, docid):

        res = self.searcher.stored_fields(docid[0])

        f_path = res['path'][res['path'].find(res['repository']) \

                             + len(res['repository']):].lstrip('/')

            memory.append((start_offseted, end_offseted,))

            yield (start_offseted, end_offseted,)

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

        if self.search_type != 'content':

            return ''

                 analyzer=ANALYZER,

                 fragmenter=FRAGMENTER,

                 formatter=FORMATTER,

        return hl

from vcs.exceptions import ChangesetError, RepositoryError, \

    NodeDoesNotExistError

from whoosh.index import create_in, open_dir

log = logging.getLogger('whooshIndexer')

# create logger

log.setLevel(logging.DEBUG)

log.propagate = False

# create console handler and set level to debug

ch = logging.StreamHandler()

# add formatter to ch

ch.setFormatter(formatter)

# add ch to logger

log.addHandler(ch)

class WhooshIndexingDaemon(object):

    """

    Daemon for atomic jobs

    """

                 repo_location=None, sa=None, repo_list=None):

        self.indexname = indexname

        self.index_location = index_location

        if not index_location:

            raise Exception('You have to provide index location')

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

                if repo_name in repo_list:

                    filtered_repo_paths[repo_name] = repo

            self.repo_paths = filtered_repo_paths

        self.initial = False

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

            os.makedirs(self.index_location)

            log.info('Cannot run incremental index since it does not'

                     ' yet exist running full build')

            self.initial = True

                        repository=safe_unicode(repo_name),

                        path=safe_unicode(path),

                        content=u_content,

                        modtime=self.get_node_mtime(node),

                        extension=node.extension)

    def build_index(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):

                self.add_doc(writer, idx_path, repo, repo_name)

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

        writer.commit(merge=True)

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

    def update_index(self):

        log.debug('STARTING INCREMENTAL INDEXING UPDATE')

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

        # The set of all paths in the index

        indexed_paths = set()

div.codeblock .code-body table td {

	border: 0px !important;

}

div.code-body {

	background-color: #FFFFFF;

}

	background-color: #FAFFA6;

}

	background-color: #DDE7EF;

	width: 100%;

	color: #747474;

	display: block;

}

%for cnt,sr in enumerate(c.formated_results):

    %if h.HasRepoPermissionAny('repository.write','repository.read','repository.admin')(sr['repository'],'search results check'):

    <div class="table">

        <div id="body${cnt}" class="codeblock">

            <div class="code-header">

            </div>

                <pre>${h.literal(sr['content_short_hl'])}</pre>

            </div>

        </div>

    </div>

    %else:

        %if cnt == 0: