files: fixed the repo switcher at flag beeing nor persistens

- additionally SVN now reports nice switchet refs as other types of vcs
- fixes  #5610
- references  #5599 (org issue)

rhodecode/apps/repository/views/repo_files.py

@@ -1,1555 +1,1568 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 itertools
 import logging
 import os
 import shutil
 import tempfile
 import collections
 import urllib
 import pathlib2
 
 from pyramid.httpexceptions import HTTPNotFound, HTTPBadRequest, HTTPFound
 from pyramid.view import view_config
 from pyramid.renderers import render
 from pyramid.response import Response
 
 import rhodecode
 from rhodecode.apps._base import RepoAppView
 
 
 from rhodecode.lib import diffs, helpers as h, rc_cache
 from rhodecode.lib import audit_logger
 from rhodecode.lib.view_utils import parse_path_ref
 from rhodecode.lib.exceptions import NonRelativePathError
 from rhodecode.lib.codeblocks import (
     filenode_as_lines_tokens, filenode_as_annotated_lines_tokens)
 from rhodecode.lib.utils2 import (
     convert_line_endings, detect_mode, safe_str, str2bool, safe_int, sha1, safe_unicode)
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator, CSRFRequired)
 from rhodecode.lib.vcs import path as vcspath
 from rhodecode.lib.vcs.backends.base import EmptyCommit
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.lib.vcs.exceptions import (
     RepositoryError, CommitDoesNotExistError, EmptyRepositoryError,
     ImproperArchiveTypeError, VCSError, NodeAlreadyExistsError,
     NodeDoesNotExistError, CommitError, NodeError)
 
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.db import Repository
 
 log = logging.getLogger(__name__)
 
 
 class RepoFilesView(RepoAppView):
 
     @staticmethod
     def adjust_file_path_for_svn(f_path, repo):
         """
         Computes the relative path of `f_path`.
 
         This is mainly based on prefix matching of the recognized tags and
         branches in the underlying repository.
         """
         tags_and_branches = itertools.chain(
             repo.branches.iterkeys(),
             repo.tags.iterkeys())
         tags_and_branches = sorted(tags_and_branches, key=len, reverse=True)
 
         for name in tags_and_branches:
             if f_path.startswith('{}/'.format(name)):
                 f_path = vcspath.relpath(f_path, name)
                 break
         return f_path
 
     def load_default_context(self):
         c = self._get_local_tmpl_context(include_app_defaults=True)
         c.rhodecode_repo = self.rhodecode_vcs_repo
         c.enable_downloads = self.db_repo.enable_downloads
         return c
 
     def _ensure_not_locked(self, commit_id='tip'):
         _ = self.request.translate
 
         repo = self.db_repo
         if repo.enable_locking and repo.locked[0]:
             h.flash(_('This repository has been locked by %s on %s')
                     % (h.person_by_id(repo.locked[0]),
                     h.format_date(h.time_to_datetime(repo.locked[1]))),
                     'warning')
             files_url = h.route_path(
                 'repo_files:default_path',
                 repo_name=self.db_repo_name, commit_id=commit_id)
             raise HTTPFound(files_url)
 
     def forbid_non_head(self, is_head, f_path, commit_id='tip', json_mode=False):
         _ = self.request.translate
 
         if not is_head:
             message = _('Cannot modify file. '
                         'Given commit `{}` is not head of a branch.').format(commit_id)
             h.flash(message, category='warning')
 
             if json_mode:
                 return message
 
             files_url = h.route_path(
                 'repo_files', repo_name=self.db_repo_name, commit_id=commit_id,
                 f_path=f_path)
             raise HTTPFound(files_url)
 
     def check_branch_permission(self, branch_name, commit_id='tip', json_mode=False):
         _ = self.request.translate
 
         rule, branch_perm = self._rhodecode_user.get_rule_and_branch_permission(
             self.db_repo_name, branch_name)
         if branch_perm and branch_perm not in ['branch.push', 'branch.push_force']:
             message = _('Branch `{}` changes forbidden by rule {}.').format(
                 branch_name, rule)
             h.flash(message, 'warning')
 
             if json_mode:
                 return message
 
             files_url = h.route_path(
                 'repo_files:default_path', repo_name=self.db_repo_name, commit_id=commit_id)
 
             raise HTTPFound(files_url)
 
     def _get_commit_and_path(self):
         default_commit_id = self.db_repo.landing_rev[1]
         default_f_path = '/'
 
         commit_id = self.request.matchdict.get(
             'commit_id', default_commit_id)
         f_path = self._get_f_path(self.request.matchdict, default_f_path)
         return commit_id, f_path
 
     def _get_default_encoding(self, c):
         enc_list = getattr(c, 'default_encodings', [])
         return enc_list[0] if enc_list else 'UTF-8'
 
     def _get_commit_or_redirect(self, commit_id, redirect_after=True):
         """
         This is a safe way to get commit. If an error occurs it redirects to
         tip with proper message
 
         :param commit_id: id of commit to fetch
         :param redirect_after: toggle redirection
         """
         _ = self.request.translate
 
         try:
             return self.rhodecode_vcs_repo.get_commit(commit_id)
         except EmptyRepositoryError:
             if not redirect_after:
                 return None
 
             _url = h.route_path(
                 'repo_files_add_file',
                 repo_name=self.db_repo_name, commit_id=0, f_path='')
 
             if h.HasRepoPermissionAny(
                     'repository.write', 'repository.admin')(self.db_repo_name):
                 add_new = h.link_to(
                     _('Click here to add a new file.'), _url, class_="alert-link")
             else:
                 add_new = ""
 
             h.flash(h.literal(
                 _('There are no files yet. %s') % add_new), category='warning')
             raise HTTPFound(
                 h.route_path('repo_summary', repo_name=self.db_repo_name))
 
         except (CommitDoesNotExistError, LookupError):
             msg = _('No such commit exists for this repository')
             h.flash(msg, category='error')
             raise HTTPNotFound()
         except RepositoryError as e:
             h.flash(safe_str(h.escape(e)), category='error')
             raise HTTPNotFound()
 
     def _get_filenode_or_redirect(self, commit_obj, path):
         """
         Returns file_node, if error occurs or given path is directory,
         it'll redirect to top level path
         """
         _ = self.request.translate
 
         try:
             file_node = commit_obj.get_node(path)
             if file_node.is_dir():
                 raise RepositoryError('The given path is a directory')
         except CommitDoesNotExistError:
             log.exception('No such commit exists for this repository')
             h.flash(_('No such commit exists for this repository'), category='error')
             raise HTTPNotFound()
         except RepositoryError as e:
             log.warning('Repository error while fetching filenode `%s`. Err:%s', path, e)
             h.flash(safe_str(h.escape(e)), category='error')
             raise HTTPNotFound()
 
         return file_node
 
     def _is_valid_head(self, commit_id, repo):
         branch_name = sha_commit_id = ''
         is_head = False
         log.debug('Checking if commit_id `%s` is a head for %s.', commit_id, repo)
 
         for _branch_name, branch_commit_id in repo.branches.items():
             # simple case we pass in branch name, it's a HEAD
             if commit_id == _branch_name:
                 is_head = True
                 branch_name = _branch_name
                 sha_commit_id = branch_commit_id
                 break
             # case when we pass in full sha commit_id, which is a head
             elif commit_id == branch_commit_id:
                 is_head = True
                 branch_name = _branch_name
                 sha_commit_id = branch_commit_id
                 break
 
         if h.is_svn(repo) and not repo.is_empty():
             # Note: Subversion only has one head.
             if commit_id == repo.get_commit(commit_idx=-1).raw_id:
                 is_head = True
                 return branch_name, sha_commit_id, is_head
 
         # checked branches, means we only need to try to get the branch/commit_sha
         if not repo.is_empty():
             commit = repo.get_commit(commit_id=commit_id)
             if commit:
                 branch_name = commit.branch
                 sha_commit_id = commit.raw_id
 
         return branch_name, sha_commit_id, is_head
 
-    def _get_tree_at_commit(self, c, commit_id, f_path, full_load=False):
+    def _get_tree_at_commit(self, c, commit_id, f_path, full_load=False, at_rev=None):
 
         repo_id = self.db_repo.repo_id
         force_recache = self.get_recache_flag()
 
         cache_seconds = safe_int(
             rhodecode.CONFIG.get('rc_cache.cache_repo.expiration_time'))
         cache_on = not force_recache and cache_seconds > 0
         log.debug(
             'Computing FILE TREE for repo_id %s commit_id `%s` and path `%s`'
             'with caching: %s[TTL: %ss]' % (
                 repo_id, commit_id, f_path, cache_on, cache_seconds or 0))
 
         cache_namespace_uid = 'cache_repo.{}'.format(repo_id)
         region = rc_cache.get_or_create_region('cache_repo', cache_namespace_uid)
 
         @region.conditional_cache_on_arguments(namespace=cache_namespace_uid,
                                                condition=cache_on)
