search: allow result sorting for elasticsearch6

rhodecode/apps/search/views.py

@@ -1,164 +1,169 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 import urllib
 from pyramid.view import view_config
 from webhelpers.util import update_params
 
 from rhodecode.apps._base import BaseAppView, RepoAppView, RepoGroupAppView
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator, HasRepoGroupPermissionAnyDecorator)
 from rhodecode.lib.helpers import Page
 from rhodecode.lib.utils2 import safe_str
 from rhodecode.lib.index import searcher_from_config
 from rhodecode.model import validation_schema
 from rhodecode.model.validation_schema.schemas import search_schema
 
 log = logging.getLogger(__name__)
 
 
 def perform_search(request, tmpl_context, repo_name=None, repo_group_name=None):
     searcher = searcher_from_config(request.registry.settings)
     formatted_results = []
     execution_time = ''
 
     schema = search_schema.SearchParamsSchema()
     search_tags = []
     search_params = {}
     errors = []
+
     try:
         search_params = schema.deserialize(
             dict(
                 search_query=request.GET.get('q'),
                 search_type=request.GET.get('type'),
                 search_sort=request.GET.get('sort'),
                 search_max_lines=request.GET.get('max_lines'),
                 page_limit=request.GET.get('page_limit'),
                 requested_page=request.GET.get('page'),
              )
         )
     except validation_schema.Invalid as e:
         errors = e.children
 
     def url_generator(**kw):
         q = urllib.quote(safe_str(search_query))
         return update_params(
-            "?q=%s&type=%s&max_lines=%s" % (
-                q, safe_str(search_type), search_max_lines), **kw)
+            "?q=%s&type=%s&max_lines=%s&sort=%s" % (
+                q, safe_str(search_type), search_max_lines, search_sort), **kw)
 
     c = tmpl_context
     search_query = search_params.get('search_query')
     search_type = search_params.get('search_type')
     search_sort = search_params.get('search_sort')
     search_max_lines = search_params.get('search_max_lines')
     if search_params.get('search_query'):
         page_limit = search_params['page_limit']
         requested_page = search_params['requested_page']
 
         try:
             search_result = searcher.search(
                 search_query, search_type, c.auth_user, repo_name, repo_group_name,
                 requested_page=requested_page, page_limit=page_limit, sort=search_sort)
 
             formatted_results = Page(
                 search_result['results'], page=requested_page,
                 item_count=search_result['count'],
                 items_per_page=page_limit, url=url_generator)
         finally:
             searcher.cleanup()
 
         search_tags = searcher.extract_search_tags(search_query)
 
         if not search_result['error']:
             execution_time = '%s results (%.4f seconds)' % (
                 search_result['count'],
                 search_result['runtime'])
         elif not errors:
             node = schema['search_query']
             errors = [
                 validation_schema.Invalid(node, search_result['error'])]
 
     c.perm_user = c.auth_user
     c.repo_name = repo_name
     c.repo_group_name = repo_group_name
-    c.sort = search_sort
     c.url_generator = url_generator
     c.errors = errors
     c.formatted_results = formatted_results
     c.runtime = execution_time
     c.cur_query = search_query
     c.search_type = search_type
     c.searcher = searcher
     c.search_tags = search_tags
 
+    direction, sort_field = searcher.get_sort(search_type, search_sort)
+    c.sort = '{}:{}'.format(direction, sort_field)
+    c.sort_tag = sort_field
+    c.sort_tag_dir = direction
+
 
 class SearchView(BaseAppView):
     def load_default_context(self):
         c = self._get_local_tmpl_context()
         return c
 
     @LoginRequired()
     @view_config(
         route_name='search', request_method='GET',
         renderer='rhodecode:templates/search/search.mako')
     def search(self):
         c = self.load_default_context()
         perform_search(self.request, c)
         return self._get_template_context(c)
 
 
 class SearchRepoView(RepoAppView):
     def load_default_context(self):
         c = self._get_local_tmpl_context()
         c.active = 'search'
         return c
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='search_repo', request_method='GET',
         renderer='rhodecode:templates/search/search.mako')
     @view_config(
         route_name='search_repo_alt', request_method='GET',
         renderer='rhodecode:templates/search/search.mako')
     def search_repo(self):
         c = self.load_default_context()
         perform_search(self.request, c, repo_name=self.db_repo_name)
         return self._get_template_context(c)
 
 
 class SearchRepoGroupView(RepoGroupAppView):
     def load_default_context(self):
         c = self._get_local_tmpl_context()
         c.active = 'search'
         return c
 
     @LoginRequired()
     @HasRepoGroupPermissionAnyDecorator(
         'group.read', 'group.write', 'group.admin')
     @view_config(
         route_name='search_repo_group', request_method='GET',
         renderer='rhodecode:templates/search/search.mako')
     def search_repo_group(self):
         c = self.load_default_context()
         perform_search(self.request, c, repo_group_name=self.db_repo_group_name)
         return self._get_template_context(c)

