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

# 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/>.

"""

kallithea.controllers.search

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

Search controller for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Aug 7, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import traceback

import urllib

from tg.i18n import ugettext as _

from tg import request, config, tmpl_context as c

from whoosh.index import open_dir, exists_in, EmptyIndexError

from whoosh.qparser import QueryParser, QueryParserError

from whoosh.query import Phrase, Prefix

from webhelpers.util import update_params

from kallithea.lib.auth import LoginRequired

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.indexers import CHGSETS_SCHEMA, SCHEMA, CHGSET_IDX_NAME, \

    IDX_NAME, WhooshResultWrapper

from kallithea.lib.page import Page

from kallithea.lib.utils2 import safe_str, safe_int

from kallithea.model.repo import RepoModel

log = logging.getLogger(__name__)

class SearchController(BaseRepoController):

    @LoginRequired(allow_default_user=True)

    def index(self, repo_name=None):

        c.repo_name = repo_name

        c.formated_results = []

        c.runtime = ''

        c.cur_query = request.GET.get('q', None)

        c.cur_type = request.GET.get('type', 'content')

        c.cur_search = search_type = {'content': 'content',

                                      'commit': 'message',

                                      'path': 'path',

                                      'repository': 'repository'

                                      }.get(c.cur_type, 'content')

        index_name = {

            'content': IDX_NAME,

            'commit': CHGSET_IDX_NAME,

            'path': IDX_NAME

        }.get(c.cur_type, IDX_NAME)

        schema_defn = {

            'content': SCHEMA,

            'commit': CHGSETS_SCHEMA,

            'path': SCHEMA

        }.get(c.cur_type, SCHEMA)

        log.debug('IDX: %s', index_name)

        log.debug('SCHEMA: %s', schema_defn)

        if c.cur_query:

            cur_query = c.cur_query.lower()

            log.debug(cur_query)

        if c.cur_query:

            p = safe_int(request.GET.get('page'), 1)

            highlight_items = set()

            index_dir = config['app_conf']['index_dir']

            try:

                if not exists_in(index_dir, index_name):

                    raise EmptyIndexError

                idx = open_dir(index_dir, indexname=index_name)

                searcher = idx.searcher()

                qp = QueryParser(search_type, schema=schema_defn)

                if c.repo_name:

                    # use "repository_rawname:" instead of "repository:"

                    # for case-sensitive matching

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

                try:

                    query = qp.parse(unicode(cur_query))

                    # extract words for highlight

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

                            if i[0] in ['content', 'message']:

                                highlight_items.add(i[1])

                    matcher = query.matcher(searcher)

                    log.debug('query: %s', query)

                    log.debug('hl terms: %s', highlight_items)

                    results = searcher.search(query)

                    res_ln = len(results)

                    c.runtime = '%s results (%.3f seconds)' % (

                        res_ln, results.runtime

                    )

                    def url_generator(**kw):

                        q = urllib.quote(safe_str(c.cur_query))

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

                        % (q, safe_str(c.cur_type)), **kw)

                    repo_location = RepoModel().repos_path

                    c.formated_results = Page(

                        WhooshResultWrapper(search_type, searcher, matcher,

                                            highlight_items, repo_location),

                        page=p,

                        item_count=res_ln,

                        items_per_page=10,

                        url=url_generator

                    )

                except QueryParserError:

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

                searcher.close()

            except EmptyIndexError:

            except Exception:

                log.error(traceback.format_exc())

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

        # Return a rendered template

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

import mock

import os

from kallithea.tests.base import *

class TestSearchController(TestController):

    def test_index(self):

        self.log_user()

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

        response.mustcontain('class="form-control" id="q" name="q" type="text"')

        # Test response...

    def test_empty_search(self, tmpdir):

        self.log_user()

        config_mock = {

            'app_conf': {

                # can be any existing dir that does not contain an actual index

                'index_dir': str(tmpdir),

            }

        }

        with mock.patch('kallithea.controllers.search.config', config_mock):

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

                                    {'q': HG_REPO})

    def test_normal_search(self):

        self.log_user()

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

                                {'q': 'def repo'})

        response.mustcontain('58 results')

    def test_repo_search(self):

        self.log_user()

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

                                {'q': 'repository:%s def test' % HG_REPO})

        response.mustcontain('18 results')

    def test_search_last(self):

        self.log_user()

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

                                {'q': 'last:t', 'type': 'commit'})

        response.mustcontain('2 results')

    def test_search_commit_message(self):

        self.log_user()

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

                    {'q': 'bother to ask where to fetch repo during tests',

                     'type': 'commit'})

        response.mustcontain('2 results')

        response.mustcontain('a00c1b6f5d7a6ae678fd553a8b81d92367f7ecf1')

        response.mustcontain('c6eb379775c578a95dad8ddab53f963b80894850')

    def test_search_commit_message_hg_repo(self):

        self.log_user()

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

                                    repo_name=HG_REPO),

                    {'q': 'bother to ask where to fetch repo during tests',

                     'type': 'commit'})

        response.mustcontain('1 results')

        response.mustcontain('a00c1b6f5d7a6ae678fd553a8b81d92367f7ecf1')

    def test_search_commit_changed_file(self):

        self.log_user()

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

                                {'q': 'changed:tests/utils.py',

                                 'type': 'commit'})

        response.mustcontain('29 results')

    def test_search_commit_changed_files_get_commit(self):

        self.log_user()

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

                                {'q': 'changed:vcs/utils/archivers.py',

                                 'type': 'commit'})

        response.mustcontain('8 results')

        response.mustcontain('25213a5fbb048dff8ba65d21e466a835536e5b70')

        response.mustcontain('47aedd538bf616eedcb0e7d630ea476df0e159c7')

        response.mustcontain('f5d23247fad4856a1dabd5838afade1e0eed24fb')

        response.mustcontain('04ad456aefd6461aea24f90b63954b6b1ce07b3e')

        response.mustcontain('c994f0de03b2a0aa848a04fc2c0d7e737dba31fc')

        response.mustcontain('d1f898326327e20524fe22417c22d71064fe54a1')

        response.mustcontain('fe568b4081755c12abf6ba673ba777fc02a415f3')

        response.mustcontain('bafe786f0d8c2ff7da5c1dcfcfa577de0b5e92f1')

    def test_search_commit_added_file(self):

        self.log_user()

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

                                {'q': 'added:README.rst',

                                 'type': 'commit'})

        response.mustcontain('2 results')

        # Hg

        response.mustcontain('3803844fdbd3b711175fc3da9bdacfcd6d29a6fb')

        # Git

        response.mustcontain('ff7ca51e58c505fec0dd2491de52c622bb7a806b')

    def test_search_author(self):

        self.log_user()

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

                    {'q': 'author:marcin@python-blog.com raw_id:b986218ba1c9b0d6a259fac9b050b1724ed8e545',

                     'type': 'commit'})

        response.mustcontain('1 results')

    def test_search_file_name(self):

        self.log_user()

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

                    {'q': 'README.rst', 'type': 'path'})

        response.mustcontain('2 results')