-        def compute_file_tree(ver, repo_id, commit_id, f_path, full_load):
+        def compute_file_tree(ver, repo_id, commit_id, f_path, full_load, at_rev):
             log.debug('Generating cached file tree at ver:%s for repo_id: %s, %s, %s',
                       ver, repo_id, commit_id, f_path)
 
             c.full_load = full_load
             return render(
                 'rhodecode:templates/files/files_browser_tree.mako',
-                self._get_template_context(c), self.request)
+                self._get_template_context(c), self.request, at_rev)
 
         return compute_file_tree(
-            rc_cache.FILE_TREE_CACHE_VER, self.db_repo.repo_id, commit_id, f_path, full_load)
+            rc_cache.FILE_TREE_CACHE_VER, self.db_repo.repo_id, commit_id,
+            f_path, full_load, at_rev)
 
     def _get_archive_spec(self, fname):
         log.debug('Detecting archive spec for: `%s`', fname)
 
         fileformat = None
         ext = None
         content_type = None
         for a_type, content_type, extension in settings.ARCHIVE_SPECS:
 
             if fname.endswith(extension):
                 fileformat = a_type
                 log.debug('archive is of type: %s', fileformat)
                 ext = extension
                 break
 
         if not fileformat:
             raise ValueError()
 
         # left over part of whole fname is the commit
         commit_id = fname[:-len(ext)]
 
         return commit_id, ext, fileformat, content_type
 
     def create_pure_path(self, *parts):
         # Split paths and sanitize them, removing any ../ etc
         sanitized_path = [
             x for x in pathlib2.PurePath(*parts).parts
             if x not in ['.', '..']]
 
         pure_path = pathlib2.PurePath(*sanitized_path)
         return pure_path
 
     def _is_lf_enabled(self, target_repo):
         lf_enabled = False
 
         lf_key_for_vcs_map = {
             'hg': 'extensions_largefiles',
             'git': 'vcs_git_lfs_enabled'
         }
 
         lf_key_for_vcs = lf_key_for_vcs_map.get(target_repo.repo_type)
 
         if lf_key_for_vcs:
             lf_enabled = self._get_repo_setting(target_repo, lf_key_for_vcs)
 
         return lf_enabled
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_archivefile', request_method='GET',
         renderer=None)
     def repo_archivefile(self):
         # archive cache config
         from rhodecode import CONFIG
         _ = self.request.translate
         self.load_default_context()
         default_at_path = '/'
         fname = self.request.matchdict['fname']
         subrepos = self.request.GET.get('subrepos') == 'true'
         at_path = self.request.GET.get('at_path') or default_at_path
 
         if not self.db_repo.enable_downloads:
             return Response(_('Downloads disabled'))
 
         try:
             commit_id, ext, fileformat, content_type = \
                 self._get_archive_spec(fname)
         except ValueError:
             return Response(_('Unknown archive type for: `{}`').format(
                 h.escape(fname)))
 
         try:
             commit = self.rhodecode_vcs_repo.get_commit(commit_id)
         except CommitDoesNotExistError:
             return Response(_('Unknown commit_id {}').format(
                 h.escape(commit_id)))
         except EmptyRepositoryError:
             return Response(_('Empty repository'))
 
         try:
             at_path = commit.get_node(at_path).path or default_at_path
         except Exception:
             return Response(_('No node at path {} for this repository').format(at_path))
 
         path_sha = sha1(at_path)[:8]
 
         # original backward compat name of archive
         clean_name = safe_str(self.db_repo_name.replace('/', '_'))
         short_sha = safe_str(commit.short_id)
 
         if at_path == default_at_path:
             archive_name = '{}-{}{}{}'.format(
                 clean_name,
                 '-sub' if subrepos else '',
                 short_sha,
                 ext)
         # custom path and new name
         else:
             archive_name = '{}-{}{}-{}{}'.format(
                 clean_name,
                 '-sub' if subrepos else '',
                 short_sha,
                 path_sha,
                 ext)
 
         use_cached_archive = False
         archive_cache_enabled = CONFIG.get(
             'archive_cache_dir') and not self.request.GET.get('no_cache')
         cached_archive_path = None
 
         if archive_cache_enabled:
             # check if we it's ok to write
             if not os.path.isdir(CONFIG['archive_cache_dir']):
                 os.makedirs(CONFIG['archive_cache_dir'])
             cached_archive_path = os.path.join(
                 CONFIG['archive_cache_dir'], archive_name)
             if os.path.isfile(cached_archive_path):
                 log.debug('Found cached archive in %s', cached_archive_path)
                 fd, archive = None, cached_archive_path
                 use_cached_archive = True
             else:
                 log.debug('Archive %s is not yet cached', archive_name)
 
         if not use_cached_archive:
             # generate new archive
             fd, archive = tempfile.mkstemp()
             log.debug('Creating new temp archive in %s', archive)
             try:
                 commit.archive_repo(archive, kind=fileformat, subrepos=subrepos,
                                     archive_at_path=at_path)
             except ImproperArchiveTypeError:
                 return _('Unknown archive type')
             if archive_cache_enabled:
                 # if we generated the archive and we have cache enabled
                 # let's use this for future
                 log.debug('Storing new archive in %s', cached_archive_path)
                 shutil.move(archive, cached_archive_path)
                 archive = cached_archive_path
 
         # store download action
         audit_logger.store_web(
             'repo.archive.download', action_data={
                 'user_agent': self.request.user_agent,
                 'archive_name': archive_name,
                 'archive_spec': fname,
                 'archive_cached': use_cached_archive},
             user=self._rhodecode_user,
             repo=self.db_repo,
             commit=True
         )
 
         def get_chunked_archive(archive_path):
             with open(archive_path, 'rb') as stream:
                 while True:
                     data = stream.read(16 * 1024)
                     if not data:
                         if fd:  # fd means we used temporary file
                             os.close(fd)
                         if not archive_cache_enabled:
                             log.debug('Destroying temp archive %s', archive_path)
                             os.remove(archive_path)
                         break
                     yield data
 
         response = Response(app_iter=get_chunked_archive(archive))
         response.content_disposition = str(
             'attachment; filename=%s' % archive_name)
         response.content_type = str(content_type)
 
         return response
 
     def _get_file_node(self, commit_id, f_path):
         if commit_id not in ['', None, 'None', '0' * 12, '0' * 40]:
             commit = self.rhodecode_vcs_repo.get_commit(commit_id=commit_id)
             try:
                 node = commit.get_node(f_path)
                 if node.is_dir():
                     raise NodeError('%s path is a %s not a file'
                                     % (node, type(node)))
             except NodeDoesNotExistError:
                 commit = EmptyCommit(
                     commit_id=commit_id,
                     idx=commit.idx,
                     repo=commit.repository,
                     alias=commit.repository.alias,
                     message=commit.message,
                     author=commit.author,
                     date=commit.date)
                 node = FileNode(f_path, '', commit=commit)
         else:
             commit = EmptyCommit(
                 repo=self.rhodecode_vcs_repo,
                 alias=self.rhodecode_vcs_repo.alias)
             node = FileNode(f_path, '', commit=commit)
         return node
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_files_diff', request_method='GET',
         renderer=None)
     def repo_files_diff(self):
         c = self.load_default_context()
         f_path = self._get_f_path(self.request.matchdict)
         diff1 = self.request.GET.get('diff1', '')
         diff2 = self.request.GET.get('diff2', '')
 
         path1, diff1 = parse_path_ref(diff1, default_path=f_path)
 
         ignore_whitespace = str2bool(self.request.GET.get('ignorews'))
         line_context = self.request.GET.get('context', 3)
 
         if not any((diff1, diff2)):
             h.flash(
                 'Need query parameter "diff1" or "diff2" to generate a diff.',
                 category='error')
             raise HTTPBadRequest()
 
         c.action = self.request.GET.get('diff')
         if c.action not in ['download', 'raw']:
             compare_url = h.route_path(
                 'repo_compare',
                 repo_name=self.db_repo_name,
                 source_ref_type='rev',
                 source_ref=diff1,
                 target_repo=self.db_repo_name,
                 target_ref_type='rev',
                 target_ref=diff2,
                 _query=dict(f_path=f_path))
             # redirect to new view if we render diff
             raise HTTPFound(compare_url)
 
         try:
             node1 = self._get_file_node(diff1, path1)
             node2 = self._get_file_node(diff2, f_path)
         except (RepositoryError, NodeError):
             log.exception("Exception while trying to get node from repository")
             raise HTTPFound(
                 h.route_path('repo_files', repo_name=self.db_repo_name,
                              commit_id='tip', f_path=f_path))
 
         if all(isinstance(node.commit, EmptyCommit)
                for node in (node1, node2)):
             raise HTTPNotFound()
 
         c.commit_1 = node1.commit
         c.commit_2 = node2.commit
 
         if c.action == 'download':
             _diff = diffs.get_gitdiff(node1, node2,
                                       ignore_whitespace=ignore_whitespace,
                                       context=line_context)
             diff = diffs.DiffProcessor(_diff, format='gitdiff')
 
             response = Response(self.path_filter.get_raw_patch(diff))
             response.content_type = 'text/plain'
             response.content_disposition = (
                 'attachment; filename=%s_%s_vs_%s.diff' % (f_path, diff1, diff2)
             )
             charset = self._get_default_encoding(c)
             if charset:
                 response.charset = charset
             return response
 
         elif c.action == 'raw':
             _diff = diffs.get_gitdiff(node1, node2,
                                       ignore_whitespace=ignore_whitespace,
                                       context=line_context)
             diff = diffs.DiffProcessor(_diff, format='gitdiff')
 
             response = Response(self.path_filter.get_raw_patch(diff))
             response.content_type = 'text/plain'
             charset = self._get_default_encoding(c)
             if charset:
                 response.charset = charset
             return response
 
         # in case we ever end up here
         raise HTTPNotFound()
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_files_diff_2way_redirect', request_method='GET',
         renderer=None)
     def repo_files_diff_2way_redirect(self):
         """
         Kept only to make OLD links work
         """
         f_path = self._get_f_path_unchecked(self.request.matchdict)
         diff1 = self.request.GET.get('diff1', '')
         diff2 = self.request.GET.get('diff2', '')
 
         if not any((diff1, diff2)):
             h.flash(
                 'Need query parameter "diff1" or "diff2" to generate a diff.',
                 category='error')
             raise HTTPBadRequest()
 
         compare_url = h.route_path(
             'repo_compare',
             repo_name=self.db_repo_name,
             source_ref_type='rev',
             source_ref=diff1,
             target_ref_type='rev',
             target_ref=diff2,
             _query=dict(f_path=f_path, diffmode='sideside',
                         target_repo=self.db_repo_name,))
         raise HTTPFound(compare_url)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_files', request_method='GET',
         renderer=None)
     @view_config(
         route_name='repo_files:default_path', request_method='GET',
         renderer=None)
     @view_config(
         route_name='repo_files:default_commit', request_method='GET',
         renderer=None)
     @view_config(
         route_name='repo_files:rendered', request_method='GET',
         renderer=None)
     @view_config(
         route_name='repo_files:annotated', request_method='GET',
         renderer=None)
     def repo_files(self):
         c = self.load_default_context()
 
         view_name = getattr(self.request.matched_route, 'name', None)
 
         c.annotate = view_name == 'repo_files:annotated'
         # default is false, but .rst/.md files later are auto rendered, we can
         # overwrite auto rendering by setting this GET flag
         c.renderer = view_name == 'repo_files:rendered' or \
                         not self.request.GET.get('no-render', False)
 
-        # redirect to given commit_id from form if given
-        get_commit_id = self.request.GET.get('at_rev', None)
-        if get_commit_id:
-            self._get_commit_or_redirect(get_commit_id)
+        commit_id, f_path = self._get_commit_and_path()
 
-        commit_id, f_path = self._get_commit_and_path()
         c.commit = self._get_commit_or_redirect(commit_id)
         c.branch = self.request.GET.get('branch', None)
         c.f_path = f_path
+        at_rev = self.request.GET.get('at')
 
         # prev link
         try:
             prev_commit = c.commit.prev(c.branch)
             c.prev_commit = prev_commit
             c.url_prev = h.route_path(
                 'repo_files', repo_name=self.db_repo_name,
                 commit_id=prev_commit.raw_id, f_path=f_path)
             if c.branch:
                 c.url_prev += '?branch=%s' % c.branch
         except (CommitDoesNotExistError, VCSError):
             c.url_prev = '#'
             c.prev_commit = EmptyCommit()
 
         # next link
         try:
             next_commit = c.commit.next(c.branch)
             c.next_commit = next_commit
             c.url_next = h.route_path(
                 'repo_files', repo_name=self.db_repo_name,
                 commit_id=next_commit.raw_id, f_path=f_path)
             if c.branch:
                 c.url_next += '?branch=%s' % c.branch
         except (CommitDoesNotExistError, VCSError):
             c.url_next = '#'
             c.next_commit = EmptyCommit()
 
         # files or dirs
         try:
             c.file = c.commit.get_node(f_path)
             c.file_author = True
             c.file_tree = ''
 
             # load file content
             if c.file.is_file():
                 c.lf_node = {}
 
                 has_lf_enabled = self._is_lf_enabled(self.db_repo)
                 if has_lf_enabled:
                     c.lf_node = c.file.get_largefile_node()
 
                 c.file_source_page = 'true'
                 c.file_last_commit = c.file.last_commit
 
                 c.file_size_too_big = c.file.size > c.visual.cut_off_limit_file
 
                 if not (c.file_size_too_big or c.file.is_binary):
                     if c.annotate:  # annotation has precedence over renderer
                         c.annotated_lines = filenode_as_annotated_lines_tokens(
                             c.file
                         )
                     else:
                         c.renderer = (
                             c.renderer and h.renderer_from_filename(c.file.path)
                         )
                         if not c.renderer:
                             c.lines = filenode_as_lines_tokens(c.file)
 
                 _branch_name, _sha_commit_id, is_head = self._is_valid_head(
                     commit_id, self.rhodecode_vcs_repo)
                 c.on_branch_head = is_head
 
                 branch = c.commit.branch if (
                     c.commit.branch and '/' not in c.commit.branch) else None
                 c.branch_or_raw_id = branch or c.commit.raw_id
                 c.branch_name = c.commit.branch or h.short_id(c.commit.raw_id)
 
                 author = c.file_last_commit.author
                 c.authors = [[
                     h.email(author),
                     h.person(author, 'username_or_name_or_email'),
                     1
                 ]]
 
             else:  # load tree content at path
                 c.file_source_page = 'false'
                 c.authors = []
                 # this loads a simple tree without metadata to speed things up
                 # later via ajax we call repo_nodetree_full and fetch whole