rhodecode/lib/index/__init__.py

@@ -1,110 +1,143 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Index schema for RhodeCode
 """
 
 import importlib
 import logging
 
 from rhodecode.lib.index.search_utils import normalize_text_for_matching
 
 log = logging.getLogger(__name__)
 
 # leave defaults for backward compat
 default_searcher = 'rhodecode.lib.index.whoosh'
 default_location = '%(here)s/data/index'
 
 ES_VERSION_2 = '2'
 ES_VERSION_6 = '6'
 # for legacy reasons we keep 2 compat as default
 DEFAULT_ES_VERSION = ES_VERSION_2
 
 from rhodecode_tools.lib.fts_index.elasticsearch_engine_6 import \
     ES_CONFIG  # pragma: no cover
 
 
 class BaseSearcher(object):
     query_lang_doc = ''
     es_version = None
     name = None
+    DIRECTION_ASC = 'asc'
+    DIRECTION_DESC = 'desc'
 
     def __init__(self):
         pass
 
     def cleanup(self):
         pass
 
     def search(self, query, document_type, search_user,
                repo_name=None, repo_group_name=None,
                raise_on_exc=True):
         raise Exception('NotImplemented')
 
     @staticmethod
     def query_to_mark(query, default_field=None):
         """
         Formats the query to mark token for jquery.mark.js highlighting. ES could
         have a different format optionally.
 
         :param default_field:
         :param query:
         """
         return ' '.join(normalize_text_for_matching(query).split())
 
     @property
     def is_es_6(self):
         return self.es_version == ES_VERSION_6
 
     def get_handlers(self):
         return {}
 
     @staticmethod
     def extract_search_tags(query):
         return []
 
     @staticmethod
     def escape_specials(val):
         """
         Handle and escape reserved chars for search
         """
         return val
 
+    @staticmethod
+    def get_sort(search_type, search_val):
+        """
+        Method used to parse the GET search sort value to a field and direction.
+        e.g asc:lines == asc, lines
+
+        There's also a legacy support for newfirst/oldfirst which defines commit
+        sorting only
+        """
+
+        direction = BaseSearcher.DIRECTION_ASC
+        sort_field = None
+
+        if not search_val:
+            return direction, sort_field
+
+        if search_val.startswith('asc:'):
+            sort_field = search_val[4:]
+            direction = BaseSearcher.DIRECTION_ASC
+        elif search_val.startswith('desc:'):
+            sort_field = search_val[5:]
+            direction = BaseSearcher.DIRECTION_DESC
+        elif search_val == 'newfirst' and search_type == 'commit':
+            sort_field = 'date'
+            direction = BaseSearcher.DIRECTION_DESC
+        elif search_val == 'oldfirst' and search_type == 'commit':
+            sort_field = 'date'
+            direction = BaseSearcher.DIRECTION_ASC
+
+        return direction, sort_field
+
 
 def search_config(config, prefix='search.'):
     _config = {}
     for key in config.keys():
         if key.startswith(prefix):
             _config[key[len(prefix):]] = config[key]
     return _config
 
 
 def searcher_from_config(config, prefix='search.'):
     _config = search_config(config, prefix)
 
     if 'location' not in _config:
         _config['location'] = default_location
     if 'es_version' not in _config:
         # use old legacy ES version set to 2
         _config['es_version'] = '2'
 
     imported = importlib.import_module(_config.get('module', default_searcher))
     searcher = imported.Searcher(config=_config)
     return searcher

rhodecode/model/validation_schema/schemas/search_schema.py

@@ -1,46 +1,58 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2019 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import colander
 
 
+def sort_validator(node, value):
+    if value in ['oldfirst', 'newfirst']:
+        return value
+    if value.startswith('asc:'):
+        return value
+    if value.startswith('desc:'):
+        return value
+
+    msg = u'Invalid search sort, must be `oldfirst`, `newfirst`, or start with asc: or desc:'
+    raise colander.Invalid(node, msg)
+
+
 class SearchParamsSchema(colander.MappingSchema):
     search_query = colander.SchemaNode(
         colander.String(),
         missing='')
     search_type = colander.SchemaNode(
         colander.String(),
         missing='content',
         validator=colander.OneOf(['content', 'path', 'commit', 'repository']))
     search_sort = colander.SchemaNode(
         colander.String(),
         missing='newfirst',
-        validator=colander.OneOf(['oldfirst', 'newfirst']))
+        validator=sort_validator)
     search_max_lines = colander.SchemaNode(
         colander.Integer(),
         missing=10)
     page_limit = colander.SchemaNode(
         colander.Integer(),
         missing=10,
         validator=colander.Range(1, 500))
     requested_page = colander.SchemaNode(
         colander.Integer(),
         missing=1)

rhodecode/templates/search/search.mako

@@ -1,217 +1,241 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.mako"/>
 
 <%def name="title()">
     %if c.repo_name:
         ${_('Search inside repository {repo_name}').format(repo_name=c.repo_name)}
     %elif c.repo_group_name:
         ${_('Search inside repository group {repo_group_name}').format(repo_group_name=c.repo_group_name)}
     %else:
         ${_('Search inside all accessible repositories')}
     %endif
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}
     %endif
 </%def>
 
 <%def name="breadcrumbs_links()">
   %if c.repo_name:
     ${_('Search inside repository {repo_name}').format(repo_name=c.repo_name)}
   %elif c.repo_group_name:
     ${_('Search inside repository group {repo_group_name}').format(repo_group_name=c.repo_group_name)}
   %else:
     ${_('Search inside all accessible repositories')}
   %endif
 
 </%def>
 
 <%def name="menu_bar_nav()">
     %if c.repo_name:
     ${self.menu_items(active='search')}
     %elif c.repo_group_name:
     ${self.menu_items(active='search')}
     %else:
     ${self.menu_items(active='search')}
     %endif
 </%def>
 
 <%def name="menu_bar_subnav()">
     %if c.repo_name:
         <% active_entry = {'content':'files', 'path':'files', 'commit':'commits'}.get(c.search_type, 'summary')%>
         ${self.repo_menu(active=active_entry)}
     %elif c.repo_group_name:
         ${self.repo_group_menu(active='home')}
     %endif
 </%def>
 
 <%def name="repo_icon(db_repo)">
     %if h.is_hg(db_repo):
         <i class="icon-hg"></i>
     %endif
     %if h.is_git(db_repo):
         <i class="icon-git"></i>
     %endif
     %if h.is_svn(db_repo):
         <i class="icon-svn"></i>
     %endif
 </%def>
 
 <%def name="repo_group_icon()">
     <i class="icon-repo-group"></i>
 </%def>
 
+
+<%def name="field_sort(field_name)">
+
+    <%
+    if c.sort.startswith('asc:'):
+        return c.url_generator(sort='desc:{}'.format(field_name))
+    elif c.sort.startswith('desc:'):
+        return c.url_generator(sort='asc:{}'.format(field_name))
+
+    return 'asc:{}'.format(field_name)
+    %>
+</%def>
+
+
 <%def name="main()">
 <div class="box">
     %if c.repo_name:
         <!-- box / title -->
         ${h.form(h.route_path('search_repo',repo_name=c.repo_name),method='get')}
     %elif c.repo_group_name:
         <!-- box / title -->
         ${h.form(h.route_path('search_repo_group',repo_group_name=c.repo_group_name),method='get')}
     %else:
         <!-- box / title -->
         <div class="title">
             ${self.breadcrumbs()}
             <ul class="links">&nbsp;</ul>
         </div>
         <!-- end box / title -->
         ${h.form(h.route_path('search'), method='get')}
     %endif
     <div class="form search-form">
         <div class="fields">
 
             ${h.text('q', c.cur_query, placeholder="Enter query...")}
 
             ${h.select('type',c.search_type,[('content',_('Files')), ('path',_('File path')),('commit',_('Commits'))],id='id_search_type')}
             ${h.hidden('max_lines', '10')}
 
             <input type="submit" value="${_('Search')}" class="btn"/>
             <br/>
 
             <div class="search-tags">
                 <span class="tag tag8">
                     %if c.repo_name:
                         <a href="${h.route_path('search', _query={'q': c.cur_query, 'type': request.GET.get('type', 'content')})}">${_('Global Search')}</a>
                     %elif c.repo_group_name:
                         <a href="${h.route_path('search', _query={'q': c.cur_query, 'type': request.GET.get('type', 'content')})}">${_('Global Search')}</a>
                     % else:
                         ${_('Global Search')}
                     %endif
                 </span>
 
             %if c.repo_name:
                 »
                 <span class="tag tag8">
                     ${repo_icon(c.rhodecode_db_repo)}
                     ${c.repo_name}
                 </span>
 
             %elif c.repo_group_name:
                 »
                 <span class="tag tag8">
                     ${repo_group_icon()}
                     ${c.repo_group_name}
                 </span>
             %endif
 
+            % if c.sort_tag:
+                <span class="tag tag8">
+                    % if c.sort_tag_dir == 'asc':
+                        <i class="icon-angle-down"></i>
+                    % elif c.sort_tag_dir == 'desc':
+                        <i class="icon-angle-up"></i>
+                    % endif
+                    ${_('sort')}:${c.sort_tag}
+                </span>
+            % endif
 
             % for search_tag in c.search_tags:
                 <br/><span class="tag disabled" style="margin-top: 3px">${search_tag}</span>
             % endfor
 
             </div>
 
             <div class="search-feedback-items">
             % for error in c.errors:
               <span class="error-message">
                   % for k,v in error.asdict().items():
                     ${k} - ${v}
                   % endfor
               </span>
             % endfor
             <div class="field">
-                <p class="filterexample" style="position: inherit" onclick="$('#search-help').toggle()">${_('Query Langague examples')}</p>
+                <p class="filterexample" style="position: inherit" onclick="$('#search-help').toggle()">${_('Query Language examples')}</p>
 <pre id="search-help" style="display: none">\
 
 % if c.searcher.name == 'whoosh':
 Example filter terms for `Whoosh` search:
 query lang: <a href="${c.searcher.query_lang_doc}">Whoosh Query Language</a>
 Whoosh has limited query capabilities. For advanced search use ElasticSearch 6 from RhodeCode EE edition.
 
 Generate wildcards using '*' character:
   "repo_name:vcs*" - search everything starting with 'vcs'
   "repo_name:*vcs*" - search for repository containing 'vcs'
 
 Optional AND / OR operators in queries
   "repo_name:vcs OR repo_name:test"
   "owner:test AND repo_name:test*" AND extension:py
 
 Move advanced search is available via ElasticSearch6 backend in EE edition.
 % elif c.searcher.name == 'elasticsearch' and c.searcher.es_version == '2':
 Example filter terms for `ElasticSearch-${c.searcher.es_version}`search:
 ElasticSearch-2 has limited query capabilities. For advanced search use ElasticSearch 6 from RhodeCode EE edition.
 
 search type: content (File Content)
   indexed fields: content
 
   # search for `fix` string in all files
   fix
 
 search type: commit (Commit message)
   indexed fields: message
 
 search type: path (File name)
   indexed fields: path
 
 % else:
 Example filter terms for `ElasticSearch-${c.searcher.es_version}`search:
 query lang: <a href="${c.searcher.query_lang_doc}">ES 6 Query Language</a>
 The reserved characters needed espace by `\`: + - = && || > < ! ( ) { } [ ] ^ " ~ * ? : \ /
 % for handler in c.searcher.get_handlers().values():
 
 search type: ${handler.search_type_label}
   *indexed fields*: ${', '.join( [('\n    ' if x[0]%4==0 else '')+x[1] for x in enumerate(handler.es_6_field_names)])}
   % for entry in handler.es_6_example_queries:
   ${entry.rstrip()}
   % endfor
 % endfor
 
 % endif
 </pre>
             </div>
 
             <div class="field">${c.runtime}</div>
             </div>
         </div>
     </div>
 
     ${h.end_form()}
     <div class="search">
     % if c.search_type == 'content':
         <%include file='search_content.mako'/>
     % elif c.search_type == 'path':
         <%include file='search_path.mako'/>
     % elif c.search_type == 'commit':
         <%include file='search_commit.mako'/>
     % elif c.search_type == 'repository':
         <%include file='search_repository.mako'/>
     % endif
     </div>
 </div>
 <script>
     $(document).ready(function(){
         $("#id_search_type").select2({
             'containerCssClass': "drop-menu",
             'dropdownCssClass': "drop-menu-dropdown",
             'dropdownAutoWidth': true,
             'minimumResultsForSearch': -1
         });
 
         $('#q').autoGrowInput({maxWidth: 920});
 
         setTimeout(function() {
             $('#q').keyup()
         }, 1);
     })
 </script>
 </%def>

rhodecode/templates/search/search_commit.mako

@@ -1,98 +1,98 b''
 <%namespace name="base" file="/base/base.mako"/>
 <%namespace name="search" file="/search/search.mako"/>
 
 % if c.formatted_results:
 
 <table class="rctable search-results">
     <tr>
         <th>${_('Repository')}</th>
         <th>${_('Commit')}</th>
         <th></th>
-        <th>${_('Commit message')}</th>
+        <th>
+            <a href="${search.field_sort('message.raw')}">${_('Commit message')}</a>
+        </th>
         <th>
-        %if c.sort == 'newfirst':
-            <a href="${c.url_generator(sort='oldfirst')}">${_('Age (new first)')}</a>
-        %else:
-            <a href="${c.url_generator(sort='newfirst')}">${_('Age (old first)')}</a>
-        %endif
+            <a href="${search.field_sort('date')}">${_('Age')}</a>
         </th>
-        <th>${_('Author')}</th>
+        <th>
+            <a href="${search.field_sort('author.email.raw')}">${_('Author')}</a>
+        </th>
     </tr>
     %for entry in c.formatted_results:
         ## search results are additionally filtered, and this check is just a safe gate
         % if c.rhodecode_user.is_admin or h.HasRepoPermissionAny('repository.write','repository.read','repository.admin')(entry['repository'], 'search results commit check'):
             <tr class="body">
                 <td class="td-componentname">
                     <% repo_type = entry.get('repo_type') or h.get_repo_type_by_name(entry.get('repository')) %>
                     ${search.repo_icon(repo_type)}
                     ${h.link_to(entry['repository'], h.route_path('repo_summary',repo_name=entry['repository']))}
                 </td>
                 <td class="td-hash">
                     ${h.link_to(h._shorten_commit_id(entry['commit_id']),
                       h.route_path('repo_commit',repo_name=entry['repository'],commit_id=entry['commit_id']))}
                 </td>
                 <td class="td-message expand_commit search open" data-commit-id="${h.md5_safe(entry['repository'])+entry['commit_id']}" id="t-${h.md5_safe(entry['repository'])+entry['commit_id']}" title="${_('Expand commit message')}">
                     <div>
                     <i class="icon-expand-linked"></i>&nbsp;
                     </div>
                 </td>
                 <td data-commit-id="${h.md5_safe(entry['repository'])+entry['commit_id']}" id="c-${h.md5_safe(entry['repository'])+entry['commit_id']}" class="message td-description open">
                     %if entry.get('message_hl'):
                         ${h.literal(entry['message_hl'])}
                     %else:
                         ${h.urlify_commit_message(entry['message'], entry['repository'])}
                     %endif
                 </td>
                 <td class="td-time">
                     ${h.age_component(h.time_to_utcdatetime(entry['date']))}
                 </td>
 
                 <td class="td-user author">
                     <%
                     ## es6 stores this as object
                     author = entry['author']
                     if isinstance(author, dict):
                         author = author['email']
                     %>
                     ${base.gravatar_with_user(author)}
                 </td>
             </tr>
         % endif
     %endfor
 </table>
 
 %if c.cur_query:
 <div class="pagination-wh pagination-left">
     ${c.formatted_results.pager('$link_previous ~2~ $link_next')}
 </div>
 %endif
 
 <script>
     $('.expand_commit').on('click',function(e){
       var target_expand = $(this);
       var cid = target_expand.data('commit-id');
 
       if (target_expand.hasClass('open')){
         $('#c-'+cid).css({'height': '1.5em', 'white-space': 'nowrap', 'text-overflow': 'ellipsis', 'overflow':'hidden'});
         $('#t-'+cid).css({'height': 'auto', 'line-height': '.9em', 'text-overflow': 'ellipsis', 'overflow':'hidden'});
         target_expand.removeClass('open');
       }
       else {
         $('#c-'+cid).css({'height': 'auto', 'white-space': 'normal', 'text-overflow': 'initial', 'overflow':'visible'});
         $('#t-'+cid).css({'height': 'auto', 'max-height': 'none', 'text-overflow': 'initial', 'overflow':'visible'});
         target_expand.addClass('open');
       }
     });
 
     $(".message.td-description").mark(
         "${c.searcher.query_to_mark(c.cur_query, 'message')}",
         {
             "className": 'match',
             "accuracy": "complementary",
             "ignorePunctuation": ":._(){}[]!'+=".split("")
         }
     );
 
 </script>
 
 % endif

rhodecode/templates/search/search_path.mako

@@ -1,46 +1,53 b''
 <%namespace name="search" file="/search/search.mako"/>
 
 % if c.formatted_results:
 
 <table class="rctable search-results">
     <tr>
         <th>${_('Repository')}</th>
-        <th>${_('File')}</th>
-        <th>${_('Size')}</th>
-        <th>${_('Lines')}</th>
+        <th>
+            <a href="${search.field_sort('file.raw')}">${_('File')}</a>
+        </th>
+        <th>
+            <a href="${search.field_sort('size')}">${_('Size')}</a>
+        </th>
+        <th>
+            <a href="${search.field_sort('lines')}">${_('Lines')}</a>
+        </th>
     </tr>
     %for entry in c.formatted_results:
         ## search results are additionally filtered, and this check is just a safe gate
         % if c.rhodecode_user.is_admin or h.HasRepoPermissionAny('repository.write','repository.read','repository.admin')(entry['repository'], 'search results path check'):
             <tr class="body">
                 <td class="td-componentname">
                     <% repo_type = entry.get('repo_type') or h.get_repo_type_by_name(entry.get('repository')) %>
                     ${search.repo_icon(repo_type)}
                     ${h.link_to(entry['repository'], h.route_path('repo_summary',repo_name=entry['repository']))}
                 </td>
                 <td class="td-componentname">
+                    <i class="icon-file"></i>
                     ${h.link_to(h.literal(entry['f_path']),
                         h.route_path('repo_files',repo_name=entry['repository'],commit_id='tip',f_path=entry['f_path']))}
                 </td>
                 <td>
                     %if entry.get('size'):
                       ${h.format_byte_size_binary(entry['size'])}
                     %endif
                 </td>
                 <td>
                     %if entry.get('lines'):
-                      ${entry.get('lines', 0.)} ${_ungettext('line', 'lines', entry.get('lines', 0.))}
+                      ${entry.get('lines', 0.)}
                     %endif
                 </td>
             </tr>
         % endif
     %endfor
 </table>
 
 %if c.cur_query:
 <div class="pagination-wh pagination-left">
     ${c.formatted_results.pager('$link_previous ~2~ $link_next')}
 </div>
 %endif
 
 % endif