-                c.file_tree = self._get_tree_at_commit(c, c.commit.raw_id, f_path)
+                c.file_tree = self._get_tree_at_commit(c, c.commit.raw_id, f_path, at_rev=at_rev)
 
                 c.readme_data, c.readme_file = \
                     self._get_readme_data(self.db_repo, c.visual.default_renderer,
                                           c.commit.raw_id, f_path)
 
         except RepositoryError as e:
             h.flash(safe_str(h.escape(e)), category='error')
             raise HTTPNotFound()
 
         if self.request.environ.get('HTTP_X_PJAX'):
             html = render('rhodecode:templates/files/files_pjax.mako',
                           self._get_template_context(c), self.request)
         else:
             html = render('rhodecode:templates/files/files.mako',
                           self._get_template_context(c), self.request)
         return Response(html)
 
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_files:annotated_previous', request_method='GET',
         renderer=None)
     def repo_files_annotated_previous(self):
         self.load_default_context()
 
         commit_id, f_path = self._get_commit_and_path()
         commit = self._get_commit_or_redirect(commit_id)
         prev_commit_id = commit.raw_id
         line_anchor = self.request.GET.get('line_anchor')
         is_file = False
         try:
             _file = commit.get_node(f_path)
             is_file = _file.is_file()
         except (NodeDoesNotExistError, CommitDoesNotExistError, VCSError):
             pass
 
         if is_file:
             history = commit.get_path_history(f_path)
             prev_commit_id = history[1].raw_id \
                 if len(history) > 1 else prev_commit_id
         prev_url = h.route_path(
             'repo_files:annotated', repo_name=self.db_repo_name,
             commit_id=prev_commit_id, f_path=f_path,
             _anchor='L{}'.format(line_anchor))
 
         raise HTTPFound(prev_url)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_nodetree_full', request_method='GET',
         renderer=None, xhr=True)
     @view_config(
         route_name='repo_nodetree_full:default_path', request_method='GET',
         renderer=None, xhr=True)
     def repo_nodetree_full(self):
         """
         Returns rendered html of file tree that contains commit date,
         author, commit_id for the specified combination of
         repo, commit_id and file path
         """
         c = self.load_default_context()
 
         commit_id, f_path = self._get_commit_and_path()
         commit = self._get_commit_or_redirect(commit_id)
         try:
             dir_node = commit.get_node(f_path)
         except RepositoryError as e:
             return Response('error: {}'.format(h.escape(safe_str(e))))
 
         if dir_node.is_file():
             return Response('')
 
         c.file = dir_node
         c.commit = commit
+        at_rev = self.request.GET.get('at')
 
         html = self._get_tree_at_commit(
-            c, commit.raw_id, dir_node.path, full_load=True)
+            c, commit.raw_id, dir_node.path, full_load=True, at_rev=at_rev)
 
         return Response(html)
 
     def _get_attachement_headers(self, f_path):
         f_name = safe_str(f_path.split(Repository.NAME_SEP)[-1])
         safe_path = f_name.replace('"', '\\"')
         encoded_path = urllib.quote(f_name)
 
         return "attachment; " \
                "filename=\"{}\"; " \
                "filename*=UTF-8\'\'{}".format(safe_path, encoded_path)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_file_raw', request_method='GET',
         renderer=None)
     def repo_file_raw(self):
         """
         Action for show as raw, some mimetypes are "rendered",
         those include images, icons.
         """
         c = self.load_default_context()
 
         commit_id, f_path = self._get_commit_and_path()
         commit = self._get_commit_or_redirect(commit_id)
         file_node = self._get_filenode_or_redirect(commit, f_path)
 
         raw_mimetype_mapping = {
             # map original mimetype to a mimetype used for "show as raw"
             # you can also provide a content-disposition to override the
             # default "attachment" disposition.
             # orig_type: (new_type, new_dispo)
 
             # show images inline:
             # Do not re-add SVG: it is unsafe and permits XSS attacks. One can
             # for example render an SVG with javascript inside or even render
             # HTML.
             'image/x-icon': ('image/x-icon', 'inline'),
             'image/png': ('image/png', 'inline'),
             'image/gif': ('image/gif', 'inline'),
             'image/jpeg': ('image/jpeg', 'inline'),
             'application/pdf': ('application/pdf', 'inline'),
         }
 
         mimetype = file_node.mimetype
         try:
             mimetype, disposition = raw_mimetype_mapping[mimetype]
         except KeyError:
             # we don't know anything special about this, handle it safely
             if file_node.is_binary:
                 # do same as download raw for binary files
                 mimetype, disposition = 'application/octet-stream', 'attachment'
             else:
                 # do not just use the original mimetype, but force text/plain,
                 # otherwise it would serve text/html and that might be unsafe.
                 # Note: underlying vcs library fakes text/plain mimetype if the
                 # mimetype can not be determined and it thinks it is not
                 # binary.This might lead to erroneous text display in some
                 # cases, but helps in other cases, like with text files
                 # without extension.
                 mimetype, disposition = 'text/plain', 'inline'
 
         if disposition == 'attachment':
             disposition = self._get_attachement_headers(f_path)
 
         stream_content = file_node.stream_bytes()
 
         response = Response(app_iter=stream_content)
         response.content_disposition = disposition
         response.content_type = mimetype
 
         charset = self._get_default_encoding(c)
         if charset:
             response.charset = charset
 
         return response
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_file_download', request_method='GET',
         renderer=None)
     @view_config(
         route_name='repo_file_download:legacy', request_method='GET',
         renderer=None)
     def repo_file_download(self):
         c = self.load_default_context()
 
         commit_id, f_path = self._get_commit_and_path()
         commit = self._get_commit_or_redirect(commit_id)
         file_node = self._get_filenode_or_redirect(commit, f_path)
 
         if self.request.GET.get('lf'):
             # only if lf get flag is passed, we download this file
             # as LFS/Largefile
             lf_node = file_node.get_largefile_node()
             if lf_node:
                 # overwrite our pointer with the REAL large-file
                 file_node = lf_node
 
         disposition = self._get_attachement_headers(f_path)
 
         stream_content = file_node.stream_bytes()
 
         response = Response(app_iter=stream_content)
         response.content_disposition = disposition
         response.content_type = file_node.mimetype
 
         charset = self._get_default_encoding(c)
         if charset:
             response.charset = charset
 
         return response
 
     def _get_nodelist_at_commit(self, repo_name, repo_id, commit_id, f_path):
 
         cache_seconds = safe_int(
             rhodecode.CONFIG.get('rc_cache.cache_repo.expiration_time'))
         cache_on = cache_seconds > 0
         log.debug(
             'Computing FILE SEARCH for repo_id %s commit_id `%s` and path `%s`'
             'with caching: %s[TTL: %ss]' % (
                 repo_id, commit_id, f_path, cache_on, cache_seconds or 0))
 
         cache_namespace_uid = 'cache_repo.{}'.format(repo_id)
         region = rc_cache.get_or_create_region('cache_repo', cache_namespace_uid)
 
         @region.conditional_cache_on_arguments(namespace=cache_namespace_uid,
                                                condition=cache_on)
         def compute_file_search(repo_id, commit_id, f_path):
             log.debug('Generating cached nodelist for repo_id:%s, %s, %s',
                       repo_id, commit_id, f_path)
             try:
                 _d, _f = ScmModel().get_quick_filter_nodes(repo_name, commit_id, f_path)
             except (RepositoryError, CommitDoesNotExistError, Exception) as e:
                 log.exception(safe_str(e))
                 h.flash(safe_str(h.escape(e)), category='error')
                 raise HTTPFound(h.route_path(
                     'repo_files', repo_name=self.db_repo_name,
                     commit_id='tip', f_path='/'))
 
             return _d + _f
 
         result = compute_file_search(self.db_repo.repo_id, commit_id, f_path)
         return filter(lambda n: self.path_filter.path_access_allowed(n['name']), result)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_files_nodelist', request_method='GET',
         renderer='json_ext', xhr=True)
     def repo_nodelist(self):
         self.load_default_context()
 
         commit_id, f_path = self._get_commit_and_path()
         commit = self._get_commit_or_redirect(commit_id)
 
         metadata = self._get_nodelist_at_commit(
             self.db_repo_name, self.db_repo.repo_id, commit.raw_id, f_path)
         return {'nodes': metadata}
 
     def _create_references(self, branches_or_tags, symbolic_reference, f_path, ref_type):
         items = []
         for name, commit_id in branches_or_tags.items():
             sym_ref = symbolic_reference(commit_id, name, f_path, ref_type)
             items.append((sym_ref, name, ref_type))
         return items
 
     def _symbolic_reference(self, commit_id, name, f_path, ref_type):
         return commit_id
 
     def _symbolic_reference_svn(self, commit_id, name, f_path, ref_type):
         return commit_id
 
         # NOTE(dan): old code we used in "diff" mode compare
         new_f_path = vcspath.join(name, f_path)
         return u'%s@%s' % (new_f_path, commit_id)
 
     def _get_node_history(self, commit_obj, f_path, commits=None):
         """
         get commit history for given node
 
         :param commit_obj: commit to calculate history
         :param f_path: path for node to calculate history for
         :param commits: if passed don't calculate history and take
             commits defined in this list
         """
         _ = self.request.translate
 
         # calculate history based on tip
         tip = self.rhodecode_vcs_repo.get_commit()
         if commits is None:
             pre_load = ["author", "branch"]
             try:
                 commits = tip.get_path_history(f_path, pre_load=pre_load)
             except (NodeDoesNotExistError, CommitError):
                 # this node is not present at tip!
                 commits = commit_obj.get_path_history(f_path, pre_load=pre_load)
 
         history = []
         commits_group = ([], _("Changesets"))
         for commit in commits:
             branch = ' (%s)' % commit.branch if commit.branch else ''
             n_desc = 'r%s:%s%s' % (commit.idx, commit.short_id, branch)
             commits_group[0].append((commit.raw_id, n_desc, 'sha'))
         history.append(commits_group)
 
         symbolic_reference = self._symbolic_reference
 
         if self.rhodecode_vcs_repo.alias == 'svn':
             adjusted_f_path = RepoFilesView.adjust_file_path_for_svn(
                 f_path, self.rhodecode_vcs_repo)
             if adjusted_f_path != f_path:
                 log.debug(
                     'Recognized svn tag or branch in file "%s", using svn '
                     'specific symbolic references', f_path)
                 f_path = adjusted_f_path
                 symbolic_reference = self._symbolic_reference_svn
 
         branches = self._create_references(
             self.rhodecode_vcs_repo.branches, symbolic_reference, f_path, 'branch')
         branches_group = (branches, _("Branches"))
 
         tags = self._create_references(
             self.rhodecode_vcs_repo.tags, symbolic_reference, f_path, 'tag')
         tags_group = (tags, _("Tags"))
 
         history.append(branches_group)
         history.append(tags_group)
 
         return history, commits
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_file_history', request_method='GET',
         renderer='json_ext')
     def repo_file_history(self):
         self.load_default_context()
 
         commit_id, f_path = self._get_commit_and_path()
         commit = self._get_commit_or_redirect(commit_id)
         file_node = self._get_filenode_or_redirect(commit, f_path)
 
         if file_node.is_file():
             file_history, _hist = self._get_node_history(commit, f_path)
 
             res = []
-            for obj in file_history:
+            for section_items, section in file_history:
+                items = []
+                for obj_id, obj_text, obj_type in section_items:
+                    at_rev = ''
+                    if obj_type in ['branch', 'bookmark', 'tag']:
+                        at_rev = obj_text
+                    entry = {
+                        'id': obj_id,
+                        'text': obj_text,
+                        'type': obj_type,
+                        'at_rev': at_rev
+                    }
+
+                    items.append(entry)
+
                 res.append({
-                    'text': obj[1],
-                    'children': [{'id': o[0], 'text': o[1], 'type': o[2]} for o in obj[0]]
+                    'text': section,
+                    'children': items
                 })
 
             data = {
                 'more': False,
                 'results': res
             }
             return data
 
         log.warning('Cannot fetch history for directory')
         raise HTTPBadRequest()
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_file_authors', request_method='GET',
         renderer='rhodecode:templates/files/file_authors_box.mako')
     def repo_file_authors(self):
         c = self.load_default_context()
 
         commit_id, f_path = self._get_commit_and_path()
         commit = self._get_commit_or_redirect(commit_id)
         file_node = self._get_filenode_or_redirect(commit, f_path)
 
         if not file_node.is_file():
             raise HTTPBadRequest()
 
         c.file_last_commit = file_node.last_commit
         if self.request.GET.get('annotate') == '1':
             # use _hist from annotation if annotation mode is on
             commit_ids = set(x[1] for x in file_node.annotate)
             _hist = (
                 self.rhodecode_vcs_repo.get_commit(commit_id)
                 for commit_id in commit_ids)
         else:
             _f_history, _hist = self._get_node_history(commit, f_path)
         c.file_author = False
 
         unique = collections.OrderedDict()
         for commit in _hist:
             author = commit.author
             if author not in unique:
                 unique[commit.author] = [
                     h.email(author),
                     h.person(author, 'username_or_name_or_email'),
                     1  # counter
                 ]
 
             else:
                 # increase counter
                 unique[commit.author][2] += 1
 
         c.authors = [val for val in unique.values()]
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     @view_config(
         route_name='repo_files_remove_file', request_method='GET',
         renderer='rhodecode:templates/files/files_delete.mako')
     def repo_files_remove_file(self):
         _ = self.request.translate
         c = self.load_default_context()
         commit_id, f_path = self._get_commit_and_path()
 
         self._ensure_not_locked()
         _branch_name, _sha_commit_id, is_head = \
             self._is_valid_head(commit_id, self.rhodecode_vcs_repo)
 
         self.forbid_non_head(is_head, f_path)
         self.check_branch_permission(_branch_name)
 
         c.commit = self._get_commit_or_redirect(commit_id)
         c.file = self._get_filenode_or_redirect(c.commit, f_path)
 
         c.default_message = _(
             'Deleted file {} via RhodeCode Enterprise').format(f_path)
         c.f_path = f_path
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='repo_files_delete_file', request_method='POST',
         renderer=None)
     def repo_files_delete_file(self):
         _ = self.request.translate
 
         c = self.load_default_context()
         commit_id, f_path = self._get_commit_and_path()
 
         self._ensure_not_locked()
         _branch_name, _sha_commit_id, is_head = \
             self._is_valid_head(commit_id, self.rhodecode_vcs_repo)
 
         self.forbid_non_head(is_head, f_path)
         self.check_branch_permission(_branch_name)
 
         c.commit = self._get_commit_or_redirect(commit_id)
         c.file = self._get_filenode_or_redirect(c.commit, f_path)
 
         c.default_message = _(
             'Deleted file {} via RhodeCode Enterprise').format(f_path)
         c.f_path = f_path
         node_path = f_path
         author = self._rhodecode_db_user.full_contact
         message = self.request.POST.get('message') or c.default_message
         try:
             nodes = {
                 node_path: {
                     'content': ''
                 }
             }
             ScmModel().delete_nodes(
                 user=self._rhodecode_db_user.user_id, repo=self.db_repo,
                 message=message,
                 nodes=nodes,
                 parent_commit=c.commit,
                 author=author,
             )
 
             h.flash(
                 _('Successfully deleted file `{}`').format(
                     h.escape(f_path)), category='success')
         except Exception:
             log.exception('Error during commit operation')
             h.flash(_('Error occurred during commit'), category='error')
         raise HTTPFound(
             h.route_path('repo_commit', repo_name=self.db_repo_name,
                          commit_id='tip'))
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     @view_config(
         route_name='repo_files_edit_file', request_method='GET',
         renderer='rhodecode:templates/files/files_edit.mako')
     def repo_files_edit_file(self):
         _ = self.request.translate
         c = self.load_default_context()
         commit_id, f_path = self._get_commit_and_path()
 
         self._ensure_not_locked()
         _branch_name, _sha_commit_id, is_head = \
             self._is_valid_head(commit_id, self.rhodecode_vcs_repo)
 
         self.forbid_non_head(is_head, f_path, commit_id=commit_id)
         self.check_branch_permission(_branch_name, commit_id=commit_id)
 
         c.commit = self._get_commit_or_redirect(commit_id)
         c.file = self._get_filenode_or_redirect(c.commit, f_path)
 
         if c.file.is_binary:
             files_url = h.route_path(
                 'repo_files',
                 repo_name=self.db_repo_name,
                 commit_id=c.commit.raw_id, f_path=f_path)
             raise HTTPFound(files_url)
 
         c.default_message = _('Edited file {} via RhodeCode Enterprise').format(f_path)
         c.f_path = f_path
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='repo_files_update_file', request_method='POST',
         renderer=None)
     def repo_files_update_file(self):
         _ = self.request.translate
         c = self.load_default_context()
         commit_id, f_path = self._get_commit_and_path()
 
         self._ensure_not_locked()
 
         c.commit = self._get_commit_or_redirect(commit_id)
         c.file = self._get_filenode_or_redirect(c.commit, f_path)
 
         if c.file.is_binary:
             raise HTTPFound(h.route_path('repo_files', repo_name=self.db_repo_name,
                                          commit_id=c.commit.raw_id, f_path=f_path))
 
         _branch_name, _sha_commit_id, is_head = \
             self._is_valid_head(commit_id, self.rhodecode_vcs_repo)
 
         self.forbid_non_head(is_head, f_path, commit_id=commit_id)
         self.check_branch_permission(_branch_name, commit_id=commit_id)
 
         c.default_message = _('Edited file {} via RhodeCode Enterprise').format(f_path)
         c.f_path = f_path
 
         old_content = c.file.content
         sl = old_content.splitlines(1)
         first_line = sl[0] if sl else ''
 
         r_post = self.request.POST
         # line endings:  0 - Unix, 1 - Mac, 2 - DOS
         line_ending_mode = detect_mode(first_line, 0)
         content = convert_line_endings(r_post.get('content', ''), line_ending_mode)
 
         message = r_post.get('message') or c.default_message
         org_node_path = c.file.unicode_path
         filename = r_post['filename']
 
         root_path = c.file.dir_path
         pure_path = self.create_pure_path(root_path, filename)
         node_path = safe_unicode(bytes(pure_path))
 
         default_redirect_url = h.route_path('repo_commit', repo_name=self.db_repo_name,
                                             commit_id=commit_id)
         if content == old_content and node_path == org_node_path:
             h.flash(_('No changes detected on {}').format(h.escape(org_node_path)),
                     category='warning')
             raise HTTPFound(default_redirect_url)
 
         try:
             mapping = {
                 org_node_path: {
                     'org_filename': org_node_path,
                     'filename': node_path,
                     'content': content,
                     'lexer': '',
                     'op': 'mod',
                     'mode': c.file.mode
                 }
             }
 
             commit = ScmModel().update_nodes(
                 user=self._rhodecode_db_user.user_id,
                 repo=self.db_repo,
                 message=message,
                 nodes=mapping,
                 parent_commit=c.commit,
             )
 
             h.flash(_('Successfully committed changes to file `{}`').format(
                     h.escape(f_path)), category='success')
             default_redirect_url = h.route_path(
                 'repo_commit', repo_name=self.db_repo_name, commit_id=commit.raw_id)
 
         except Exception:
             log.exception('Error occurred during commit')
             h.flash(_('Error occurred during commit'), category='error')
 
         raise HTTPFound(default_redirect_url)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     @view_config(
         route_name='repo_files_add_file', request_method='GET',
         renderer='rhodecode:templates/files/files_add.mako')
     @view_config(
         route_name='repo_files_upload_file', request_method='GET',
         renderer='rhodecode:templates/files/files_upload.mako')
     def repo_files_add_file(self):
         _ = self.request.translate
         c = self.load_default_context()
         commit_id, f_path = self._get_commit_and_path()
 
         self._ensure_not_locked()
 
         c.commit = self._get_commit_or_redirect(commit_id, redirect_after=False)
         if c.commit is None:
             c.commit = EmptyCommit(alias=self.rhodecode_vcs_repo.alias)
 
         if self.rhodecode_vcs_repo.is_empty():
             # for empty repository we cannot check for current branch, we rely on
             # c.commit.branch instead
             _branch_name, _sha_commit_id, is_head = c.commit.branch, '', True
         else:
             _branch_name, _sha_commit_id, is_head = \
                 self._is_valid_head(commit_id, self.rhodecode_vcs_repo)
 
         self.forbid_non_head(is_head, f_path, commit_id=commit_id)
         self.check_branch_permission(_branch_name, commit_id=commit_id)
 
         c.default_message = (_('Added file via RhodeCode Enterprise'))
         c.f_path = f_path.lstrip('/')  # ensure not relative path
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='repo_files_create_file', request_method='POST',
         renderer=None)
     def repo_files_create_file(self):
         _ = self.request.translate
         c = self.load_default_context()
         commit_id, f_path = self._get_commit_and_path()
 
         self._ensure_not_locked()
 
         c.commit = self._get_commit_or_redirect(commit_id, redirect_after=False)
         if c.commit is None:
             c.commit = EmptyCommit(alias=self.rhodecode_vcs_repo.alias)
 
         # calculate redirect URL
         if self.rhodecode_vcs_repo.is_empty():
             default_redirect_url = h.route_path(
                 'repo_summary', repo_name=self.db_repo_name)
         else:
             default_redirect_url = h.route_path(
                 'repo_commit', repo_name=self.db_repo_name, commit_id='tip')
 
         if self.rhodecode_vcs_repo.is_empty():
             # for empty repository we cannot check for current branch, we rely on
             # c.commit.branch instead
             _branch_name, _sha_commit_id, is_head = c.commit.branch, '', True
         else:
             _branch_name, _sha_commit_id, is_head = \
                 self._is_valid_head(commit_id, self.rhodecode_vcs_repo)
 
         self.forbid_non_head(is_head, f_path, commit_id=commit_id)
         self.check_branch_permission(_branch_name, commit_id=commit_id)
 
         c.default_message = (_('Added file via RhodeCode Enterprise'))
         c.f_path = f_path
 
         r_post = self.request.POST
         message = r_post.get('message') or c.default_message
         filename = r_post.get('filename')
         unix_mode = 0
         content = convert_line_endings(r_post.get('content', ''), unix_mode)
 
         if not filename:
             # If there's no commit, redirect to repo summary
             if type(c.commit) is EmptyCommit:
                 redirect_url = h.route_path(
                     'repo_summary', repo_name=self.db_repo_name)
             else:
                 redirect_url = default_redirect_url
             h.flash(_('No filename specified'), category='warning')
             raise HTTPFound(redirect_url)
 
         root_path = f_path
         pure_path = self.create_pure_path(root_path, filename)
         node_path = safe_unicode(bytes(pure_path).lstrip('/'))
 
         author = self._rhodecode_db_user.full_contact
         nodes = {
             node_path: {
                 'content': content
             }
         }
 
         try:
 
             commit = ScmModel().create_nodes(
                 user=self._rhodecode_db_user.user_id,
                 repo=self.db_repo,
                 message=message,
                 nodes=nodes,
                 parent_commit=c.commit,
                 author=author,
             )
 
             h.flash(_('Successfully committed new file `{}`').format(
                     h.escape(node_path)), category='success')
 
             default_redirect_url = h.route_path(
                 'repo_commit', repo_name=self.db_repo_name, commit_id=commit.raw_id)
 
         except NonRelativePathError:
             log.exception('Non Relative path found')
             h.flash(_('The location specified must be a relative path and must not '
                       'contain .. in the path'), category='warning')
             raise HTTPFound(default_redirect_url)
         except (NodeError, NodeAlreadyExistsError) as e:
             h.flash(_(h.escape(e)), category='error')
         except Exception:
             log.exception('Error occurred during commit')
             h.flash(_('Error occurred during commit'), category='error')
 
         raise HTTPFound(default_redirect_url)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='repo_files_upload_file', request_method='POST',
         renderer='json_ext')
     def repo_files_upload_file(self):
         _ = self.request.translate
         c = self.load_default_context()
         commit_id, f_path = self._get_commit_and_path()
 
         self._ensure_not_locked()
 
         c.commit = self._get_commit_or_redirect(commit_id, redirect_after=False)
         if c.commit is None:
             c.commit = EmptyCommit(alias=self.rhodecode_vcs_repo.alias)
 
         # calculate redirect URL
         if self.rhodecode_vcs_repo.is_empty():
             default_redirect_url = h.route_path(
                 'repo_summary', repo_name=self.db_repo_name)
         else:
             default_redirect_url = h.route_path(
                 'repo_commit', repo_name=self.db_repo_name, commit_id='tip')
 
         if self.rhodecode_vcs_repo.is_empty():
             # for empty repository we cannot check for current branch, we rely on
             # c.commit.branch instead
             _branch_name, _sha_commit_id, is_head = c.commit.branch, '', True
         else:
             _branch_name, _sha_commit_id, is_head = \
                 self._is_valid_head(commit_id, self.rhodecode_vcs_repo)
 
         error = self.forbid_non_head(is_head, f_path, json_mode=True)
         if error:
             return {
                 'error': error,
                 'redirect_url': default_redirect_url
             }
         error = self.check_branch_permission(_branch_name, json_mode=True)
         if error:
             return {
                 'error': error,
                 'redirect_url': default_redirect_url
             }
 
         c.default_message = (_('Uploaded file via RhodeCode Enterprise'))
         c.f_path = f_path
 
         r_post = self.request.POST
 
         message = c.default_message
         user_message = r_post.getall('message')
         if isinstance(user_message, list) and user_message:
             # we take the first from duplicated results if it's not empty
             message = user_message[0] if user_message[0] else message
 
         nodes = {}
 
         for file_obj in r_post.getall('files_upload') or []:
             content = file_obj.file
             filename = file_obj.filename
 
             root_path = f_path
             pure_path = self.create_pure_path(root_path, filename)
             node_path = safe_unicode(bytes(pure_path).lstrip('/'))
 
             nodes[node_path] = {
                 'content': content
             }
 
         if not nodes:
             error = 'missing files'
             return {
                 'error': error,
                 'redirect_url': default_redirect_url
             }
 
         author = self._rhodecode_db_user.full_contact
 
         try:
             commit = ScmModel().create_nodes(
                 user=self._rhodecode_db_user.user_id,
                 repo=self.db_repo,
                 message=message,
                 nodes=nodes,
                 parent_commit=c.commit,
                 author=author,
             )
             if len(nodes) == 1:
                 flash_message = _('Successfully committed {} new files').format(len(nodes))
             else:
                 flash_message = _('Successfully committed 1 new file')
 
             h.flash(flash_message, category='success')
 
             default_redirect_url = h.route_path(
                 'repo_commit', repo_name=self.db_repo_name, commit_id=commit.raw_id)
 
         except NonRelativePathError:
             log.exception('Non Relative path found')
             error = _('The location specified must be a relative path and must not '
                       'contain .. in the path')
             h.flash(error, category='warning')
 
             return {
                 'error': error,
                 'redirect_url': default_redirect_url
             }
         except (NodeError, NodeAlreadyExistsError) as e:
             error = h.escape(e)
             h.flash(error, category='error')
 
             return {
                 'error': error,
                 'redirect_url': default_redirect_url
             }
         except Exception:
             log.exception('Error occurred during commit')
             error = _('Error occurred during commit')
             h.flash(error, category='error')
             return {
                 'error': error,
                 'redirect_url': default_redirect_url
             }
 
         return {
             'error': None,
             'redirect_url': default_redirect_url
         }

rhodecode/lib/rc_cache/__init__.py

@@ -1,81 +1,81 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2015-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
 from dogpile.cache import register_backend
 
 register_backend(
     "dogpile.cache.rc.memory_lru", "rhodecode.lib.rc_cache.backends",
     "LRUMemoryBackend")
 
 register_backend(
     "dogpile.cache.rc.file_namespace", "rhodecode.lib.rc_cache.backends",
     "FileNamespaceBackend")
 
 register_backend(
     "dogpile.cache.rc.redis", "rhodecode.lib.rc_cache.backends",
     "RedisPickleBackend")
 
 register_backend(
     "dogpile.cache.rc.redis_msgpack", "rhodecode.lib.rc_cache.backends",
     "RedisMsgPackBackend")
 
 
 log = logging.getLogger(__name__)
 
 from . import region_meta
 from .utils import (
     get_default_cache_settings, backend_key_generator, get_or_create_region,
     clear_cache_namespace, make_region, InvalidationContext,
     FreshRegionCache, ActiveRegionCache)
 
 
-FILE_TREE_CACHE_VER = 'v2'
+FILE_TREE_CACHE_VER = 'v3'
 
 
 def configure_dogpile_cache(settings):
     cache_dir = settings.get('cache_dir')
     if cache_dir:
         region_meta.dogpile_config_defaults['cache_dir'] = cache_dir
 
     rc_cache_data = get_default_cache_settings(settings, prefixes=['rc_cache.'])
 
     # inspect available namespaces
     avail_regions = set()
     for key in rc_cache_data.keys():
         namespace_name = key.split('.', 1)[0]
         avail_regions.add(namespace_name)
     log.debug('dogpile: found following cache regions: %s', avail_regions)
 
     # register them into namespace
     for region_name in avail_regions:
         new_region = make_region(
             name=region_name,
             function_key_generator=None
         )
 
         new_region.configure_from_config(settings, 'rc_cache.{}.'.format(region_name))
         new_region.function_key_generator = backend_key_generator(new_region.actual_backend)
         log.debug('dogpile: registering a new region %s[%s]', region_name, new_region.__dict__)
         region_meta.dogpile_cache_regions[region_name] = new_region
 
 
 def includeme(config):
     configure_dogpile_cache(config.registry.settings)

rhodecode/public/js/src/rhodecode/files.js

@@ -1,519 +1,523 b''
 // # Copyright (C) 2010-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/
 
 /**
  * Search file list
  */
 
 var NodeFilter = {};
 
 var fileBrowserListeners = function (node_list_url, url_base) {
     var $filterInput = $('#node_filter');
     var n_filter = $filterInput.get(0);
 
     NodeFilter.filterTimeout = null;
     var nodes = null;
 
     NodeFilter.focus = function () {
         $filterInput.focus()
     };
 
     NodeFilter.fetchNodes = function (callback) {
         $.ajax(
             {url: node_list_url, headers: {'X-PARTIAL-XHR': true}})
             .done(function (data) {
                 nodes = data.nodes;
                 if (callback) {
                     callback();
                 }
             })
             .fail(function (data) {
                 console.log('failed to load');
             });
     };
 
     NodeFilter.initFilter = function (e) {
         if ($filterInput.hasClass('loading')) {
             return
         }
 
         // in case we are already loaded, do nothing
         if (!$filterInput.hasClass('init')) {
             return NodeFilter.handleKey(e);
         }
         var iconLoading = 'icon-spin animate-spin';
         var iconSearch = 'icon-search';
         $('.files-filter-box-path i').removeClass(iconSearch).addClass(iconLoading);
         $filterInput.addClass('loading');
 
         var callback = function (org) {
             return function () {
                 if ($filterInput.hasClass('init')) {
                     $filterInput.removeClass('init');
                     $filterInput.removeClass('loading');
                 }
                 $('.files-filter-box-path i').removeClass(iconLoading).addClass(iconSearch);
 
                 // auto re-filter if we filled in the input
                 if (n_filter.value !== "") {
                     NodeFilter.updateFilter(n_filter, e)()
                 }
 
             }
         };
         // load node data
         NodeFilter.fetchNodes(callback());
 
     };
 
     NodeFilter.resetFilter = function () {
         $('#tbody').show();
         $('#tbody_filtered').hide();
         $filterInput.val('');
     };
 
     NodeFilter.handleKey = function (e) {
         var scrollDown = function (element) {
             var elementBottom = element.offset().top + $(element).outerHeight();
             var windowBottom = window.innerHeight + $(window).scrollTop();
             if (elementBottom > windowBottom) {
                 var offset = elementBottom - window.innerHeight;
                 $('html,body').scrollTop(offset);
                 return false;
             }
             return true;
         };
 
         var scrollUp = function (element) {
             if (element.offset().top < $(window).scrollTop()) {
                 $('html,body').scrollTop(element.offset().top);
                 return false;
             }
             return true;
         };
         var $hlElem = $('.browser-highlight');
 
         if (e.keyCode === 40) { // Down
             if ($hlElem.length === 0) {
                 $('.browser-result').first().addClass('browser-highlight');
             } else {
                 var next = $hlElem.next();
                 if (next.length !== 0) {
                     $hlElem.removeClass('browser-highlight');
                     next.addClass('browser-highlight');
                 }
             }
 
             if ($hlElem.get(0) !== undefined){
                 scrollDown($hlElem);
             }
         }
         if (e.keyCode === 38) { // Up
             e.preventDefault();
             if ($hlElem.length !== 0) {
                 var next = $hlElem.prev();
                 if (next.length !== 0) {
                     $('.browser-highlight').removeClass('browser-highlight');
                     next.addClass('browser-highlight');
                 }
             }
 
             if ($hlElem.get(0) !== undefined){
                 scrollUp($hlElem);
             }
 
         }
         if (e.keyCode === 13) { // Enter
             if ($('.browser-highlight').length !== 0) {
                 var url = $('.browser-highlight').find('.match-link').attr('href');
                 window.location = url;
             }
         }
         if (e.keyCode === 27) { // Esc
             NodeFilter.resetFilter();
             $('html,body').scrollTop(0);
         }
 
         var capture_keys = [
             40, // ArrowDown
             38, // ArrowUp
             39, // ArrowRight
             37, // ArrowLeft
             13, // Enter
             27  // Esc
         ];
 
         if ($.inArray(e.keyCode, capture_keys) === -1) {
             clearTimeout(NodeFilter.filterTimeout);
             NodeFilter.filterTimeout = setTimeout(NodeFilter.updateFilter(n_filter, e), 200);
         }
 
     };
 
     NodeFilter.fuzzy_match = function (filepath, query) {
         var highlight = [];
         var order = 0;
         for (var i = 0; i < query.length; i++) {
             var match_position = filepath.indexOf(query[i]);
             if (match_position !== -1) {
                 var prev_match_position = highlight[highlight.length - 1];
                 if (prev_match_position === undefined) {
                     highlight.push(match_position);
                 } else {
                     var current_match_position = prev_match_position + match_position + 1;
                     highlight.push(current_match_position);
                     order = order + current_match_position - prev_match_position;
                 }
                 filepath = filepath.substring(match_position + 1);
             } else {
                 return false;
             }
         }
         return {
             'order': order,
             'highlight': highlight
         };
     };
 
     NodeFilter.sortPredicate = function (a, b) {
         if (a.order < b.order) return -1;
         if (a.order > b.order) return 1;
         if (a.filepath < b.filepath) return -1;
         if (a.filepath > b.filepath) return 1;
         return 0;
     };
 
     NodeFilter.updateFilter = function (elem, e) {
         return function () {
             // Reset timeout
             NodeFilter.filterTimeout = null;
             var query = elem.value.toLowerCase();
             var match = [];
             var matches_max = 20;
             if (query !== "") {
                 var results = [];
                 for (var k = 0; k < nodes.length; k++) {
                     var result = NodeFilter.fuzzy_match(
                             nodes[k].name.toLowerCase(), query);
                     if (result) {
                         result.type = nodes[k].type;
                         result.filepath = nodes[k].name;
                         results.push(result);
                     }
                 }
                 results = results.sort(NodeFilter.sortPredicate);
                 var limit = matches_max;
                 if (results.length < matches_max) {
                     limit = results.length;
                 }
                 for (var i = 0; i < limit; i++) {
                     if (query && results.length > 0) {
                         var n = results[i].filepath;
                         var t = results[i].type;
                         var n_hl = n.split("");
                         var pos = results[i].highlight;
                         for (var j = 0; j < pos.length; j++) {
                             n_hl[pos[j]] = "<em>" + n_hl[pos[j]] + "</em>";
                         }
                         n_hl = n_hl.join("");
                         var new_url = url_base.replace('__FPATH__', n);
 
                         var typeObj = {
                             dir: 'icon-directory browser-dir',
                             file: 'icon-file-text browser-file'
                         };
 
                         var typeIcon = '<i class="{0}"></i>'.format(typeObj[t]);
                         match.push('<tr class="browser-result"><td><a class="match-link" href="{0}">{1}{2}</a></td><td colspan="5"></td></tr>'.format(new_url, typeIcon, n_hl));
                     }
                 }
                 if (results.length > limit) {
                     var truncated_count = results.length - matches_max;
                     if (truncated_count === 1) {
                         match.push('<tr><td>{0} {1}</td><td colspan="5"></td></tr>'.format(truncated_count, _gettext('truncated result')));
                     } else {
                         match.push('<tr><td>{0} {1}</td><td colspan="5"></td></tr>'.format(truncated_count, _gettext('truncated results')));
                     }
                 }
             }
             if (query !== "") {
                 $('#tbody').hide();
                 $('#tbody_filtered').show();
 
                 if (match.length === 0) {
                     match.push('<tr><td>{0}</td><td colspan="5"></td></tr>'.format(_gettext('No matching files')));
                 }
                 $('#tbody_filtered').html(match.join(""));
             } else {
                 $('#tbody').show();
                 $('#tbody_filtered').hide();
             }
 
         };
     };
 
 };
 
 var getIdentNode = function(n){
   // iterate through nodes until matched interesting node
   if (typeof n === 'undefined'){
     return -1;
   }
   if(typeof n.id !== "undefined" && n.id.match('L[0-9]+')){
     return n;
   }
   else{
     return getIdentNode(n.parentNode);
   }
 };
 
 var getSelectionLink = function(e) {
   // get selection from start/to nodes
   if (typeof window.getSelection !== "undefined") {
     s = window.getSelection();
 
     from = getIdentNode(s.anchorNode);
     till = getIdentNode(s.focusNode);
 
     f_int = parseInt(from.id.replace('L',''));
     t_int = parseInt(till.id.replace('L',''));
 
     if (f_int > t_int){
       // highlight from bottom
       offset = -35;
       ranges = [t_int,f_int];
     }
     else{
       // highligth from top
       offset = 35;
       ranges = [f_int,t_int];
     }
     // if we select more than 2 lines
     if (ranges[0] !== ranges[1]){
       if($('#linktt').length === 0){
         hl_div = document.createElement('div');
         hl_div.id = 'linktt';
       }
       hl_div.innerHTML = '';
 
       anchor = '#L'+ranges[0]+'-'+ranges[1];
       var link = document.createElement('a');
       link.href = location.href.substring(0,location.href.indexOf('#'))+anchor;
       link.innerHTML = _gettext('Selection link');
       hl_div.appendChild(link);
       $('#codeblock').append(hl_div);
 
       var xy = $(till).offset();
       $('#linktt').addClass('hl-tip-box tip-box');
       $('#linktt').offset({top: xy.top + offset, left: xy.left});
       $('#linktt').css('visibility','visible');
     }
     else{
       $('#linktt').css('visibility','hidden');
     }
   }
 };
 
 var getFileState = function() {
     // relies on a global set filesUrlData
     var f_path = filesUrlData['f_path'];
     var commit_id = filesUrlData['commit_id'];
 
     var url_params = {
         repo_name: templateContext.repo_name,
         commit_id: commit_id,
         f_path:'__FPATH__'
     };
     if (atRef !== '') {
         url_params['at'] = atRef
     }
 
     var _url_base = pyroutes.url('repo_files', url_params);
     var _node_list_url = pyroutes.url('repo_files_nodelist',
             {repo_name: templateContext.repo_name,
              commit_id: commit_id, f_path: f_path});
 
     return {
         f_path: f_path,
         commit_id: commit_id,
         node_list_url: _node_list_url,
         url_base: _url_base
     };
 };
 
 var getFilesMetadata = function() {
     // relies on metadataRequest global state
     if (metadataRequest && metadataRequest.readyState != 4) {
         metadataRequest.abort();
     }
 
     if ($('#file-tree-wrapper').hasClass('full-load')) {
         // in case our HTML wrapper has full-load class we don't
         // trigger the async load of metadata
         return false;
     }
 
     var state = getFileState();
     var url_data = {
         'repo_name': templateContext.repo_name,
         'commit_id': state.commit_id,
-        'f_path': state.f_path
+        'f_path': state.f_path,
     };
 
+    if (atRef !== '') {
+        url_data['at'] = atRef
+    }
+
     var url = pyroutes.url('repo_nodetree_full', url_data);
 
     metadataRequest = $.ajax({url: url});
 
     metadataRequest.done(function(data) {
         $('#file-tree').html(data);
         timeagoActivate();
         tooltipActivate();
     });
     metadataRequest.fail(function (data, textStatus, errorThrown) {
         if (data.status != 0) {
             alert("Error while fetching metadata.\nError code {0} ({1}).Please consider reloading the page".format(data.status,data.statusText));
         }
     });
 };
 
 // show more authors
 var showAuthors = function(elem, annotate) {
     var state = getFileState('callbacks');
 
     var url = pyroutes.url('repo_file_authors',
                 {'repo_name': templateContext.repo_name,
                  'commit_id': state.commit_id, 'f_path': state.f_path});
 
     $.pjax({
         url: url,
         data: 'annotate={0}'.format(annotate),
         container: '#file_authors',
         push: false,
         timeout: 5000
     }).complete(function(){
         $(elem).hide();
         $('#file_authors_title').html(_gettext('All Authors'));
         tooltipActivate();
     })
 };
 
 
 (function (mod) {
 
     if (typeof exports == "object" && typeof module == "object") {
         // CommonJS
         module.exports = mod();
     } else {
         // Plain browser env
         (this || window).FileEditor = mod();
     }
 
 })(function () {
     "use strict";
 
     function FileEditor(textAreaElement, options) {
         if (!(this instanceof FileEditor)) {
             return new FileEditor(textAreaElement, options);
         }
         // bind the element instance to our Form
         var te = $(textAreaElement).get(0);
         if (te !== undefined) {
             te.FileEditor = this;
         }
 
         this.modes_select = '#set_mode';
         this.filename_selector = '#filename';
         this.commit_btn_selector = '#commit_btn';
         this.line_wrap_selector = '#line_wrap';
         this.editor_preview_selector = '#editor_preview';
 
         if (te !== undefined) {
             this.cm = initCodeMirror(textAreaElement, null, false);
         }
 
         // FUNCTIONS and helpers
         var self = this;
 
         this.submitHandler = function() {
             $(self.commit_btn_selector).on('click', function(e) {
 
                 var filename = $(self.filename_selector).val();
                 if (filename === "") {
                     alert("Missing filename");
                     e.preventDefault();
                 }
 
                 var button = $(this);
                 if (button.hasClass('clicked')) {
                     button.attr('disabled', true);
                 } else {
                     button.addClass('clicked');
                 }
             });
         };
         this.submitHandler();
 
         // on select line wraps change the editor
         this.lineWrapHandler = function () {
             $(self.line_wrap_selector).on('change', function (e) {
                 var selected = e.currentTarget;
                 var line_wraps = {'on': true, 'off': false}[selected.value];
                 setCodeMirrorLineWrap(self.cm, line_wraps)
             });
         };
         this.lineWrapHandler();
 
 
         this.showPreview = function () {
 
             var _text = self.cm.getValue();
             var _file_path = $(self.filename_selector).val();
             if (_text && _file_path) {
                 $('.show-preview').addClass('active');
                 $('.show-editor').removeClass('active');
 
                 $(self.editor_preview_selector).show();
                 $(self.cm.getWrapperElement()).hide();
 
 
                 var post_data = {'text': _text, 'file_path': _file_path, 'csrf_token': CSRF_TOKEN};
                 $(self.editor_preview_selector).html(_gettext('Loading ...'));
 
                 var url = pyroutes.url('file_preview');
 
                 ajaxPOST(url, post_data, function (o) {
                     $(self.editor_preview_selector).html(o);
                 })
             }
 
         };
 
         this.showEditor = function () {
             $(self.editor_preview_selector).hide();
             $('.show-editor').addClass('active');
             $('.show-preview').removeClass('active');
 
             $(self.cm.getWrapperElement()).show();
         };
 
 
     }
 
     return FileEditor;
 });
 

rhodecode/templates/files/base.mako

@@ -1,44 +1,59 b''
-<%def name="refs(commit)">
-    ## Build a cache of refs for selector
+<%def name="refs(commit, at_rev=None)">
+
+    ## Build a cache of refs for selector, based on this the files ref selector gets pre-selected values
     <script>
-        fileTreeRefs = {
+        fileTreeRefs = {}
+    </script>
 
-        }
-    </script>
+    % if h.is_svn(c.rhodecode_repo):
+        ## since SVN doesn't have an commit<->refs association, we simply inject it
+        ## based on our at_rev marker
+        % if at_rev and at_rev.startswith('branches/'):
+            <%
+                commit.branch = at_rev
+            %>
+        % endif
+        % if at_rev and at_rev.startswith('tags/'):
+            <%
+                commit.tags.append(at_rev)
+            %>
+        % endif
+
+    % endif
 
     %if commit.merge:
         <span class="mergetag tag">
          <i class="icon-merge">${_('merge')}</i>
         </span>
     %endif
 
     %if h.is_hg(c.rhodecode_repo):
         %for book in commit.bookmarks:
             <span class="booktag tag" title="${h.tooltip(_('Bookmark %s') % book)}">
               <a href="${h.route_path('repo_files:default_path',repo_name=c.repo_name,commit_id=commit.raw_id,_query=dict(at=book))}"><i class="icon-bookmark"></i>${h.shorter(book)}</a>
             </span>
             <script>
                 fileTreeRefs["${book}"] = {raw_id: "${commit.raw_id}", type:"book", text: "${book}"};
             </script>
         %endfor
     %endif
 
     %for tag in commit.tags:
         <span class="tagtag tag"  title="${h.tooltip(_('Tag %s') % tag)}">
             <a href="${h.route_path('repo_files:default_path',repo_name=c.repo_name,commit_id=commit.raw_id,_query=dict(at=tag))}"><i class="icon-tag"></i>${tag}</a>
         </span>
         <script>
             fileTreeRefs["${tag}"] = {raw_id: "${commit.raw_id}", type:"tag", text: "${tag}"};
         </script>
     %endfor
 
     %if commit.branch:
         <span class="branchtag tag" title="${h.tooltip(_('Branch %s') % commit.branch)}">
           <a href="${h.route_path('repo_files:default_path',repo_name=c.repo_name,commit_id=commit.raw_id,_query=dict(at=commit.branch))}"><i class="icon-code-fork"></i>${h.shorter(commit.branch)}</a>
         </span>
         <script>
             fileTreeRefs["${commit.branch}"] = {raw_id: "${commit.raw_id}", type:"branch", text: "${commit.branch}"};
         </script>
     %endif
 
 </%def>

rhodecode/templates/files/files.mako

@@ -1,372 +1,379 b''
 <%inherit file="/base/base.mako"/>
 
 <%def name="title(*args)">
     ${_('{} Files').format(c.repo_name)}
     %if hasattr(c,'file'):
         &middot; ${(h.safe_unicode(c.file.path) or '\\')}
     %endif
 
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}
     %endif
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${_('Files')}
     %if c.file:
         @ ${h.show_id(c.commit)}
     %endif
 </%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='repositories')}
 </%def>
 
 <%def name="menu_bar_subnav()">
     ${self.repo_menu(active='files')}
 </%def>
 
 <%def name="main()">
     <script type="text/javascript">
         var fileSourcePage = ${c.file_source_page};
         var atRef = '${request.GET.get('at', '')}';
 
         // global state for fetching metadata
         metadataRequest = null;
 
         // global metadata about URL
         filesUrlData = ${h.files_url_data(request)|n};
     </script>
 
     <div>
         <div>
             <%include file='files_pjax.mako'/>
         </div>
     </div>
 
     <script type="text/javascript">
 
         var initFileJS = function () {
             var state = getFileState();
 
             // select code link event
             $("#hlcode").mouseup(getSelectionLink);
 
             // file history select2 used for history of file, and switch to
             var initialCommitData = {
                 at_ref: atRef,
                 id: null,
                 text: '${c.commit.raw_id}',
                 type: 'sha',
                 raw_id: '${c.commit.raw_id}',
                 idx: ${c.commit.idx},
                 files_url: null,
             };
 
             // check if we have ref info.
             var selectedRef =  fileTreeRefs[atRef];
             if (selectedRef !== undefined) {
                 $.extend(initialCommitData, selectedRef)
             }
 
             var loadUrl = pyroutes.url('repo_file_history', {'repo_name': templateContext.repo_name, 'commit_id': state.commit_id,'f_path': state.f_path});
             var cacheKey = '__SINGLE_FILE_REFS__';
             var cachedDataSource = {};
 
             var loadRefsData = function (query) {
                 $.ajax({
                     url: loadUrl,
                     data: {},
                     dataType: 'json',
                     type: 'GET',
                     success: function (data) {
                         cachedDataSource[cacheKey] = data;
                         query.callback({results: data.results});
                     }
                 });
             };
 
             var feedRefsData = function (query, cachedData) {
                 var data = {results: []};
                 //filter results
                 $.each(cachedData.results, function () {
                     var section = this.text;
                     var children = [];
                     $.each(this.children, function () {
                         if (query.term.length === 0 || this.text.toUpperCase().indexOf(query.term.toUpperCase()) >= 0) {
                             children.push(this)
                         }
                     });
                     data.results.push({
                         'text': section,
                         'children': children
                     })
                 });
 
                 query.callback(data);
             };
 
             var select2FileHistorySwitcher = function (targetElement, loadUrl, initialData) {
                 var formatResult = function (result, container, query) {
                     return formatSelect2SelectionRefs(result);
                 };
 
                 var formatSelection = function (data, container) {
                     var commit_ref = data;
 
                     var tmpl = '';
                     if (commit_ref.type === 'sha') {
                         tmpl = (commit_ref.raw_id || "").substr(0,8);
                     } else if (commit_ref.type === 'branch') {
                         tmpl = tmpl.concat('<i class="icon-branch"></i> ');
                         tmpl = tmpl.concat(escapeHtml(commit_ref.text));
                     } else if (commit_ref.type === 'tag') {
                         tmpl = tmpl.concat('<i class="icon-tag"></i> ');
                         tmpl = tmpl.concat(escapeHtml(commit_ref.text));
                     } else if (commit_ref.type === 'book') {
                         tmpl = tmpl.concat('<i class="icon-bookmark"></i> ');
                         tmpl = tmpl.concat(escapeHtml(commit_ref.text));
                     }
                     var idx = commit_ref.idx || 0;
                     if (idx !== 0) {
                         tmpl = tmpl.concat('<span class="select-index-number">r{0}</span>'.format(idx));
                     }
                     return tmpl
                 };
 
               $(targetElement).select2({
                 dropdownAutoWidth: true,
                 width: "resolve",
                 containerCssClass: "drop-menu",
                 dropdownCssClass: "drop-menu-dropdown",
                 query: function(query) {
                   var cachedData = cachedDataSource[cacheKey];
                   if (cachedData) {
                     feedRefsData(query, cachedData)
                   } else {
                     loadRefsData(query)
                   }
                 },
                 initSelection: function(element, callback) {
                   callback(initialData);
                 },
                 formatResult: formatResult,
                 formatSelection: formatSelection
               });
 
             };
 
             select2FileHistorySwitcher('#file_refs_filter', loadUrl, initialCommitData);
 
+            // switcher for files
             $('#file_refs_filter').on('change', function(e) {
                 var data = $('#file_refs_filter').select2('data');
                 var commit_id = data.id;
+                var params = {
+                    'repo_name': templateContext.repo_name,
+                    'commit_id': commit_id,
+                    'f_path': state.f_path
+                };
+
+                if(data.at_rev !== undefined && data.at_rev !== "") {
+                    params['at'] = data.at_rev;
+                }
 
                 if ("${c.annotate}" === "True") {
-                    var url = pyroutes.url('repo_files:annotated',
-                            {'repo_name': templateContext.repo_name,
-                             'commit_id': commit_id, 'f_path': state.f_path});
+                    var url = pyroutes.url('repo_files:annotated', params);
                 } else {
-                    var url = pyroutes.url('repo_files',
-                            {'repo_name': templateContext.repo_name,
-                             'commit_id': commit_id, 'f_path': state.f_path});
+                    var url = pyroutes.url('repo_files', params);
                 }
                 window.location = url;
 
             });
 
             // load file short history
             $('#file_history_overview').on('click', function(e) {
                 e.preventDefault();
                 path = state.f_path;
                 if (path.indexOf("#") >= 0) {
                     path = path.slice(0, path.indexOf("#"));
                 }
                 var url = pyroutes.url('repo_commits_file',
                         {'repo_name': templateContext.repo_name,
                          'commit_id': state.commit_id, 'f_path': path, 'limit': 6});
                 $('#file_history_container').show();
                 $('#file_history_container').html('<div class="file-history-inner">{0}</div>'.format(_gettext('Loading ...')));
 
                 $.pjax({
                     url: url,
                     container: '#file_history_container',
                     push: false,
                     timeout: 5000
                 }).complete(function () {
                     tooltipActivate();
                 });
             });
 
         };
 
         var initTreeJS = function () {
             var state = getFileState();
             getFilesMetadata();
 
             // fuzzy file filter
             fileBrowserListeners(state.node_list_url, state.url_base);
 
             // switch to widget
             var initialCommitData = {
                 at_ref: atRef,
                 id: null,
                 text: '${c.commit.raw_id}',
                 type: 'sha',
                 raw_id: '${c.commit.raw_id}',
                 idx: ${c.commit.idx},
                 files_url: null,
             };
 
             // check if we have ref info.
             var selectedRef =  fileTreeRefs[atRef];
             if (selectedRef !== undefined) {
                 $.extend(initialCommitData, selectedRef)
             }
 
             var loadUrl = pyroutes.url('repo_refs_data', {'repo_name': templateContext.repo_name});
             var cacheKey = '__ALL_FILE_REFS__';
             var cachedDataSource = {};
 
             var loadRefsData = function (query) {
                 $.ajax({
                     url: loadUrl,
                     data: {},
                     dataType: 'json',
                     type: 'GET',
                     success: function (data) {
                         cachedDataSource[cacheKey] = data;
                         query.callback({results: data.results});
                     }
                 });
             };
 
             var feedRefsData = function (query, cachedData) {
                 var data = {results: []};
                 //filter results
                 $.each(cachedData.results, function () {
                     var section = this.text;
                     var children = [];
                     $.each(this.children, function () {
                         if (query.term.length === 0 || this.text.toUpperCase().indexOf(query.term.toUpperCase()) >= 0) {
                             children.push(this)
                         }
                     });
                     data.results.push({
                         'text': section,
                         'children': children
                     })
                 });
 
                 //push the typed in commit idx
                 if (!isNaN(query.term)) {
                     var files_url = pyroutes.url('repo_files',
                                 {'repo_name': templateContext.repo_name,
                                  'commit_id': query.term, 'f_path': state.f_path});
 
                     data.results.push({
                         'text': _gettext('go to numeric commit'),
                         'children': [{
                             at_ref: null,
                             id: null,
                             text: 'r{0}'.format(query.term),
                             type: 'sha',
                             raw_id: query.term,
                             idx: query.term,
                             files_url: files_url,
                         }]
                     });
                 }
                 query.callback(data);
             };
 
             var select2RefFileSwitcher = function (targetElement, loadUrl, initialData) {
                 var formatResult = function (result, container, query) {
                     return formatSelect2SelectionRefs(result);
                 };
 
                 var formatSelection = function (data, container) {
                     var commit_ref = data;
 
                     var tmpl = '';
                     if (commit_ref.type === 'sha') {
                         tmpl = (commit_ref.raw_id || "").substr(0,8);
                     } else if (commit_ref.type === 'branch') {
                         tmpl = tmpl.concat('<i class="icon-branch"></i> ');
                         tmpl = tmpl.concat(escapeHtml(commit_ref.text));
                     } else if (commit_ref.type === 'tag') {
                         tmpl = tmpl.concat('<i class="icon-tag"></i> ');
                         tmpl = tmpl.concat(escapeHtml(commit_ref.text));
                     } else if (commit_ref.type === 'book') {
                         tmpl = tmpl.concat('<i class="icon-bookmark"></i> ');
                         tmpl = tmpl.concat(escapeHtml(commit_ref.text));
                     }
 
                     var idx = commit_ref.idx || 0;
                     if (idx !== 0) {
                         tmpl = tmpl.concat('<span class="select-index-number">r{0}</span>'.format(idx));
                     }
                     return tmpl
                 };
 
               $(targetElement).select2({
                 dropdownAutoWidth: true,
                 width: "resolve",
                 containerCssClass: "drop-menu",
                 dropdownCssClass: "drop-menu-dropdown",
                 query: function(query) {
 
                   var cachedData = cachedDataSource[cacheKey];
                   if (cachedData) {
                     feedRefsData(query, cachedData)
                   } else {
                     loadRefsData(query)
                   }
                 },
                 initSelection: function(element, callback) {
                   callback(initialData);
                 },
                 formatResult: formatResult,
                 formatSelection: formatSelection
               });
 
             };
 
             select2RefFileSwitcher('#refs_filter', loadUrl, initialCommitData);
 
+            // switcher for file tree
             $('#refs_filter').on('change', function(e) {
                 var data = $('#refs_filter').select2('data');
                 window.location = data.files_url
             });
 
         };
 
         $(document).ready(function() {
             timeagoActivate();
             tooltipActivate();
 
             if ($('#trimmed_message_box').height() < 50) {
                 $('#message_expand').hide();
             }
 
             $('#message_expand').on('click', function(e) {
                 $('#trimmed_message_box').css('max-height', 'none');
                 $(this).hide();
             });
 
             if (fileSourcePage) {
                 initFileJS()
             } else {
                 initTreeJS()
             }
 
             var search_GET = "${request.GET.get('search','')}";
             if (search_GET === "1") {
                 NodeFilter.initFilter();
                 NodeFilter.focus();
             }
         });
 
     </script>
 
 </%def>
  No newline at end of file

rhodecode/templates/files/files_browser_tree.mako

@@ -1,96 +1,95 b''
 <%namespace name="base" file="/base/base.mako"/>
 
 <%
     if request.GET.get('at'):
         query={'at': request.GET.get('at')}
     else:
         query=None
 %>
 <div id="file-tree-wrapper" class="browser-body ${('full-load' if c.full_load else '')}">
     <table class="code-browser rctable repo_summary">
         <thead>
             <tr>
                 <th>${_('Name')}</th>
                 <th>${_('Size')}</th>
                 <th>${_('Modified')}</th>
                 <th>${_('Last Commit')}</th>
                 <th>${_('Author')}</th>
             </tr>
         </thead>
 
         <tbody id="tbody">
         <tr>
             <td colspan="5">
                 ${h.files_breadcrumbs(c.repo_name,c.commit.raw_id,c.file.path, request.GET.get('at'), limit_items=True)}
             </td>
         </tr>
 
         <% has_files = False %>
         % for cnt,node in enumerate(c.file):
         <% has_files = True %>
         <tr class="parity${(cnt % 2)}">
             <td class="td-componentname">
             % if node.is_submodule():
               <span class="submodule-dir">
                 % if node.url.startswith('http://') or node.url.startswith('https://'):
                   <a href="${node.url}">
                       <i class="icon-directory browser-dir"></i>${node.name}
                   </a>
                 % else:
                   <i class="icon-directory browser-dir"></i>${node.name}
                 % endif
               </span>
             % else:
-
               <a href="${h.route_path('repo_files',repo_name=c.repo_name,commit_id=c.commit.raw_id,f_path=h.safe_unicode(node.path), _query=query)}">
                 <i class="${('icon-file-text browser-file' if node.is_file() else 'icon-directory browser-dir')}"></i>${node.name}
               </a>
             % endif
             </td>
             %if node.is_file():
               <td class="td-size" data-attr-name="size">
                   % if c.full_load:
                     <span data-size="${node.size}">${h.format_byte_size_binary(node.size)}</span>
                   % else:
                     ${_('Loading ...')}
                   % endif
               </td>
               <td class="td-time" data-attr-name="modified_at">
                   % if c.full_load:
                     <span data-date="${node.last_commit.date}">${h.age_component(node.last_commit.date)}</span>
                   % endif
               </td>
               <td class="td-hash" data-attr-name="commit_id">
                   % if c.full_load:
                   <div class="tooltip-hovercard" data-hovercard-alt="${node.last_commit.message}" data-hovercard-url="${h.route_path('hovercard_repo_commit', repo_name=c.repo_name, commit_id=node.last_commit.raw_id)}">
                       <pre data-commit-id="${node.last_commit.raw_id}">r${node.last_commit.idx}:${node.last_commit.short_id}</pre>
                   </div>
                   % endif
               </td>
               <td class="td-user" data-attr-name="author">
                   % if c.full_load:
                   <span data-author="${node.last_commit.author}">${h.gravatar_with_user(request, node.last_commit.author, tooltip=True)|n}</span>
                   % endif
               </td>
             %else:
               <td></td>
               <td></td>
               <td></td>
               <td></td>
             %endif
           </tr>
         % endfor
 
         % if not has_files:
         <tr>
             <td colspan="5">
                 ##empty-dir mostly SVN
                 &nbsp;
             </td>
         </tr>
         % endif
 
         </tbody>
         <tbody id="tbody_filtered"></tbody>
     </table>
 </div>

rhodecode/templates/files/files_source_header.mako

@@ -1,65 +1,65 b''
 <%namespace name="base" file="/base/base.mako"/>
 <%namespace name="file_base" file="/files/base.mako"/>
 
 <div class="summary">
   <div class="fieldset">
     <div class="left-content">
       <%
         rc_user = h.discover_user(c.commit.author_email)
       %>
       <div class="left-content-avatar">
         ${base.gravatar(c.file_last_commit.author_email, 30, tooltip=(True if rc_user else False), user=rc_user)}
       </div>
 
       <div class="left-content-message">
       <div class="fieldset collapsable-content no-hide" data-toggle="summary-details">
         <div class="commit truncate-wrap">${h.urlify_commit_message(h.chop_at_smart(c.commit.message, '\n', suffix_if_chopped='...'), c.repo_name)}</div>
       </div>
 
       <div class="fieldset collapsable-content" data-toggle="summary-details">
         <div class="commit">${h.urlify_commit_message(c.commit.message,c.repo_name)}</div>
       </div>
 
       <div class="fieldset" data-toggle="summary-details">
         <div class="" id="file_authors">
           ## loads single author, or ALL
           <%include file='file_authors_box.mako'/>
         </div>
       </div>
       </div>
 
       <div class="fieldset collapsable-content" data-toggle="summary-details">
         <div class="left-label-summary-files">
             <p>${_('File last commit')}:</p>
             <div class="right-label-summary">
               <code><a href="${h.route_path('repo_commit',repo_name=c.repo_name,commit_id=c.file_last_commit.raw_id)}">${h.show_id(c.file_last_commit)}</a></code>
-            ${file_base.refs(c.file_last_commit)}
+              ${file_base.refs(c.file_last_commit)}
           </div>
         </div>
       </div>
     </div>
 
     <div class="right-content">
       <div data-toggle="summary-details">
           <div class="tags tags-main">
             <code>
                 <a href="${h.route_path('repo_commit',repo_name=c.repo_name,commit_id=c.commit.raw_id)}">${h.show_id(c.commit)}</a>
             </code>
             <i class="tooltip icon-clipboard clipboard-action" data-clipboard-text="${c.commit.raw_id}" title="${_('Copy the full commit id')}"></i>
-            ${file_base.refs(c.commit)}
+            ${file_base.refs(c.commit, request.GET.get('at'))}
           </div>
       </div>
     </div>
 
     <div class="clear-fix"></div>
 
     <div  class="btn-collapse" data-toggle="summary-details">
         ${_('Show More')}
     </div>
 
   </div>
 </div>
 
 <script>
   collapsableContent();
 </script>

rhodecode/templates/files/files_tree_header.mako

@@ -1,49 +1,50 b''
 <%namespace name="base" file="/base/base.mako"/>
 <%namespace name="file_base" file="/files/base.mako"/>
 
 <div class="summary">
   <div class="fieldset">
     <div class="left-content">
       <%
         rc_user = h.discover_user(c.commit.author_email)
       %>
       <div class="left-content-avatar">
         ${base.gravatar(c.commit.author_email, 30, tooltip=(True if rc_user else False), user=rc_user)}
       </div>
 
       <div class="left-content-message">
         <div class="fieldset collapsable-content no-hide" data-toggle="summary-details">
           <div class="commit truncate-wrap">${h.urlify_commit_message(h.chop_at_smart(c.commit.message, '\n', suffix_if_chopped='...'), c.repo_name)}</div>
         </div>
 
         <div class="fieldset collapsable-content" data-toggle="summary-details">
           <div class="commit">${h.urlify_commit_message(c.commit.message,c.repo_name)}</div>
         </div>
 
         <div class="fieldset clear-fix">
           <span class="commit-author">${h.link_to_user(c.commit.author)}</span><span class="commit-date"> - ${h.age_component(c.commit.date)}</span>
         </div>
       </div>
     </div>
 
     <div class="right-content">
       <div class="tags">
         <code>
             <a href="${h.route_path('repo_commit',repo_name=c.repo_name,commit_id=c.commit.raw_id)}">${h.show_id(c.commit)}</a>
         </code>
 
         <i class="tooltip icon-clipboard clipboard-action" data-clipboard-text="${c.commit.raw_id}" title="${_('Copy the full commit id')}"></i>
-        ${file_base.refs(c.commit)}
+        ${file_base.refs(c.commit, request.GET.get('at'))}
+
       </div>
     </div>
 
     <div class="clear-fix"></div>
 
     <div  class="btn-collapse" data-toggle="summary-details">
         ${_('Show More')}
     </div>
   </div>
 </div>
 <script>
   collapsableContent();
 </script>