landing-refs: create helpers for landing ref to make clear indication about type/name

rhodecode/apps/repository/tests/test_repo_files.py

@@ -1,1070 +1,1070 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 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 os
 
 import mock
 import pytest
 
 from rhodecode.apps.repository.tests.test_repo_compare import ComparePage
 from rhodecode.apps.repository.views.repo_files import RepoFilesView
 from rhodecode.lib import helpers as h
 from rhodecode.lib.compat import OrderedDict
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.vcs import nodes
 
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.tests import assert_session_flash
 from rhodecode.tests.fixture import Fixture
 from rhodecode.model.db import Session
 
 fixture = Fixture()
 
 
 def get_node_history(backend_type):
     return {
         'hg': json.loads(fixture.load_resource('hg_node_history_response.json')),
         'git': json.loads(fixture.load_resource('git_node_history_response.json')),
         'svn': json.loads(fixture.load_resource('svn_node_history_response.json')),
     }[backend_type]
 
 
 def route_path(name, params=None, **kwargs):
     import urllib
 
     base_url = {
         'repo_summary': '/{repo_name}',
         'repo_archivefile': '/{repo_name}/archive/{fname}',
         'repo_files_diff': '/{repo_name}/diff/{f_path}',
         'repo_files_diff_2way_redirect':  '/{repo_name}/diff-2way/{f_path}',
         'repo_files': '/{repo_name}/files/{commit_id}/{f_path}',
         'repo_files:default_path': '/{repo_name}/files/{commit_id}/',
         'repo_files:default_commit': '/{repo_name}/files',
         'repo_files:rendered': '/{repo_name}/render/{commit_id}/{f_path}',
         'repo_files:annotated': '/{repo_name}/annotate/{commit_id}/{f_path}',
         'repo_files:annotated_previous': '/{repo_name}/annotate-previous/{commit_id}/{f_path}',
         'repo_files_nodelist': '/{repo_name}/nodelist/{commit_id}/{f_path}',
         'repo_file_raw': '/{repo_name}/raw/{commit_id}/{f_path}',
         'repo_file_download': '/{repo_name}/download/{commit_id}/{f_path}',
         'repo_file_history': '/{repo_name}/history/{commit_id}/{f_path}',
         'repo_file_authors': '/{repo_name}/authors/{commit_id}/{f_path}',
         'repo_files_remove_file': '/{repo_name}/remove_file/{commit_id}/{f_path}',
         'repo_files_delete_file': '/{repo_name}/delete_file/{commit_id}/{f_path}',
         'repo_files_edit_file': '/{repo_name}/edit_file/{commit_id}/{f_path}',
         'repo_files_update_file': '/{repo_name}/update_file/{commit_id}/{f_path}',
         'repo_files_add_file': '/{repo_name}/add_file/{commit_id}/{f_path}',
         'repo_files_create_file': '/{repo_name}/create_file/{commit_id}/{f_path}',
         'repo_nodetree_full': '/{repo_name}/nodetree_full/{commit_id}/{f_path}',
         'repo_nodetree_full:default_path': '/{repo_name}/nodetree_full/{commit_id}/',
     }[name].format(**kwargs)
 
     if params:
         base_url = '{}?{}'.format(base_url, urllib.urlencode(params))
     return base_url
 
 
 def assert_files_in_response(response, files, params):
     template = (
         'href="/%(repo_name)s/files/%(commit_id)s/%(name)s"')
     _assert_items_in_response(response, files, template, params)
 
 
 def assert_dirs_in_response(response, dirs, params):
     template = (
         'href="/%(repo_name)s/files/%(commit_id)s/%(name)s"')
     _assert_items_in_response(response, dirs, template, params)
 
 
 def _assert_items_in_response(response, items, template, params):
     for item in items:
         item_params = {'name': item}
         item_params.update(params)
         response.mustcontain(template % item_params)
 
 
 def assert_timeago_in_response(response, items, params):
     for item in items:
         response.mustcontain(h.age_component(params['date']))
 
 
 @pytest.mark.usefixtures("app")
 class TestFilesViews(object):
 
     def test_show_files(self, backend):
         response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/'))
         commit = backend.repo.get_commit()
 
         params = {
             'repo_name': backend.repo_name,
             'commit_id': commit.raw_id,
             'date': commit.date
         }
         assert_dirs_in_response(response, ['docs', 'vcs'], params)
         files = [
             '.gitignore',
             '.hgignore',
             '.hgtags',
             # TODO: missing in Git
             # '.travis.yml',
             'MANIFEST.in',
             'README.rst',
             # TODO: File is missing in svn repository
             # 'run_test_and_report.sh',
             'setup.cfg',
             'setup.py',
             'test_and_report.sh',
             'tox.ini',
         ]
         assert_files_in_response(response, files, params)
         assert_timeago_in_response(response, files, params)
 
     def test_show_files_links_submodules_with_absolute_url(self, backend_hg):
         repo = backend_hg['subrepos']
         response = self.app.get(
             route_path('repo_files',
                        repo_name=repo.repo_name,
                        commit_id='tip', f_path='/'))
         assert_response = response.assert_response()
         assert_response.contains_one_link(
             'absolute-path @ 000000000000', 'http://example.com/absolute-path')
 
     def test_show_files_links_submodules_with_absolute_url_subpaths(
             self, backend_hg):
         repo = backend_hg['subrepos']
         response = self.app.get(
             route_path('repo_files',
                        repo_name=repo.repo_name,
                        commit_id='tip', f_path='/'))
         assert_response = response.assert_response()
         assert_response.contains_one_link(
             'subpaths-path @ 000000000000',
             'http://sub-base.example.com/subpaths-path')
 
     @pytest.mark.xfail_backends("svn", reason="Depends on branch support")
     def test_files_menu(self, backend):
         new_branch = "temp_branch_name"
         commits = [
             {'message': 'a'},
             {'message': 'b', 'branch': new_branch}
         ]
         backend.create_repo(commits)
         backend.repo.landing_rev = "branch:%s" % new_branch
         Session().commit()
 
         # get response based on tip and not new commit
         response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/'))
 
         # make sure Files menu url is not tip but new commit
-        landing_rev = backend.repo.landing_rev[1]
+        landing_rev = backend.repo.landing_ref_name
         files_url = route_path('repo_files:default_path',
                                repo_name=backend.repo_name,
                                commit_id=landing_rev)
 
         assert landing_rev != 'tip'
         response.mustcontain(
             '<li class="active"><a class="menulink" href="%s">' % files_url)
 
     def test_show_files_commit(self, backend):
         commit = backend.repo.get_commit(commit_idx=32)
 
         response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/'))
 
         dirs = ['docs', 'tests']
         files = ['README.rst']
         params = {
             'repo_name': backend.repo_name,
             'commit_id': commit.raw_id,
         }
         assert_dirs_in_response(response, dirs, params)
         assert_files_in_response(response, files, params)
 
     def test_show_files_different_branch(self, backend):
         branches = dict(
             hg=(150, ['git']),
             # TODO: Git test repository does not contain other branches
             git=(633, ['master']),
             # TODO: Branch support in Subversion
             svn=(150, [])
         )
         idx, branches = branches[backend.alias]
         commit = backend.repo.get_commit(commit_idx=idx)
         response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/'))
 
         assert_response = response.assert_response()
         for branch in branches:
             assert_response.element_contains('.tags .branchtag', branch)
 
     def test_show_files_paging(self, backend):
         repo = backend.repo
         indexes = [73, 92, 109, 1, 0]
         idx_map = [(rev, repo.get_commit(commit_idx=rev).raw_id)
                    for rev in indexes]
 
         for idx in idx_map:
             response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id=idx[1], f_path='/'))
 
             response.mustcontain("""r%s:%s""" % (idx[0], idx[1][:8]))
 
     def test_file_source(self, backend):
         commit = backend.repo.get_commit(commit_idx=167)
         response = self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='vcs/nodes.py'))
 
         msgbox = """<div class="commit">%s</div>"""
         response.mustcontain(msgbox % (commit.message, ))
 
         assert_response = response.assert_response()
         if commit.branch:
             assert_response.element_contains(
                 '.tags.tags-main .branchtag', commit.branch)
         if commit.tags:
             for tag in commit.tags:
                 assert_response.element_contains('.tags.tags-main .tagtag', tag)
 
     def test_file_source_annotated(self, backend):
         response = self.app.get(
             route_path('repo_files:annotated',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='vcs/nodes.py'))
         expected_commits = {
             'hg': 'r356',
             'git': 'r345',
             'svn': 'r208',
         }
         response.mustcontain(expected_commits[backend.alias])
 
     def test_file_source_authors(self, backend):
         response = self.app.get(
             route_path('repo_file_authors',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='vcs/nodes.py'))
         expected_authors = {
             'hg': ('Marcin Kuzminski', 'Lukasz Balcerzak'),
             'git': ('Marcin Kuzminski', 'Lukasz Balcerzak'),
             'svn': ('marcin', 'lukasz'),
         }
 
         for author in expected_authors[backend.alias]:
             response.mustcontain(author)
 
     def test_file_source_authors_with_annotation(self, backend):
         response = self.app.get(
             route_path('repo_file_authors',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='vcs/nodes.py',
                        params=dict(annotate=1)))
         expected_authors = {
             'hg': ('Marcin Kuzminski', 'Lukasz Balcerzak'),
             'git': ('Marcin Kuzminski', 'Lukasz Balcerzak'),
             'svn': ('marcin', 'lukasz'),
         }
 
         for author in expected_authors[backend.alias]:
             response.mustcontain(author)
 
     def test_file_source_history(self, backend, xhr_header):
         response = self.app.get(
             route_path('repo_file_history',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='vcs/nodes.py'),
             extra_environ=xhr_header)
         assert get_node_history(backend.alias) == json.loads(response.body)
 
     def test_file_source_history_svn(self, backend_svn, xhr_header):
         simple_repo = backend_svn['svn-simple-layout']
         response = self.app.get(
             route_path('repo_file_history',
                        repo_name=simple_repo.repo_name,
                        commit_id='tip', f_path='trunk/example.py'),
             extra_environ=xhr_header)
 
         expected_data = json.loads(
             fixture.load_resource('svn_node_history_branches.json'))
 
         assert expected_data == response.json
 
     def test_file_source_history_with_annotation(self, backend, xhr_header):
         response = self.app.get(
             route_path('repo_file_history',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='vcs/nodes.py',
                        params=dict(annotate=1)),
 
             extra_environ=xhr_header)
         assert get_node_history(backend.alias) == json.loads(response.body)
 
     def test_tree_search_top_level(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_files_nodelist',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/'),
             extra_environ=xhr_header)
         assert 'nodes' in response.json
         assert {'name': 'docs', 'type': 'dir'} in response.json['nodes']
 
     def test_tree_search_missing_xhr(self, backend):
         self.app.get(
             route_path('repo_files_nodelist',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/'),
             status=404)
 
     def test_tree_search_at_path(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_files_nodelist',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/docs'),
             extra_environ=xhr_header)
         assert 'nodes' in response.json
         nodes = response.json['nodes']
         assert {'name': 'docs/api', 'type': 'dir'} in nodes
         assert {'name': 'docs/index.rst', 'type': 'file'} in nodes
 
     def test_tree_search_at_path_2nd_level(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_files_nodelist',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/docs/api'),
             extra_environ=xhr_header)
         assert 'nodes' in response.json
         nodes = response.json['nodes']
         assert {'name': 'docs/api/index.rst', 'type': 'file'} in nodes
 
     def test_tree_search_at_path_missing_xhr(self, backend):
         self.app.get(
             route_path('repo_files_nodelist',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/docs'),
             status=404)
 
     def test_nodetree(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_nodetree_full',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/'),
             extra_environ=xhr_header)
 
         assert_response = response.assert_response()
 
         for attr in ['data-commit-id', 'data-date', 'data-author']:
             elements = assert_response.get_elements('[{}]'.format(attr))
             assert len(elements) > 1
 
             for element in elements:
                 assert element.get(attr)
 
     def test_nodetree_if_file(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_nodetree_full',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='README.rst'),
             extra_environ=xhr_header)
         assert response.body == ''
 
     def test_nodetree_wrong_path(self, backend, xhr_header):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_nodetree_full',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='/dont-exist'),
             extra_environ=xhr_header)
 
         err = 'error: There is no file nor ' \
               'directory at the given path'
         assert err in response.body
 
     def test_nodetree_missing_xhr(self, backend):
         self.app.get(
             route_path('repo_nodetree_full',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/'),
             status=404)
 
 
 @pytest.mark.usefixtures("app", "autologin_user")
 class TestRawFileHandling(object):
 
     def test_download_file(self, backend):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_file_download',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='vcs/nodes.py'),)
 
         assert response.content_disposition == 'attachment; filename="nodes.py"; filename*=UTF-8\'\'nodes.py'
         assert response.content_type == "text/x-python"
 
     def test_download_file_wrong_cs(self, backend):
         raw_id = u'ERRORce30c96924232dffcd24178a07ffeb5dfc'
 
         response = self.app.get(
             route_path('repo_file_download',
                        repo_name=backend.repo_name,
                        commit_id=raw_id, f_path='vcs/nodes.svg'),
             status=404)
 
         msg = """No such commit exists for this repository"""
         response.mustcontain(msg)
 
     def test_download_file_wrong_f_path(self, backend):
         commit = backend.repo.get_commit(commit_idx=173)
         f_path = 'vcs/ERRORnodes.py'
 
         response = self.app.get(
             route_path('repo_file_download',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path=f_path),
             status=404)
 
         msg = (
             "There is no file nor directory at the given path: "
             "`%s` at commit %s" % (f_path, commit.short_id))
         response.mustcontain(msg)
 
     def test_file_raw(self, backend):
         commit = backend.repo.get_commit(commit_idx=173)
         response = self.app.get(
             route_path('repo_file_raw',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path='vcs/nodes.py'),)
 
         assert response.content_type == "text/plain"
 
     def test_file_raw_binary(self, backend):
         commit = backend.repo.get_commit()
         response = self.app.get(
             route_path('repo_file_raw',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id,
                        f_path='docs/theme/ADC/static/breadcrumb_background.png'),)
 
         assert response.content_disposition == 'inline'
 
     def test_raw_file_wrong_cs(self, backend):
         raw_id = u'ERRORcce30c96924232dffcd24178a07ffeb5dfc'
 
         response = self.app.get(
             route_path('repo_file_raw',
                        repo_name=backend.repo_name,
                        commit_id=raw_id, f_path='vcs/nodes.svg'),
             status=404)
 
         msg = """No such commit exists for this repository"""
         response.mustcontain(msg)
 
     def test_raw_wrong_f_path(self, backend):
         commit = backend.repo.get_commit(commit_idx=173)
         f_path = 'vcs/ERRORnodes.py'
         response = self.app.get(
             route_path('repo_file_raw',
                        repo_name=backend.repo_name,
                        commit_id=commit.raw_id, f_path=f_path),
             status=404)
 
         msg = (
             "There is no file nor directory at the given path: "
             "`%s` at commit %s" % (f_path, commit.short_id))
         response.mustcontain(msg)
 
     def test_raw_svg_should_not_be_rendered(self, backend):
         backend.create_repo()
         backend.ensure_file("xss.svg")
         response = self.app.get(
             route_path('repo_file_raw',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='xss.svg'),)
         # If the content type is image/svg+xml then it allows to render HTML
         # and malicious SVG.
         assert response.content_type == "text/plain"
 
 
 @pytest.mark.usefixtures("app")
 class TestRepositoryArchival(object):
 
     def test_archival(self, backend):
         backend.enable_downloads()
         commit = backend.repo.get_commit(commit_idx=173)
         for a_type, content_type, extension in settings.ARCHIVE_SPECS:
 
             short = commit.short_id + extension
             fname = commit.raw_id + extension
             filename = '%s-%s' % (backend.repo_name, short)
             response = self.app.get(
                 route_path('repo_archivefile',
                            repo_name=backend.repo_name,
                            fname=fname))
 
             assert response.status == '200 OK'
             headers = [
                 ('Content-Disposition', 'attachment; filename=%s' % filename),
                 ('Content-Type', '%s' % content_type),
             ]
 
             for header in headers:
                 assert header in response.headers.items()
 
     @pytest.mark.parametrize('arch_ext',[
         'tar', 'rar', 'x', '..ax', '.zipz', 'tar.gz.tar'])
     def test_archival_wrong_ext(self, backend, arch_ext):
         backend.enable_downloads()
         commit = backend.repo.get_commit(commit_idx=173)
 
         fname = commit.raw_id + '.' + arch_ext
 
         response = self.app.get(
             route_path('repo_archivefile',
                        repo_name=backend.repo_name,
                        fname=fname))
         response.mustcontain(
             'Unknown archive type for: `{}`'.format(fname))
 
     @pytest.mark.parametrize('commit_id', [
         '00x000000', 'tar', 'wrong', '@$@$42413232', '232dffcd'])
     def test_archival_wrong_commit_id(self, backend, commit_id):
         backend.enable_downloads()
         fname = '%s.zip' % commit_id
 
         response = self.app.get(
             route_path('repo_archivefile',
                        repo_name=backend.repo_name,
                        fname=fname))
         response.mustcontain('Unknown commit_id')
 
 
 @pytest.mark.usefixtures("app")
 class TestFilesDiff(object):
 
     @pytest.mark.parametrize("diff", ['diff', 'download', 'raw'])
     def test_file_full_diff(self, backend, diff):
         commit1 = backend.repo.get_commit(commit_idx=-1)
         commit2 = backend.repo.get_commit(commit_idx=-2)
 
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend.repo_name,
                        f_path='README'),
             params={
                 'diff1': commit2.raw_id,
                 'diff2': commit1.raw_id,
                 'fulldiff': '1',
                 'diff': diff,
             })
 
         if diff == 'diff':
             # use redirect since this is OLD view redirecting to compare page
             response = response.follow()
 
         # It's a symlink to README.rst
         response.mustcontain('README.rst')
         response.mustcontain('No newline at end of file')
 
     def test_file_binary_diff(self, backend):
         commits = [
             {'message': 'First commit'},
             {'message': 'Commit with binary',
              'added': [nodes.FileNode('file.bin', content='\0BINARY\0')]},
         ]
         repo = backend.create_repo(commits=commits)
 
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend.repo_name,
                        f_path='file.bin'),
             params={
                 'diff1': repo.get_commit(commit_idx=0).raw_id,
                 'diff2': repo.get_commit(commit_idx=1).raw_id,
                 'fulldiff': '1',
                 'diff': 'diff',
             })
         # use redirect since this is OLD view redirecting to compare page
         response = response.follow()
         response.mustcontain('Collapse 1 commit')
         file_changes = (1, 0, 0)
 
         compare_page = ComparePage(response)
         compare_page.contains_change_summary(*file_changes)
 
         if backend.alias == 'svn':
             response.mustcontain('new file 10644')
             # TODO(marcink): SVN doesn't yet detect binary changes
         else:
             response.mustcontain('new file 100644')
             response.mustcontain('binary diff hidden')
 
     def test_diff_2way(self, backend):
         commit1 = backend.repo.get_commit(commit_idx=-1)
         commit2 = backend.repo.get_commit(commit_idx=-2)
         response = self.app.get(
             route_path('repo_files_diff_2way_redirect',
                        repo_name=backend.repo_name,
                        f_path='README'),
             params={
                 'diff1': commit2.raw_id,
                 'diff2': commit1.raw_id,
             })
         # use redirect since this is OLD view redirecting to compare page
         response = response.follow()
 
         # It's a symlink to README.rst
         response.mustcontain('README.rst')
         response.mustcontain('No newline at end of file')
 
     def test_requires_one_commit_id(self, backend, autologin_user):
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend.repo_name,
                        f_path='README.rst'),
             status=400)
         response.mustcontain(
             'Need query parameter', 'diff1', 'diff2', 'to generate a diff.')
 
     def test_returns_no_files_if_file_does_not_exist(self, vcsbackend):
         repo = vcsbackend.repo
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=repo.name,
                        f_path='does-not-exist-in-any-commit'),
             params={
                 'diff1': repo[0].raw_id,
                 'diff2': repo[1].raw_id
             })
 
         response = response.follow()
         response.mustcontain('No files')
 
     def test_returns_redirect_if_file_not_changed(self, backend):
         commit = backend.repo.get_commit(commit_idx=-1)
         response = self.app.get(
             route_path('repo_files_diff_2way_redirect',
                        repo_name=backend.repo_name,
                        f_path='README'),
             params={
                 'diff1': commit.raw_id,
                 'diff2': commit.raw_id,
             })
 
         response = response.follow()
         response.mustcontain('No files')
         response.mustcontain('No commits in this compare')
 
     def test_supports_diff_to_different_path_svn(self, backend_svn):
         #TODO: check this case
         return
 
         repo = backend_svn['svn-simple-layout'].scm_instance()
         commit_id_1 = '24'
         commit_id_2 = '26'
 
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend_svn.repo_name,
                        f_path='trunk/example.py'),
             params={
                 'diff1': 'tags/v0.2/example.py@' + commit_id_1,
                 'diff2': commit_id_2,
             })
 
         response = response.follow()
         response.mustcontain(
             # diff contains this
             "Will print out a useful message on invocation.")
 
         # Note: Expecting that we indicate the user what's being compared
         response.mustcontain("trunk/example.py")
         response.mustcontain("tags/v0.2/example.py")
 
     def test_show_rev_redirects_to_svn_path(self, backend_svn):
         #TODO: check this case
         return
 
         repo = backend_svn['svn-simple-layout'].scm_instance()
         commit_id = repo[-1].raw_id
 
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend_svn.repo_name,
                        f_path='trunk/example.py'),
             params={
                 'diff1': 'branches/argparse/example.py@' + commit_id,
                 'diff2': commit_id,
             },
             status=302)
         response = response.follow()
         assert response.headers['Location'].endswith(
             'svn-svn-simple-layout/files/26/branches/argparse/example.py')
 
     def test_show_rev_and_annotate_redirects_to_svn_path(self, backend_svn):
         #TODO: check this case
         return
 
         repo = backend_svn['svn-simple-layout'].scm_instance()
         commit_id = repo[-1].raw_id
         response = self.app.get(
             route_path('repo_files_diff',
                        repo_name=backend_svn.repo_name,
                        f_path='trunk/example.py'),
             params={
                 'diff1': 'branches/argparse/example.py@' + commit_id,
                 'diff2': commit_id,
                 'show_rev': 'Show at Revision',
                 'annotate': 'true',
             },
             status=302)
         response = response.follow()
         assert response.headers['Location'].endswith(
             'svn-svn-simple-layout/annotate/26/branches/argparse/example.py')
 
 
 @pytest.mark.usefixtures("app", "autologin_user")
 class TestModifyFilesWithWebInterface(object):
 
     def test_add_file_view(self, backend):
         self.app.get(
             route_path('repo_files_add_file',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/')
             )
 
     @pytest.mark.xfail_backends("svn", reason="Depends on online editing")
     def test_add_file_into_repo_missing_content(self, backend, csrf_token):
         backend.create_repo()
         filename = 'init.py'
         response = self.app.post(
             route_path('repo_files_create_file',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path='/'),
             params={
                 'content': "",
                 'filename': filename,
                 'csrf_token': csrf_token,
             },
             status=302)
         expected_msg = 'Successfully committed new file `{}`'.format(os.path.join(filename))
         assert_session_flash(response, expected_msg)
 
     def test_add_file_into_repo_missing_filename(self, backend, csrf_token):
         commit_id = backend.repo.get_commit().raw_id
         response = self.app.post(
             route_path('repo_files_create_file',
                        repo_name=backend.repo_name,
                        commit_id=commit_id, f_path='/'),
             params={
                 'content': "foo",
                 'csrf_token': csrf_token,
             },
             status=302)
 
         assert_session_flash(response, 'No filename specified')
 
     def test_add_file_into_repo_errors_and_no_commits(
             self, backend, csrf_token):
         repo = backend.create_repo()
         # Create a file with no filename, it will display an error but
         # the repo has no commits yet
         response = self.app.post(
             route_path('repo_files_create_file',
                        repo_name=repo.repo_name,
                        commit_id='tip', f_path='/'),
             params={
                 'content': "foo",
                 'csrf_token': csrf_token,
             },
             status=302)
 
         assert_session_flash(response, 'No filename specified')
 
         # Not allowed, redirect to the summary
         redirected = response.follow()
         summary_url = h.route_path('repo_summary', repo_name=repo.repo_name)
 
         # As there are no commits, displays the summary page with the error of
         # creating a file with no filename
 
         assert redirected.request.path == summary_url
 
     @pytest.mark.parametrize("filename, clean_filename", [
         ('/abs/foo', 'abs/foo'),
         ('../rel/foo', 'rel/foo'),
         ('file/../foo/foo', 'file/foo/foo'),
     ])
     def test_add_file_into_repo_bad_filenames(self, filename, clean_filename, backend, csrf_token):
         repo = backend.create_repo()
         commit_id = repo.get_commit().raw_id
 
         response = self.app.post(
             route_path('repo_files_create_file',
                        repo_name=repo.repo_name,
                        commit_id=commit_id, f_path='/'),
             params={
                 'content': "foo",
                 'filename': filename,
                 'csrf_token': csrf_token,
             },
             status=302)
 
         expected_msg = 'Successfully committed new file `{}`'.format(clean_filename)
         assert_session_flash(response, expected_msg)
 
     @pytest.mark.parametrize("cnt, filename, content", [
         (1, 'foo.txt', "Content"),
         (2, 'dir/foo.rst', "Content"),
         (3, 'dir/foo-second.rst', "Content"),
         (4, 'rel/dir/foo.bar', "Content"),
     ])
     def test_add_file_into_empty_repo(self, cnt, filename, content, backend, csrf_token):
         repo = backend.create_repo()
         commit_id = repo.get_commit().raw_id
         response = self.app.post(
             route_path('repo_files_create_file',
                        repo_name=repo.repo_name,
                        commit_id=commit_id, f_path='/'),
             params={
                 'content': content,
                 'filename': filename,
                 'csrf_token': csrf_token,
             },
             status=302)
 
         expected_msg = 'Successfully committed new file `{}`'.format(filename)
         assert_session_flash(response, expected_msg)
 
     def test_edit_file_view(self, backend):
         response = self.app.get(
             route_path('repo_files_edit_file',
                        repo_name=backend.repo_name,
                        commit_id=backend.default_head_id,
                        f_path='vcs/nodes.py'),
             status=200)
         response.mustcontain("Module holding everything related to vcs nodes.")
 
     def test_edit_file_view_not_on_branch(self, backend):
         repo = backend.create_repo()
         backend.ensure_file("vcs/nodes.py")
 
         response = self.app.get(
             route_path('repo_files_edit_file',
                        repo_name=repo.repo_name,
                        commit_id='tip',
                        f_path='vcs/nodes.py'),
             status=302)
         assert_session_flash(
             response, 'Cannot modify file. Given commit `tip` is not head of a branch.')
 
     def test_edit_file_view_commit_changes(self, backend, csrf_token):
         repo = backend.create_repo()
         backend.ensure_file("vcs/nodes.py", content="print 'hello'")
 
         response = self.app.post(
             route_path('repo_files_update_file',
                        repo_name=repo.repo_name,
                        commit_id=backend.default_head_id,
                        f_path='vcs/nodes.py'),
             params={
                 'content': "print 'hello world'",
                 'message': 'I committed',
                 'filename': "vcs/nodes.py",
                 'csrf_token': csrf_token,
             },
             status=302)
         assert_session_flash(
             response, 'Successfully committed changes to file `vcs/nodes.py`')
         tip = repo.get_commit(commit_idx=-1)
         assert tip.message == 'I committed'
 
     def test_edit_file_view_commit_changes_default_message(self, backend,
                                                            csrf_token):
         repo = backend.create_repo()
         backend.ensure_file("vcs/nodes.py", content="print 'hello'")
 
         commit_id = (
             backend.default_branch_name or
             backend.repo.scm_instance().commit_ids[-1])
 
         response = self.app.post(
             route_path('repo_files_update_file',
                        repo_name=repo.repo_name,
                        commit_id=commit_id,
                        f_path='vcs/nodes.py'),
             params={
                 'content': "print 'hello world'",
                 'message': '',
                 'filename': "vcs/nodes.py",
                 'csrf_token': csrf_token,
             },
             status=302)
         assert_session_flash(
             response, 'Successfully committed changes to file `vcs/nodes.py`')
         tip = repo.get_commit(commit_idx=-1)
         assert tip.message == 'Edited file vcs/nodes.py via RhodeCode Enterprise'
 
     def test_delete_file_view(self, backend):
         self.app.get(
             route_path('repo_files_remove_file',
                        repo_name=backend.repo_name,
                        commit_id=backend.default_head_id,
                        f_path='vcs/nodes.py'),
             status=200)
 
     def test_delete_file_view_not_on_branch(self, backend):
         repo = backend.create_repo()
         backend.ensure_file('vcs/nodes.py')
 
         response = self.app.get(
             route_path('repo_files_remove_file',
                        repo_name=repo.repo_name,
                        commit_id='tip',
                        f_path='vcs/nodes.py'),
             status=302)
         assert_session_flash(
             response, 'Cannot modify file. Given commit `tip` is not head of a branch.')
 
     def test_delete_file_view_commit_changes(self, backend, csrf_token):
         repo = backend.create_repo()
         backend.ensure_file("vcs/nodes.py")
 
         response = self.app.post(
             route_path('repo_files_delete_file',
                        repo_name=repo.repo_name,
                        commit_id=backend.default_head_id,
                        f_path='vcs/nodes.py'),
             params={
                 'message': 'i commited',
                 'csrf_token': csrf_token,
             },
             status=302)
         assert_session_flash(
             response, 'Successfully deleted file `vcs/nodes.py`')
 
 
 @pytest.mark.usefixtures("app")
 class TestFilesViewOtherCases(object):
 
     def test_access_empty_repo_redirect_to_summary_with_alert_write_perms(
             self, backend_stub, autologin_regular_user, user_regular,
             user_util):
 
         repo = backend_stub.create_repo()
         user_util.grant_user_permission_to_repo(
             repo, user_regular, 'repository.write')
         response = self.app.get(
             route_path('repo_files',
                        repo_name=repo.repo_name,
                        commit_id='tip', f_path='/'))
 
         repo_file_add_url = route_path(
             'repo_files_add_file',
             repo_name=repo.repo_name,
             commit_id=0, f_path='')
 
         assert_session_flash(
             response,
             'There are no files yet. <a class="alert-link" '
             'href="{}">Click here to add a new file.</a>'
             .format(repo_file_add_url))
 
     def test_access_empty_repo_redirect_to_summary_with_alert_no_write_perms(
             self, backend_stub, autologin_regular_user):
         repo = backend_stub.create_repo()
         # init session for anon user
         route_path('repo_summary', repo_name=repo.repo_name)
 
         repo_file_add_url = route_path(
             'repo_files_add_file',
             repo_name=repo.repo_name,
             commit_id=0, f_path='')
 
         response = self.app.get(
             route_path('repo_files',
                        repo_name=repo.repo_name,
                        commit_id='tip', f_path='/'))
 
         assert_session_flash(response, no_=repo_file_add_url)
 
     @pytest.mark.parametrize('file_node', [
         'archive/file.zip',
         'diff/my-file.txt',
         'render.py',
         'render',
         'remove_file',
         'remove_file/to-delete.txt',
     ])
     def test_file_names_equal_to_routes_parts(self, backend, file_node):
         backend.create_repo()
         backend.ensure_file(file_node)
 
         self.app.get(
             route_path('repo_files',
                        repo_name=backend.repo_name,
                        commit_id='tip', f_path=file_node),
             status=200)
 
 
 class TestAdjustFilePathForSvn(object):
     """
     SVN specific adjustments of node history in RepoFilesView.
     """
 
     def test_returns_path_relative_to_matched_reference(self):
         repo = self._repo(branches=['trunk'])
         self.assert_file_adjustment('trunk/file', 'file', repo)
 
     def test_does_not_modify_file_if_no_reference_matches(self):
         repo = self._repo(branches=['trunk'])
         self.assert_file_adjustment('notes/file', 'notes/file', repo)
 
     def test_does_not_adjust_partial_directory_names(self):
         repo = self._repo(branches=['trun'])
         self.assert_file_adjustment('trunk/file', 'trunk/file', repo)
 
     def test_is_robust_to_patterns_which_prefix_other_patterns(self):
         repo = self._repo(branches=['trunk', 'trunk/new', 'trunk/old'])
         self.assert_file_adjustment('trunk/new/file', 'file', repo)
 
     def assert_file_adjustment(self, f_path, expected, repo):
         result = RepoFilesView.adjust_file_path_for_svn(f_path, repo)
         assert result == expected
 
     def _repo(self, branches=None):
         repo = mock.Mock()
         repo.branches = OrderedDict((name, '0') for name in branches or [])
         repo.tags = {}
         return repo

rhodecode/apps/repository/views/repo_files.py

@@ -1,1603 +1,1603 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2020 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_commit_id = self.db_repo.landing_ref_name
         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, 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, _name_hash, _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, _at_rev)
 
         return compute_file_tree(
             rc_cache.FILE_TREE_CACHE_VER, self.db_repo.repo_name_hash,
             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)
 
         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, 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, 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(_name_hash, _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_name_hash, 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 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': 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_check_head', request_method='POST',
         renderer='json_ext', xhr=True)
     def repo_files_check_head(self):
         self.load_default_context()
 
         commit_id, f_path = self._get_commit_and_path()
         _branch_name, _sha_commit_id, is_head = \
             self._is_valid_head(commit_id, self.rhodecode_vcs_repo)
 
         new_path = self.request.POST.get('path')
         operation = self.request.POST.get('operation')
         path_exist = ''
 
         if new_path and operation in ['create', 'upload']:
             new_f_path = os.path.join(f_path.lstrip('/'), new_path)
             try:
                 commit_obj = self.rhodecode_vcs_repo.get_commit(commit_id)
                 # NOTE(dan): construct whole path without leading /
                 file_node = commit_obj.get_node(new_f_path)
                 if file_node is not None:
                     path_exist = new_f_path
             except EmptyRepositoryError:
                 pass
             except Exception:
                 pass
 
         return {
             'branch': _branch_name,
             'sha': _sha_commit_id,
             'is_head': is_head,
             'path_exists': path_exist
         }
 
     @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/apps/repository/views/repo_forks.py

@@ -1,266 +1,266 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 import datetime
 import formencode
 import formencode.htmlfill
 
 from pyramid.httpexceptions import HTTPFound
 from pyramid.view import view_config
 from pyramid.renderers import render
 from pyramid.response import Response
 
 from rhodecode import events
 from rhodecode.apps._base import RepoAppView, DataGridAppView
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator, NotAnonymous,
     HasRepoPermissionAny, HasPermissionAnyDecorator, CSRFRequired)
 import rhodecode.lib.helpers as h
 from rhodecode.lib.celerylib.utils import get_task_id
 from rhodecode.model.db import coalesce, or_, Repository, RepoGroup
 from rhodecode.model.permission import PermissionModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.forms import RepoForkForm
 from rhodecode.model.scm import ScmModel, RepoGroupList
 from rhodecode.lib.utils2 import safe_int, safe_unicode
 
 log = logging.getLogger(__name__)
 
 
 class RepoForksView(RepoAppView, DataGridAppView):
 
     def load_default_context(self):
         c = self._get_local_tmpl_context(include_app_defaults=True)
         c.rhodecode_repo = self.rhodecode_vcs_repo
 
         acl_groups = RepoGroupList(
             RepoGroup.query().all(),
             perm_set=['group.write', 'group.admin'])
         c.repo_groups = RepoGroup.groups_choices(groups=acl_groups)
         c.repo_groups_choices = map(lambda k: safe_unicode(k[0]), c.repo_groups)
 
         c.personal_repo_group = c.rhodecode_user.personal_repo_group
 
         return c
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_forks_show_all', request_method='GET',
         renderer='rhodecode:templates/forks/forks.mako')
     def repo_forks_show_all(self):
         c = self.load_default_context()
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_forks_data', request_method='GET',
         renderer='json_ext', xhr=True)
     def repo_forks_data(self):
         _ = self.request.translate
         self.load_default_context()
         column_map = {
             'fork_name': 'repo_name',
             'fork_date': 'created_on',
             'last_activity': 'updated_on'
         }
         draw, start, limit = self._extract_chunk(self.request)
         search_q, order_by, order_dir = self._extract_ordering(
             self.request, column_map=column_map)
 
         acl_check = HasRepoPermissionAny(
             'repository.read', 'repository.write', 'repository.admin')
         repo_id = self.db_repo.repo_id
         allowed_ids = [-1]
         for f in Repository.query().filter(Repository.fork_id == repo_id):
             if acl_check(f.repo_name, 'get forks check'):
                 allowed_ids.append(f.repo_id)
 
         forks_data_total_count = Repository.query()\
             .filter(Repository.fork_id == repo_id)\
             .filter(Repository.repo_id.in_(allowed_ids))\
             .count()
 
         # json generate
         base_q = Repository.query()\
             .filter(Repository.fork_id == repo_id)\
             .filter(Repository.repo_id.in_(allowed_ids))\
 
         if search_q:
             like_expression = u'%{}%'.format(safe_unicode(search_q))
             base_q = base_q.filter(or_(
                 Repository.repo_name.ilike(like_expression),
                 Repository.description.ilike(like_expression),
             ))
 
         forks_data_total_filtered_count = base_q.count()
 
         sort_col = getattr(Repository, order_by, None)
         if sort_col:
             if order_dir == 'asc':
                 # handle null values properly to order by NULL last
                 if order_by in ['last_activity']:
                     sort_col = coalesce(sort_col, datetime.date.max)
                 sort_col = sort_col.asc()
             else:
                 # handle null values properly to order by NULL last
                 if order_by in ['last_activity']:
                     sort_col = coalesce(sort_col, datetime.date.min)
                 sort_col = sort_col.desc()
 
         base_q = base_q.order_by(sort_col)
         base_q = base_q.offset(start).limit(limit)
 
         fork_list = base_q.all()
 
         def fork_actions(fork):
             url_link = h.route_path(
                 'repo_compare',
                 repo_name=fork.repo_name,
-                source_ref_type=self.db_repo.landing_rev[0],
-                source_ref=self.db_repo.landing_rev[1],
-                target_ref_type=self.db_repo.landing_rev[0],
-                target_ref=self.db_repo.landing_rev[1],
+                source_ref_type=self.db_repo.landing_ref_type,
+                source_ref=self.db_repo.landing_ref_name,
+                target_ref_type=self.db_repo.landing_ref_type,
+                target_ref=self.db_repo.landing_ref_name,
                 _query=dict(merge=1, target_repo=f.repo_name))
             return h.link_to(_('Compare fork'), url_link, class_='btn-link')
 
         def fork_name(fork):
             return h.link_to(fork.repo_name,
                       h.route_path('repo_summary', repo_name=fork.repo_name))
 
         forks_data = []
         for fork in fork_list:
             forks_data.append({
                 "username": h.gravatar_with_user(self.request, fork.user.username),
                 "fork_name": fork_name(fork),
                 "description": fork.description_safe,
                 "fork_date": h.age_component(fork.created_on, time_is_local=True),
                 "last_activity": h.format_date(fork.updated_on),
                 "action": fork_actions(fork),
             })
 
         data = ({
             'draw': draw,
             'data': forks_data,
             'recordsTotal': forks_data_total_count,
             'recordsFiltered': forks_data_total_filtered_count,
         })
 
         return data
 
     @LoginRequired()
     @NotAnonymous()
     @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_fork_new', request_method='GET',
         renderer='rhodecode:templates/forks/forks.mako')
     def repo_fork_new(self):
         c = self.load_default_context()
 
         defaults = RepoModel()._get_defaults(self.db_repo_name)
         # alter the description to indicate a fork
         defaults['description'] = (
             'fork of repository: %s \n%s' % (
                 defaults['repo_name'], defaults['description']))
         # add suffix to fork
         defaults['repo_name'] = '%s-fork' % defaults['repo_name']
 
         data = render('rhodecode:templates/forks/fork.mako',
                       self._get_template_context(c), self.request)
         html = formencode.htmlfill.render(
             data,
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )
         return Response(html)
 
     @LoginRequired()
     @NotAnonymous()
     @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='repo_fork_create', request_method='POST',
         renderer='rhodecode:templates/forks/fork.mako')
     def repo_fork_create(self):
         _ = self.request.translate
         c = self.load_default_context()
 
         _form = RepoForkForm(self.request.translate,
                              old_data={'repo_type': self.db_repo.repo_type},
                              repo_groups=c.repo_groups_choices)()
         post_data = dict(self.request.POST)
 
         # forbid injecting other repo by forging a request
         post_data['fork_parent_id'] = self.db_repo.repo_id
         post_data['landing_rev'] = self.db_repo._landing_revision
 
         form_result = {}
         task_id = None
         try:
             form_result = _form.to_python(post_data)
             copy_permissions = form_result.get('copy_permissions')
             # create fork is done sometimes async on celery, db transaction
             # management is handled there.
             task = RepoModel().create_fork(
                 form_result, c.rhodecode_user.user_id)
 
             task_id = get_task_id(task)
         except formencode.Invalid as errors:
             c.rhodecode_db_repo = self.db_repo
 
             data = render('rhodecode:templates/forks/fork.mako',
                           self._get_template_context(c), self.request)
             html = formencode.htmlfill.render(
                 data,
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8",
                 force_defaults=False
             )
             return Response(html)
         except Exception:
             log.exception(
                 u'Exception while trying to fork the repository %s', self.db_repo_name)
             msg = _('An error occurred during repository forking %s') % (self.db_repo_name, )
             h.flash(msg, category='error')
             raise HTTPFound(h.route_path('home'))
 
         repo_name = form_result.get('repo_name_full', self.db_repo_name)
 
         affected_user_ids = [self._rhodecode_user.user_id]
         if copy_permissions:
             # permission flush is done in repo creating
             pass
 
         PermissionModel().trigger_permission_flush(affected_user_ids)
 
         raise HTTPFound(
             h.route_path('repo_creating', repo_name=repo_name,
                          _query=dict(task_id=task_id)))

rhodecode/templates/base/base.mako

@@ -1,1201 +1,1201 b''
 ## -*- coding: utf-8 -*-
 
 <%!
     ## base64 filter e.g ${ example | base64 }
     def base64(text):
         import base64
         from rhodecode.lib.helpers import safe_str
         return base64.encodestring(safe_str(text))
 %>
 
 <%inherit file="root.mako"/>
 
 <%include file="/ejs_templates/templates.html"/>
 
 <div class="outerwrapper">
   <!-- HEADER -->
   <div class="header">
       <div id="header-inner" class="wrapper">
           <div id="logo">
               <div class="logo-wrapper">
                   <a href="${h.route_path('home')}"><img src="${h.asset('images/rhodecode-logo-white-60x60.png')}" alt="RhodeCode"/></a>
               </div>
               % if c.rhodecode_name:
                <div class="branding">
                    <a href="${h.route_path('home')}">${h.branding(c.rhodecode_name)}</a>
                </div>
               % endif
           </div>
           <!-- MENU BAR NAV -->
           ${self.menu_bar_nav()}
           <!-- END MENU BAR NAV -->
       </div>
   </div>
   ${self.menu_bar_subnav()}
   <!-- END HEADER -->
 
   <!-- CONTENT -->
   <div id="content" class="wrapper">
 
       <rhodecode-toast id="notifications"></rhodecode-toast>
 
       <div class="main">
           ${next.main()}
       </div>
   </div>
   <!-- END CONTENT -->
 
 </div>
 <!-- FOOTER -->
 <div id="footer">
    <div id="footer-inner" class="title wrapper">
        <div>
            <p class="footer-link-right">
                % if c.visual.show_version:
                    RhodeCode Enterprise ${c.rhodecode_version} ${c.rhodecode_edition}
                % endif
                &copy; 2010-${h.datetime.today().year}, <a href="${h.route_url('rhodecode_official')}" target="_blank">RhodeCode GmbH</a>. All rights reserved.
                % if c.visual.rhodecode_support_url:
                   <a href="${c.visual.rhodecode_support_url}" target="_blank">${_('Support')}</a>
                % endif
            </p>
            <% sid = 'block' if request.GET.get('showrcid') else 'none' %>
            <p class="server-instance" style="display:${sid}">
                ## display hidden instance ID if specially defined
                % if c.rhodecode_instanceid:
                    ${_('RhodeCode instance id: {}').format(c.rhodecode_instanceid)}
                % endif
            </p>
        </div>
    </div>
 </div>
 
 <!-- END FOOTER -->
 
 ### MAKO DEFS ###
 
 <%def name="menu_bar_subnav()">
 </%def>
 
 <%def name="breadcrumbs(class_='breadcrumbs')">
     <div class="${class_}">
     ${self.breadcrumbs_links()}
     </div>
 </%def>
 
 <%def name="admin_menu(active=None)">
 
   <div id="context-bar">
     <div class="wrapper">
       <div class="title">
         <div class="title-content">
           <div class="title-main">
             % if c.is_super_admin:
                 ${_('Super-admin Panel')}
             % else:
                 ${_('Delegated Admin Panel')}
             % endif
           </div>
         </div>
       </div>
 
     <ul id="context-pages" class="navigation horizontal-list">
 
         ## super-admin case
         % if c.is_super_admin:
           <li class="${h.is_active('audit_logs', active)}"><a href="${h.route_path('admin_audit_logs')}">${_('Admin audit logs')}</a></li>
           <li class="${h.is_active('repositories', active)}"><a href="${h.route_path('repos')}">${_('Repositories')}</a></li>
           <li class="${h.is_active('repository_groups', active)}"><a href="${h.route_path('repo_groups')}">${_('Repository groups')}</a></li>
           <li class="${h.is_active('users', active)}"><a href="${h.route_path('users')}">${_('Users')}</a></li>
           <li class="${h.is_active('user_groups', active)}"><a href="${h.route_path('user_groups')}">${_('User groups')}</a></li>
           <li class="${h.is_active('permissions', active)}"><a href="${h.route_path('admin_permissions_application')}">${_('Permissions')}</a></li>
           <li class="${h.is_active('authentication', active)}"><a href="${h.route_path('auth_home', traverse='')}">${_('Authentication')}</a></li>
           <li class="${h.is_active('integrations', active)}"><a href="${h.route_path('global_integrations_home')}">${_('Integrations')}</a></li>
           <li class="${h.is_active('defaults', active)}"><a href="${h.route_path('admin_defaults_repositories')}">${_('Defaults')}</a></li>
           <li class="${h.is_active('settings', active)}"><a href="${h.route_path('admin_settings')}">${_('Settings')}</a></li>
 
         ## delegated admin
         % elif c.is_delegated_admin:
            <%
            repositories=c.auth_user.repositories_admin or c.can_create_repo
            repository_groups=c.auth_user.repository_groups_admin or c.can_create_repo_group
            user_groups=c.auth_user.user_groups_admin or c.can_create_user_group
            %>
 
            %if repositories:
               <li class="${h.is_active('repositories', active)} local-admin-repos"><a href="${h.route_path('repos')}">${_('Repositories')}</a></li>
            %endif
            %if repository_groups:
               <li class="${h.is_active('repository_groups', active)} local-admin-repo-groups"><a href="${h.route_path('repo_groups')}">${_('Repository groups')}</a></li>
            %endif
            %if user_groups:
               <li class="${h.is_active('user_groups', active)} local-admin-user-groups"><a href="${h.route_path('user_groups')}">${_('User groups')}</a></li>
            %endif
         % endif
     </ul>
 
     </div>
     <div class="clear"></div>
   </div>
 </%def>
 
 <%def name="dt_info_panel(elements)">
     <dl class="dl-horizontal">
     %for dt, dd, title, show_items in elements:
       <dt>${dt}:</dt>
       <dd title="${h.tooltip(title)}">
       %if callable(dd):
           ## allow lazy evaluation of elements
           ${dd()}
       %else:
           ${dd}
       %endif
       %if show_items:
           <span class="btn-collapse" data-toggle="item-${h.md5_safe(dt)[:6]}-details">${_('Show More')} </span>
       %endif
       </dd>
 
       %if show_items:
           <div class="collapsable-content" data-toggle="item-${h.md5_safe(dt)[:6]}-details" style="display: none">
           %for item in show_items:
               <dt></dt>
               <dd>${item}</dd>
           %endfor
           </div>
       %endif
 
     %endfor
     </dl>
 </%def>
 
 <%def name="tr_info_entry(element)">
     <% key, val, title, show_items = element %>
 
     <tr>
         <td style="vertical-align: top">${key}</td>
         <td title="${h.tooltip(title)}">
           %if callable(val):
               ## allow lazy evaluation of elements
               ${val()}
           %else:
               ${val}
           %endif
           %if show_items:
               <div class="collapsable-content" data-toggle="item-${h.md5_safe(val)[:6]}-details" style="display: none">
               % for item in show_items:
                   <dt></dt>
                   <dd>${item}</dd>
               % endfor
               </div>
           %endif
         </td>
         <td style="vertical-align: top">
           %if show_items:
               <span class="btn-collapse" data-toggle="item-${h.md5_safe(val)[:6]}-details">${_('Show More')} </span>
           %endif
         </td>
     </tr>
 
 </%def>
 
 <%def name="gravatar(email, size=16, tooltip=False, tooltip_alt=None, user=None, extra_class=None)">
   <%
     if size > 16:
         gravatar_class = ['gravatar','gravatar-large']
     else:
         gravatar_class = ['gravatar']
 
     data_hovercard_url = ''
     data_hovercard_alt = tooltip_alt.replace('<', '&lt;').replace('>', '&gt;') if tooltip_alt else ''
 
     if tooltip:
         gravatar_class += ['tooltip-hovercard']
     if extra_class:
         gravatar_class += extra_class
     if tooltip and user:
         if user.username == h.DEFAULT_USER:
             gravatar_class.pop(-1)
         else:
             data_hovercard_url = request.route_path('hovercard_user', user_id=getattr(user, 'user_id', ''))
     gravatar_class = ' '.join(gravatar_class)
 
   %>
   <%doc>
     TODO: johbo: For now we serve double size images to make it smooth
     for retina. This is how it worked until now. Should be replaced
     with a better solution at some point.
   </%doc>
 
   <img class="${gravatar_class}" height="${size}" width="${size}" data-hovercard-url="${data_hovercard_url}" data-hovercard-alt="${data_hovercard_alt}" src="${h.gravatar_url(email, size * 2)}" />
 </%def>
 
 
 <%def name="gravatar_with_user(contact, size=16, show_disabled=False, tooltip=False, _class='rc-user')">
   <%
       email = h.email_or_none(contact)
       rc_user = h.discover_user(contact)
   %>
 
   <div class="${_class}">
     ${self.gravatar(email, size, tooltip=tooltip, tooltip_alt=contact, user=rc_user)}
     <span class="${('user user-disabled' if show_disabled else 'user')}"> ${h.link_to_user(rc_user or contact)}</span>
   </div>
 </%def>
 
 
 <%def name="user_group_icon(user_group=None, size=16, tooltip=False)">
   <%
     if (size > 16):
         gravatar_class = 'icon-user-group-alt'
     else:
         gravatar_class = 'icon-user-group-alt'
 
     if tooltip:
         gravatar_class += ' tooltip-hovercard'
 
     data_hovercard_url = request.route_path('hovercard_user_group', user_group_id=user_group.users_group_id)
   %>
   <%doc>
     TODO: johbo: For now we serve double size images to make it smooth
     for retina. This is how it worked until now. Should be replaced
     with a better solution at some point.
   </%doc>
 
   <i style="font-size: ${size}px" class="${gravatar_class} x-icon-size-${size}" data-hovercard-url="${data_hovercard_url}"></i>
 </%def>
 
 <%def name="repo_page_title(repo_instance)">
 <div class="title-content repo-title">
 
     <div class="title-main">
         ## SVN/HG/GIT icons
         %if h.is_hg(repo_instance):
             <i class="icon-hg"></i>
         %endif
         %if h.is_git(repo_instance):
             <i class="icon-git"></i>
         %endif
         %if h.is_svn(repo_instance):
             <i class="icon-svn"></i>
         %endif
 
         ## public/private
         %if repo_instance.private:
             <i class="icon-repo-private"></i>
         %else:
             <i class="icon-repo-public"></i>
         %endif
 
         ## repo name with group name
         ${h.breadcrumb_repo_link(repo_instance)}
 
         ## Context Actions
         <div class="pull-right">
             %if c.rhodecode_user.username != h.DEFAULT_USER:
                 <a href="${h.route_path('atom_feed_home', repo_name=c.rhodecode_db_repo.repo_uid, _query=dict(auth_token=c.rhodecode_user.feed_token))}" title="${_('RSS Feed')}" class="btn btn-sm"><i class="icon-rss-sign"></i>RSS</a>
 
                 <a href="#WatchRepo" onclick="toggleFollowingRepo(this, templateContext.repo_id); return false" title="${_('Watch this Repository and actions on it in your personalized journal')}" class="btn btn-sm ${('watching' if c.repository_is_user_following else '')}">
                     % if c.repository_is_user_following:
                         <i class="icon-eye-off"></i>${_('Unwatch')}
                     % else:
                         <i class="icon-eye"></i>${_('Watch')}
                     % endif
 
                 </a>
             %else:
                 <a href="${h.route_path('atom_feed_home', repo_name=c.rhodecode_db_repo.repo_uid)}" title="${_('RSS Feed')}" class="btn btn-sm"><i class="icon-rss-sign"></i>RSS</a>
             %endif
         </div>
 
     </div>
 
     ## FORKED
     %if repo_instance.fork:
     <p class="discreet">
         <i class="icon-code-fork"></i> ${_('Fork of')}
         ${h.link_to_if(c.has_origin_repo_read_perm,repo_instance.fork.repo_name, h.route_path('repo_summary', repo_name=repo_instance.fork.repo_name))}
     </p>
     %endif
 
     ## IMPORTED FROM REMOTE
     %if repo_instance.clone_uri:
     <p class="discreet">
        <i class="icon-code-fork"></i> ${_('Clone from')}
        <a href="${h.safe_str(h.hide_credentials(repo_instance.clone_uri))}">${h.hide_credentials(repo_instance.clone_uri)}</a>
     </p>
     %endif
 
     ## LOCKING STATUS
      %if repo_instance.locked[0]:
        <p class="locking_locked discreet">
            <i class="icon-repo-lock"></i>
            ${_('Repository locked by %(user)s') % {'user': h.person_by_id(repo_instance.locked[0])}}
        </p>
      %elif repo_instance.enable_locking:
          <p class="locking_unlocked discreet">
              <i class="icon-repo-unlock"></i>
              ${_('Repository not locked. Pull repository to lock it.')}
          </p>
      %endif
 
 </div>
 </%def>
 
 <%def name="repo_menu(active=None)">
     <%
     ## determine if we have "any" option available
     can_lock = h.HasRepoPermissionAny('repository.write','repository.admin')(c.repo_name) and c.rhodecode_db_repo.enable_locking
     has_actions = can_lock
 
     %>
     % if c.rhodecode_db_repo.archived:
     <div class="alert alert-warning text-center">
         <strong>${_('This repository has been archived. It is now read-only.')}</strong>
     </div>
     % endif
 
   <!--- REPO CONTEXT BAR -->
   <div id="context-bar">
     <div class="wrapper">
 
       <div class="title">
           ${self.repo_page_title(c.rhodecode_db_repo)}
       </div>
 
       <ul id="context-pages" class="navigation horizontal-list">
         <li class="${h.is_active('summary', active)}"><a class="menulink" href="${h.route_path('repo_summary', repo_name=c.repo_name)}"><div class="menulabel">${_('Summary')}</div></a></li>
         <li class="${h.is_active('commits', active)}"><a class="menulink" href="${h.route_path('repo_commits', repo_name=c.repo_name)}"><div class="menulabel">${_('Commits')}</div></a></li>
-        <li class="${h.is_active('files', active)}"><a class="menulink" href="${h.route_path('repo_files', repo_name=c.repo_name, commit_id=c.rhodecode_db_repo.landing_rev[1], f_path='')}"><div class="menulabel">${_('Files')}</div></a></li>
+        <li class="${h.is_active('files', active)}"><a class="menulink" href="${h.route_path('repo_files', repo_name=c.repo_name, commit_id=c.rhodecode_db_repo.landing_ref_name, f_path='')}"><div class="menulabel">${_('Files')}</div></a></li>
         <li class="${h.is_active('compare', active)}"><a class="menulink" href="${h.route_path('repo_compare_select',repo_name=c.repo_name)}"><div class="menulabel">${_('Compare')}</div></a></li>
 
         ## TODO: anderson: ideally it would have a function on the scm_instance "enable_pullrequest() and enable_fork()"
         %if c.rhodecode_db_repo.repo_type in ['git','hg']:
           <li class="${h.is_active('showpullrequest', active)}">
             <a class="menulink" href="${h.route_path('pullrequest_show_all', repo_name=c.repo_name)}" title="${h.tooltip(_('Show Pull Requests for %s') % c.repo_name)}">
               <div class="menulabel">
                   ${_('Pull Requests')} <span class="menulink-counter">${c.repository_pull_requests}</span>
               </div>
             </a>
           </li>
         %endif
 
         <li class="${h.is_active('artifacts', active)}">
             <a class="menulink" href="${h.route_path('repo_artifacts_list',repo_name=c.repo_name)}">
                 <div class="menulabel">
                     ${_('Artifacts')}  <span class="menulink-counter">${c.repository_artifacts}</span>
                 </div>
             </a>
         </li>
 
         %if h.HasRepoPermissionAll('repository.admin')(c.repo_name):
             <li class="${h.is_active('settings', active)}"><a class="menulink" href="${h.route_path('edit_repo',repo_name=c.repo_name)}"><div class="menulabel">${_('Repository Settings')}</div></a></li>
         %endif
 
         <li class="${h.is_active('options', active)}">
           % if has_actions:
             <a class="menulink dropdown">
               <div class="menulabel">${_('Options')}<div class="show_more"></div></div>
             </a>
             <ul class="submenu">
                 %if can_lock:
                     %if c.rhodecode_db_repo.locked[0]:
                       <li><a class="locking_del" href="${h.route_path('repo_edit_toggle_locking',repo_name=c.repo_name)}">${_('Unlock Repository')}</a></li>
                     %else:
                       <li><a class="locking_add" href="${h.route_path('repo_edit_toggle_locking',repo_name=c.repo_name)}">${_('Lock Repository')}</a></li>
                     %endif
                 %endif
             </ul>
           % endif
         </li>
 
       </ul>
     </div>
     <div class="clear"></div>
   </div>
 
   <!--- REPO END CONTEXT BAR -->
 
 </%def>
 
 <%def name="repo_group_page_title(repo_group_instance)">
 <div class="title-content">
     <div class="title-main">
         ## Repository Group icon
         <i class="icon-repo-group"></i>
 
         ## repo name with group name
         ${h.breadcrumb_repo_group_link(repo_group_instance)}
     </div>
 
     <%namespace name="dt" file="/data_table/_dt_elements.mako"/>
     <div class="repo-group-desc discreet">
     ${dt.repo_group_desc(repo_group_instance.description_safe, repo_group_instance.personal, c.visual.stylify_metatags)}
     </div>
 
 </div>
 </%def>
 
 
 <%def name="repo_group_menu(active=None)">
     <%
     gr_name = c.repo_group.group_name if c.repo_group else None
     # create repositories with write permission on group is set to true
     group_admin = h.HasRepoGroupPermissionAny('group.admin')(gr_name, 'group admin index page')
 
     %>
 
 
   <!--- REPO GROUP CONTEXT BAR -->
   <div id="context-bar">
     <div class="wrapper">
       <div class="title">
           ${self.repo_group_page_title(c.repo_group)}
       </div>
 
       <ul id="context-pages" class="navigation horizontal-list">
         <li class="${h.is_active('home', active)}">
             <a class="menulink" href="${h.route_path('repo_group_home', repo_group_name=c.repo_group.group_name)}"><div class="menulabel">${_('Group Home')}</div></a>
         </li>
         % if c.is_super_admin or group_admin:
             <li class="${h.is_active('settings', active)}">
                 <a class="menulink" href="${h.route_path('edit_repo_group',repo_group_name=c.repo_group.group_name)}" title="${_('You have admin right to this group, and can edit it')}"><div class="menulabel">${_('Group Settings')}</div></a>
             </li>
         % endif
 
       </ul>
     </div>
     <div class="clear"></div>
   </div>
 
   <!--- REPO GROUP CONTEXT BAR -->
 
 </%def>
 
 
 <%def name="usermenu(active=False)">
     <%
     not_anonymous = c.rhodecode_user.username != h.DEFAULT_USER
 
     gr_name = c.repo_group.group_name if (hasattr(c, 'repo_group') and c.repo_group) else None
     # create repositories with write permission on group is set to true
 
     can_fork = c.is_super_admin or h.HasPermissionAny('hg.fork.repository')()
     create_on_write = h.HasPermissionAny('hg.create.write_on_repogroup.true')()
     group_write = h.HasRepoGroupPermissionAny('group.write')(gr_name, 'can write into group index page')
     group_admin = h.HasRepoGroupPermissionAny('group.admin')(gr_name, 'group admin index page')
 
     can_create_repos = c.is_super_admin or c.can_create_repo
     can_create_repo_groups = c.is_super_admin or c.can_create_repo_group
 
     can_create_repos_in_group = c.is_super_admin or group_admin or (group_write and create_on_write)
     can_create_repo_groups_in_group = c.is_super_admin or group_admin
     %>
 
     % if not_anonymous:
     <%
     default_target_group = dict()
     if c.rhodecode_user.personal_repo_group:
         default_target_group = dict(parent_group=c.rhodecode_user.personal_repo_group.group_id)
     %>
 
     ## create action
     <li>
        <a href="#create-actions" onclick="return false;" class="menulink childs">
         <i class="tooltip icon-plus-circled" title="${_('Create')}"></i>
        </a>
 
        <div class="action-menu submenu">
 
         <ol>
             ## scope of within a repository
             % if hasattr(c, 'rhodecode_db_repo') and c.rhodecode_db_repo:
                 <li class="submenu-title">${_('This Repository')}</li>
                 <li>
                     <a href="${h.route_path('pullrequest_new',repo_name=c.repo_name)}">${_('Create Pull Request')}</a>
                 </li>
                 % if can_fork:
                 <li>
                     <a href="${h.route_path('repo_fork_new',repo_name=c.repo_name,_query=default_target_group)}">${_('Fork this repository')}</a>
                 </li>
                 % endif
             % endif
 
             ## scope of within repository groups
             % if hasattr(c, 'repo_group') and c.repo_group and (can_create_repos_in_group or can_create_repo_groups_in_group):
                 <li class="submenu-title">${_('This Repository Group')}</li>
 
                 % if can_create_repos_in_group:
                     <li>
                     <a href="${h.route_path('repo_new',_query=dict(parent_group=c.repo_group.group_id))}">${_('New Repository')}</a>
                     </li>
                 % endif
 
                 % if can_create_repo_groups_in_group:
                     <li>
                         <a href="${h.route_path('repo_group_new',_query=dict(parent_group=c.repo_group.group_id))}">${_(u'New Repository Group')}</a>
                     </li>
                 % endif
             % endif
 
             ## personal group
             % if c.rhodecode_user.personal_repo_group:
                 <li class="submenu-title">Personal Group</li>
 
                 <li>
                 <a href="${h.route_path('repo_new',_query=dict(parent_group=c.rhodecode_user.personal_repo_group.group_id))}" >${_('New Repository')} </a>
                 </li>
 
                 <li>
                 <a href="${h.route_path('repo_group_new',_query=dict(parent_group=c.rhodecode_user.personal_repo_group.group_id))}">${_('New Repository Group')} </a>
                 </li>
             % endif
 
             ## Global actions
             <li class="submenu-title">RhodeCode</li>
             % if can_create_repos:
                 <li>
                 <a href="${h.route_path('repo_new')}" >${_('New Repository')}</a>
                 </li>
             % endif
 
             % if can_create_repo_groups:
                 <li>
                 <a href="${h.route_path('repo_group_new')}" >${_(u'New Repository Group')}</a>
                 </li>
             % endif
 
             <li>
                 <a href="${h.route_path('gists_new')}">${_(u'New Gist')}</a>
             </li>
 
         </ol>
 
        </div>
     </li>
 
     ## notifications
     <li>
        <a class="${('empty' if c.unread_notifications == 0 else '')}" href="${h.route_path('notifications_show_all')}">
            ${c.unread_notifications}
        </a>
     </li>
    % endif
 
     ## USER MENU
     <li id="quick_login_li" class="${'active' if active else ''}">
         % if c.rhodecode_user.username == h.DEFAULT_USER:
           <a id="quick_login_link" class="menulink childs" href="${h.route_path('login', _query={'came_from': h.current_route_path(request)})}">
             ${gravatar(c.rhodecode_user.email, 20)}
             <span class="user">
                 <span>${_('Sign in')}</span>
             </span>
           </a>
         % else:
           ## logged in user
           <a id="quick_login_link" class="menulink childs">
             ${gravatar(c.rhodecode_user.email, 20)}
             <span class="user">
                 <span class="menu_link_user">${c.rhodecode_user.username}</span>
                 <div class="show_more"></div>
             </span>
           </a>
           ## subnav with menu for logged in user
           <div class="user-menu submenu">
               <div id="quick_login">
                 %if c.rhodecode_user.username != h.DEFAULT_USER:
                     <div class="">
                         <div class="big_gravatar">${gravatar(c.rhodecode_user.email, 48)}</div>
                         <div class="full_name">${c.rhodecode_user.full_name_or_username}</div>
                         <div class="email">${c.rhodecode_user.email}</div>
                     </div>
                     <div class="">
                     <ol class="links">
                       <li>${h.link_to(_(u'My account'),h.route_path('my_account_profile'))}</li>
                       % if c.rhodecode_user.personal_repo_group:
                       <li>${h.link_to(_(u'My personal group'), h.route_path('repo_group_home', repo_group_name=c.rhodecode_user.personal_repo_group.group_name))}</li>
                       % endif
                       <li>${h.link_to(_(u'Pull Requests'), h.route_path('my_account_pullrequests'))}</li>
 
                       % if c.debug_style:
                       <li>
                           <a class="menulink" title="${_('Style')}" href="${h.route_path('debug_style_home')}">
                             <div class="menulabel">${_('[Style]')}</div>
                           </a>
                       </li>
                       % endif
 
                       ## bookmark-items
                       <li class="bookmark-items">
                           ${_('Bookmarks')}
                           <div class="pull-right">
                               <a href="${h.route_path('my_account_bookmarks')}">
 
                                   <i class="icon-cog"></i>
                               </a>
                           </div>
                       </li>
                       % if not c.bookmark_items:
                           <li>
                               <a href="${h.route_path('my_account_bookmarks')}">${_('No Bookmarks yet.')}</a>
                           </li>
                       % endif
                       % for item in c.bookmark_items:
                       <li>
                           % if item.repository:
                               <div>
                                 <a class="bookmark-item" href="${h.route_path('my_account_goto_bookmark', bookmark_id=item.position)}">
                                 <code>${item.position}</code>
                                 % if item.repository.repo_type == 'hg':
                                     <i class="icon-hg" title="${_('Repository')}" style="font-size: 16px"></i>
                                 % elif item.repository.repo_type == 'git':
                                     <i class="icon-git" title="${_('Repository')}" style="font-size: 16px"></i>
                                 % elif item.repository.repo_type == 'svn':
                                     <i class="icon-svn" title="${_('Repository')}" style="font-size: 16px"></i>
                                 % endif
                                 ${(item.title or h.shorter(item.repository.repo_name, 30))}
                               </a>
                               </div>
                           % elif item.repository_group:
                               <div>
                                 <a class="bookmark-item" href="${h.route_path('my_account_goto_bookmark', bookmark_id=item.position)}">
                                 <code>${item.position}</code>
                                 <i class="icon-repo-group" title="${_('Repository group')}" style="font-size: 14px"></i>
                                 ${(item.title or h.shorter(item.repository_group.group_name, 30))}
                               </a>
                               </div>
                           % else:
                               <a class="bookmark-item" href="${h.route_path('my_account_goto_bookmark', bookmark_id=item.position)}">
                                 <code>${item.position}</code>
                                 ${item.title}
                               </a>
                           % endif
                       </li>
                       % endfor
 
                       <li class="logout">
                       ${h.secure_form(h.route_path('logout'), request=request)}
                           ${h.submit('log_out', _(u'Sign Out'),class_="btn btn-primary")}
                       ${h.end_form()}
                       </li>
                     </ol>
                     </div>
                 %endif
               </div>
           </div>
 
         % endif
     </li>
 </%def>
 
 <%def name="menu_items(active=None)">
     <%
         notice_messages, notice_level = c.rhodecode_user.get_notice_messages()
         notice_display = 'none' if len(notice_messages) == 0 else ''
     %>
 <style>
 
 </style>
 
     <ul id="quick" class="main_nav navigation horizontal-list">
        ## notice box for important system messages
        <li style="display: ${notice_display}">
           <a class="notice-box" href="#openNotice" onclick="$('.notice-messages-container').toggle(); return false">
             <div class="menulabel-notice ${notice_level}" >
                 ${len(notice_messages)}
             </div>
           </a>
        </li>
         <div class="notice-messages-container" style="display: none">
         <div class="notice-messages">
             <table class="rctable">
             % for notice in notice_messages:
                 <tr id="notice-message-${notice['msg_id']}" class="notice-message-${notice['level']}">
                     <td style="vertical-align: text-top; width: 20px">
                         <i class="tooltip icon-info notice-color-${notice['level']}" title="${notice['level']}"></i>
                     </td>
                     <td>
                         <span><i class="icon-plus-squared cursor-pointer" onclick="$('#notice-${notice['msg_id']}').toggle()"></i> </span>
                         ${notice['subject']}
 
                         <div id="notice-${notice['msg_id']}" style="display: none">
                             ${h.render(notice['body'], renderer='markdown')}
                         </div>
                     </td>
                     <td style="vertical-align: text-top; width: 35px;">
                         <a class="tooltip" title="${_('dismiss')}" href="#dismiss" onclick="dismissNotice(${notice['msg_id']});return false">
                             <i class="icon-remove icon-filled-red"></i>
                         </a>
                     </td>
                 </tr>
 
             % endfor
             </table>
         </div>
         </div>
         ## Main filter
        <li>
         <div class="menulabel main_filter_box">
             <div class="main_filter_input_box">
                 <ul class="searchItems">
 
                     <li class="searchTag searchTagIcon">
                         <i class="icon-search"></i>
                     </li>
 
                     % if c.template_context['search_context']['repo_id']:
                         <li class="searchTag searchTagFilter searchTagHidable" >
                         ##<a href="${h.route_path('search_repo',repo_name=c.template_context['search_context']['repo_name'])}">
                             <span class="tag">
                                 This repo
                                 <a href="#removeGoToFilter" onclick="removeGoToFilter(); return false"><i class="icon-cancel-circled"></i></a>
                             </span>
                         ##</a>
                         </li>
                     % elif c.template_context['search_context']['repo_group_id']:
                         <li class="searchTag searchTagFilter searchTagHidable">
                         ##<a href="${h.route_path('search_repo_group',repo_group_name=c.template_context['search_context']['repo_group_name'])}">
                             <span class="tag">
                                 This group
                                 <a href="#removeGoToFilter" onclick="removeGoToFilter(); return false"><i class="icon-cancel-circled"></i></a>
                             </span>
                         ##</a>
                         </li>
                     % endif
 
                     <li class="searchTagInput">
                         <input class="main_filter_input" id="main_filter" size="25" type="text" name="main_filter" placeholder="${_('search / go to...')}" value="" />
                     </li>
                     <li class="searchTag searchTagHelp">
                         <a href="#showFilterHelp" onclick="showMainFilterBox(); return false">?</a>
                     </li>
                 </ul>
             </div>
         </div>
 
         <div id="main_filter_help" style="display: none">
 - Use '/' key to quickly access this field.
 
 - Enter a name of repository, or repository group for quick search.
 
 - Prefix query to allow special search:
 
    user:admin, to search for usernames, always global
 
    user_group:devops, to search for user groups, always global
 
    pr:303, to search for pull request number, title, or description, always global
 
    commit:efced4, to search for commits, scoped to repositories or groups
 
    file:models.py, to search for file paths, scoped to repositories or groups
 
 % if c.template_context['search_context']['repo_id']:
    For advanced full text search visit: <a href="${h.route_path('search_repo',repo_name=c.template_context['search_context']['repo_name'])}">repository search</a>
 % elif c.template_context['search_context']['repo_group_id']:
    For advanced full text search visit: <a href="${h.route_path('search_repo_group',repo_group_name=c.template_context['search_context']['repo_group_name'])}">repository group search</a>
 % else:
    For advanced full text search visit: <a href="${h.route_path('search')}">global search</a>
 % endif
         </div>
        </li>
 
       ## ROOT MENU
         <li class="${h.is_active('home', active)}">
           <a class="menulink" title="${_('Home')}" href="${h.route_path('home')}">
             <div class="menulabel">${_('Home')}</div>
           </a>
         </li>
 
       %if c.rhodecode_user.username != h.DEFAULT_USER:
         <li class="${h.is_active('journal', active)}">
           <a class="menulink" title="${_('Show activity journal')}" href="${h.route_path('journal')}">
             <div class="menulabel">${_('Journal')}</div>
           </a>
         </li>
       %else:
         <li class="${h.is_active('journal', active)}">
           <a class="menulink" title="${_('Show Public activity journal')}" href="${h.route_path('journal_public')}">
             <div class="menulabel">${_('Public journal')}</div>
           </a>
         </li>
       %endif
 
         <li class="${h.is_active('gists', active)}">
           <a class="menulink childs" title="${_('Show Gists')}" href="${h.route_path('gists_show')}">
             <div class="menulabel">${_('Gists')}</div>
           </a>
         </li>
 
         % if c.is_super_admin or c.is_delegated_admin:
         <li class="${h.is_active('admin', active)}">
           <a class="menulink childs" title="${_('Admin settings')}" href="${h.route_path('admin_home')}">
             <div class="menulabel">${_('Admin')} </div>
           </a>
         </li>
         % endif
 
       ## render extra user menu
       ${usermenu(active=(active=='my_account'))}
 
     </ul>
 
     <script type="text/javascript">
         var visualShowPublicIcon = "${c.visual.show_public_icon}" == "True";
 
         var formatRepoResult = function(result, container, query, escapeMarkup) {
             return function(data, escapeMarkup) {
                 if (!data.repo_id){
                   return data.text; // optgroup text Repositories
                 }
 
                 var tmpl = '';
                 var repoType = data['repo_type'];
                 var repoName = data['text'];
 
                 if(data && data.type == 'repo'){
                     if(repoType === 'hg'){
                         tmpl += '<i class="icon-hg"></i> ';
                     }
                     else if(repoType === 'git'){
                         tmpl += '<i class="icon-git"></i> ';
                     }
                     else if(repoType === 'svn'){
                         tmpl += '<i class="icon-svn"></i> ';
                     }
                     if(data['private']){
                         tmpl += '<i class="icon-lock" ></i> ';
                     }
                     else if(visualShowPublicIcon){
                         tmpl += '<i class="icon-unlock-alt"></i> ';
                     }
                 }
                 tmpl += escapeMarkup(repoName);
                 return tmpl;
 
             }(result, escapeMarkup);
         };
 
         var formatRepoGroupResult = function(result, container, query, escapeMarkup) {
             return function(data, escapeMarkup) {
                 if (!data.repo_group_id){
                   return data.text; // optgroup text Repositories
                 }
 
                 var tmpl = '';
                 var repoGroupName = data['text'];
 
                 if(data){
 
                     tmpl += '<i class="icon-repo-group"></i> ';
 
                 }
                 tmpl += escapeMarkup(repoGroupName);
                 return tmpl;
 
             }(result, escapeMarkup);
         };
 
         var escapeRegExChars = function (value) {
             return value.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
         };
 
         var getRepoIcon = function(repo_type) {
             if (repo_type === 'hg') {
                 return '<i class="icon-hg"></i> ';
             }
             else if (repo_type === 'git') {
                 return '<i class="icon-git"></i> ';
             }
             else if (repo_type === 'svn') {
                 return '<i class="icon-svn"></i> ';
             }
             return ''
         };
 
         var autocompleteMainFilterFormatResult = function (data, value, org_formatter) {
 
             if (value.split(':').length === 2) {
                 value = value.split(':')[1]
             }
 
             var searchType = data['type'];
             var searchSubType = data['subtype'];
             var valueDisplay = data['value_display'];
             var valueIcon = data['value_icon'];
 
             var pattern = '(' + escapeRegExChars(value) + ')';
 
             valueDisplay = Select2.util.escapeMarkup(valueDisplay);
 
             // highlight match
             if (searchType != 'text') {
                 valueDisplay = valueDisplay.replace(new RegExp(pattern, 'gi'), '<strong>$1<\/strong>');
             }
 
             var icon = '';
 
             if (searchType === 'hint') {
                 icon += '<i class="icon-repo-group"></i> ';
             }
             // full text search/hints
             else if (searchType === 'search') {
                 if (valueIcon === undefined) {
                     icon += '<i class="icon-more"></i> ';
                 } else {
                     icon += valueIcon + ' ';
                 }
 
                 if (searchSubType !== undefined && searchSubType == 'repo') {
                     valueDisplay += '<div class="pull-right tag">repository</div>';
                 }
                 else if (searchSubType !== undefined && searchSubType == 'repo_group') {
                     valueDisplay += '<div class="pull-right tag">repo group</div>';
                 }
             }
             // repository
             else if (searchType === 'repo') {
 
                 var repoIcon = getRepoIcon(data['repo_type']);
                 icon += repoIcon;
 
                 if (data['private']) {
                     icon += '<i class="icon-lock" ></i> ';
                 }
                 else if (visualShowPublicIcon) {
                     icon += '<i class="icon-unlock-alt"></i> ';
                 }
             }
             // repository groups
             else if (searchType === 'repo_group') {
                 icon += '<i class="icon-repo-group"></i> ';
             }
             // user group
             else if (searchType === 'user_group') {
                 icon += '<i class="icon-group"></i> ';
             }
             // user
             else if (searchType === 'user') {
                 icon += '<img class="gravatar" src="{0}"/>'.format(data['icon_link']);
             }
             // pull request
             else if (searchType === 'pull_request') {
                 icon += '<i class="icon-merge"></i> ';
             }
             // commit
             else if (searchType === 'commit') {
                 var repo_data = data['repo_data'];
                 var repoIcon = getRepoIcon(repo_data['repository_type']);
                 if (repoIcon) {
                     icon += repoIcon;
                 } else {
                     icon += '<i class="icon-tag"></i>';
                 }
             }
             // file
             else if (searchType === 'file') {
                 var repo_data = data['repo_data'];
                 var repoIcon = getRepoIcon(repo_data['repository_type']);
                 if (repoIcon) {
                     icon += repoIcon;
                 } else {
                     icon += '<i class="icon-tag"></i>';
                 }
             }
             // generic text
             else if (searchType === 'text') {
                 icon = '';
             }
 
             var tmpl = '<div class="ac-container-wrap">{0}{1}</div>';
             return tmpl.format(icon, valueDisplay);
         };
 
         var handleSelect = function(element, suggestion) {
             if (suggestion.type === "hint") {
                 // we skip action
                 $('#main_filter').focus();
             }
             else if (suggestion.type === "text") {
                 // we skip action
                 $('#main_filter').focus();
 
             } else {
               window.location = suggestion['url'];
             }
         };
 
         var autocompleteMainFilterResult = function (suggestion, originalQuery, queryLowerCase) {
             if (queryLowerCase.split(':').length === 2) {
                 queryLowerCase = queryLowerCase.split(':')[1]
             }
             if (suggestion.type === "text") {
                 // special case we don't want to "skip" display for
                 return true
             }
             return suggestion.value_display.toLowerCase().indexOf(queryLowerCase) !== -1;
         };
 
         var cleanContext = {
             repo_view_type: null,
 
             repo_id: null,
             repo_name: "",
 
             repo_group_id: null,
             repo_group_name: null
         };
         var removeGoToFilter = function () {
             $('.searchTagHidable').hide();
             $('#main_filter').autocomplete(
                 'setOptions', {params:{search_context: cleanContext}});
         };
 
         $('#main_filter').autocomplete({
             serviceUrl: pyroutes.url('goto_switcher_data'),
             params: {
                 "search_context": templateContext.search_context
             },
             minChars:2,
             maxHeight:400,
             deferRequestBy: 300, //miliseconds
             tabDisabled: true,
             autoSelectFirst: false,
             containerClass: 'autocomplete-qfilter-suggestions',
             formatResult: autocompleteMainFilterFormatResult,
             lookupFilter: autocompleteMainFilterResult,
             onSelect: function (element, suggestion) {
                 handleSelect(element, suggestion);
                 return false;
             },
             onSearchError: function (element, query, jqXHR, textStatus, errorThrown) {
                 if (jqXHR !== 'abort') {
                     var message = formatErrorMessage(jqXHR, textStatus, errorThrown);
                     SwalNoAnimation.fire({
                         icon: 'error',
                         title: _gettext('Error during search operation'),
                         html: '<span style="white-space: pre-line">{0}</span>'.format(message),
                     }).then(function(result) {
                         window.location.reload();
                     })
                 }
             },
             onSearchStart: function (params) {
                 $('.searchTag.searchTagIcon').html('<i class="icon-spin animate-spin"></i>')
             },
             onSearchComplete: function (query, suggestions) {
                 $('.searchTag.searchTagIcon').html('<i class="icon-search"></i>')
             },
         });
 
         showMainFilterBox = function () {
             $('#main_filter_help').toggle();
         };
 
         $('#main_filter').on('keydown.autocomplete', function (e) {
 
             var BACKSPACE = 8;
             var el = $(e.currentTarget);
             if(e.which === BACKSPACE){
                 var inputVal = el.val();
                 if (inputVal === ""){
                     removeGoToFilter()
                 }
             }
         });
 
         var dismissNotice = function(noticeId) {
 
             var url = pyroutes.url('user_notice_dismiss',
                     {"user_id": templateContext.rhodecode_user.user_id});
 
             var postData = {
                 'csrf_token': CSRF_TOKEN,
                 'notice_id': noticeId,
             };
 
             var success = function(response) {
                 $('#notice-message-' + noticeId).remove();
                 return false;
             };
             var failure = function(data, textStatus, xhr) {
                 alert("error processing request: " + textStatus);
                 return false;
             };
             ajaxPOST(url, postData, success, failure);
         }
     </script>
     <script src="${h.asset('js/rhodecode/base/keyboard-bindings.js', ver=c.rhodecode_version_hash)}"></script>
 </%def>
 
 <div class="modal" id="help_kb" tabindex="-1" role="dialog" aria-labelledby="myModalLabel" aria-hidden="true">
     <div class="modal-dialog">
       <div class="modal-content">
         <div class="modal-header">
           <button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>
           <h4 class="modal-title" id="myModalLabel">${_('Keyboard shortcuts')}</h4>
         </div>
         <div class="modal-body">
               <div class="block-left">
                 <table class="keyboard-mappings">
                     <tbody>
                   <tr>
                     <th></th>
                     <th>${_('Site-wide shortcuts')}</th>
                   </tr>
                   <%
                      elems = [
                          ('/', 'Use quick search box'),
                          ('g h', 'Goto home page'),
                          ('g g', 'Goto my private gists page'),
                          ('g G', 'Goto my public gists page'),
                          ('g 0-9', 'Goto bookmarked items from 0-9'),
                          ('n r', 'New repository page'),
                          ('n g', 'New gist page'),
                      ]
                   %>
                   %for key, desc in elems:
                   <tr>
                     <td class="keys">
                       <span class="key tag">${key}</span>
                     </td>
                     <td>${desc}</td>
                   </tr>
                 %endfor
                 </tbody>
                   </table>
               </div>
               <div class="block-left">
                 <table class="keyboard-mappings">
                 <tbody>
                   <tr>
                     <th></th>
                     <th>${_('Repositories')}</th>
                   </tr>
                   <%
                      elems = [
                          ('g s', 'Goto summary page'),
                          ('g c', 'Goto changelog page'),
                          ('g f', 'Goto files page'),
                          ('g F', 'Goto files page with file search activated'),
                          ('g p', 'Goto pull requests page'),
                          ('g o', 'Goto repository settings'),
                          ('g O', 'Goto repository access permissions settings'),
                      ]
                   %>
                   %for key, desc in elems:
                   <tr>
                     <td class="keys">
                       <span class="key tag">${key}</span>
                     </td>
                     <td>${desc}</td>
                   </tr>
                 %endfor
                 </tbody>
               </table>
             </div>
         </div>
         <div class="modal-footer">
         </div>
       </div><!-- /.modal-content -->
     </div><!-- /.modal-dialog -->
 </div><!-- /.modal -->

rhodecode/templates/base/root.mako

@@ -1,166 +1,166 b''
 ## -*- coding: utf-8 -*-
 <!DOCTYPE html>
 
 <%
 c.template_context['repo_name'] = getattr(c, 'repo_name', '')
 go_import_header = ''
 if hasattr(c, 'rhodecode_db_repo'):
     c.template_context['repo_type'] = c.rhodecode_db_repo.repo_type
-    c.template_context['repo_landing_commit'] = c.rhodecode_db_repo.landing_rev[1]
+    c.template_context['repo_landing_commit'] = c.rhodecode_db_repo.landing_ref_name
     c.template_context['repo_id'] = c.rhodecode_db_repo.repo_id
     c.template_context['repo_view_type'] = h.get_repo_view_type(request)
 
 if getattr(c, 'repo_group', None):
     c.template_context['repo_group_id'] = c.repo_group.group_id
     c.template_context['repo_group_name'] = c.repo_group.group_name
 
 if getattr(c, 'rhodecode_user', None) and c.rhodecode_user.user_id:
     c.template_context['rhodecode_user']['user_id'] = c.rhodecode_user.user_id
     c.template_context['rhodecode_user']['username'] = c.rhodecode_user.username
     c.template_context['rhodecode_user']['email'] = c.rhodecode_user.email
     c.template_context['rhodecode_user']['notification_status'] = c.rhodecode_user.get_instance().user_data.get('notification_status', True)
     c.template_context['rhodecode_user']['first_name'] = c.rhodecode_user.first_name
     c.template_context['rhodecode_user']['last_name'] = c.rhodecode_user.last_name
 
 c.template_context['visual']['default_renderer'] = h.get_visual_attr(c, 'default_renderer')
 c.template_context['default_user'] = {
     'username': h.DEFAULT_USER,
     'user_id': 1
 }
 c.template_context['search_context'] = {
     'repo_group_id': c.template_context.get('repo_group_id'),
     'repo_group_name': c.template_context.get('repo_group_name'),
     'repo_id': c.template_context.get('repo_id'),
     'repo_name': c.template_context.get('repo_name'),
     'repo_view_type': c.template_context.get('repo_view_type'),
 }
 
 c.template_context['attachment_store'] = {
     'max_file_size_mb': 10,
     'image_ext': ["png", "jpg", "gif", "jpeg"]
 }
 
 %>
 <html xmlns="http://www.w3.org/1999/xhtml">
     <head>
         <title>${self.title()}</title>
         <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
 
         ${h.go_import_header(request, getattr(c, 'rhodecode_db_repo', None))}
 
         % if 'safari' in (request.user_agent or '').lower():
             <meta name="referrer" content="origin">
         % else:
             <meta name="referrer" content="origin-when-cross-origin">
         % endif
 
         <%def name="robots()">
             <meta name="robots" content="index, nofollow"/>
         </%def>
         ${self.robots()}
         <link rel="icon" href="${h.asset('images/favicon.ico', ver=c.rhodecode_version_hash)}" sizes="16x16 32x32" type="image/png" />
         <script src="${h.asset('js/vendors/webcomponentsjs/custom-elements-es5-adapter.js', ver=c.rhodecode_version_hash)}"></script>
         <script src="${h.asset('js/vendors/webcomponentsjs/webcomponents-bundle.js', ver=c.rhodecode_version_hash)}"></script>
 
         ## CSS definitions
         <%def name="css()">
             <link rel="stylesheet" type="text/css" href="${h.asset('css/style.css', ver=c.rhodecode_version_hash)}" media="screen"/>
             ## EXTRA FOR CSS
             ${self.css_extra()}
         </%def>
         ## CSS EXTRA - optionally inject some extra CSS stuff needed for specific websites
         <%def name="css_extra()">
         </%def>
 
         ${self.css()}
 
         ## JAVASCRIPT
         <%def name="js()">
 
             <script src="${h.asset('js/rhodecode/i18n/%s.js' % c.language, ver=c.rhodecode_version_hash)}"></script>
             <script type="text/javascript">
             // register templateContext to pass template variables to JS
             var templateContext = ${h.json.dumps(c.template_context)|n};
 
             var APPLICATION_URL = "${h.route_path('home').rstrip('/')}";
             var APPLICATION_PLUGINS = [];
             var ASSET_URL = "${h.asset('')}";
             var DEFAULT_RENDERER = "${h.get_visual_attr(c, 'default_renderer')}";
             var CSRF_TOKEN = "${getattr(c, 'csrf_token', '')}";
 
             var APPENLIGHT = {
               enabled: ${'true' if getattr(c, 'appenlight_enabled', False) else 'false'},
               key: '${getattr(c, "appenlight_api_public_key", "")}',
               % if getattr(c, 'appenlight_server_url', None):
                   serverUrl: '${getattr(c, "appenlight_server_url", "")}',
               % endif
               requestInfo: {
               % if getattr(c, 'rhodecode_user', None):
                   ip: '${c.rhodecode_user.ip_addr}',
                   username: '${c.rhodecode_user.username}'
               % endif
               },
               tags: {
                   rhodecode_version: '${c.rhodecode_version}',
                   rhodecode_edition: '${c.rhodecode_edition}'
               }
             };
 
             </script>
             <%include file="/base/plugins_base.mako"/>
             <!--[if lt IE 9]>
             <script language="javascript" type="text/javascript" src="${h.asset('js/src/excanvas.min.js')}"></script>
             <![endif]-->
             <script language="javascript" type="text/javascript" src="${h.asset('js/rhodecode/routes.js', ver=c.rhodecode_version_hash)}"></script>
             <script> var alertMessagePayloads = ${h.flash.json_alerts(request=request)|n}; </script>
             ## avoide escaping the %N
             <script language="javascript" type="text/javascript" src="${h.asset('js/scripts.min.js', ver=c.rhodecode_version_hash)}"></script>
             <script>CodeMirror.modeURL = "${h.asset('') + 'js/mode/%N/%N.js?ver='+c.rhodecode_version_hash}";</script>
 
 
             ## JAVASCRIPT EXTRA - optionally inject some extra JS for specificed templates
             ${self.js_extra()}
 
             <script type="text/javascript">
             Rhodecode = (function() {
                 function _Rhodecode() {
                   this.comments = new CommentsController();
                 }
                 return new _Rhodecode();
             })();
 
             $(document).ready(function(){
               show_more_event();
               timeagoActivate();
               tooltipActivate();
               clipboardActivate();
             })
             </script>
 
         </%def>
 
         ## JAVASCRIPT EXTRA - optionally inject some extra JS for specificed templates
         <%def name="js_extra()"></%def>
         ${self.js()}
 
         <%def name="head_extra()"></%def>
         ${self.head_extra()}
         ## extra stuff
         %if c.pre_code:
             ${c.pre_code|n}
         %endif
     </head>
     <body id="body">
         <noscript>
             <div class="noscript-error">
                 ${_('Please enable JavaScript to use RhodeCode Enterprise')}
             </div>
         </noscript>
 
       ${next.body()}
       %if c.post_code:
         ${c.post_code|n}
       %endif
     <rhodecode-app></rhodecode-app>
     </body>
 </html>

rhodecode/templates/commits/changelog.mako

@@ -1,326 +1,326 b''
 ## -*- coding: utf-8 -*-
 
 <%inherit file="/base/base.mako"/>
 
 <%def name="title()">
     ${_('%s Changelog') % c.repo_name}
     %if c.changelog_for_path:
       /${c.changelog_for_path}
     %endif
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}
     %endif
 </%def>
 
 <%def name="breadcrumbs_links()">
     %if c.changelog_for_path:
      /${c.changelog_for_path}
     %endif
 </%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='repositories')}
 </%def>
 
 <%def name="menu_bar_subnav()">
     ${self.repo_menu(active='commits')}
 </%def>
 
 <%def name="main()">
 
 <div class="box">
 
     <div class="title">
         <div id="filter_changelog">
             ${h.hidden('branch_filter')}
              %if c.selected_name:
              <div class="btn btn-default" id="clear_filter" >
                  ${_('Clear filter')}
              </div>
             %endif
         </div>
         <div class="pull-left obsolete-toggle">
             % if h.is_hg(c.rhodecode_repo):
                 % if c.show_hidden:
                     <a class="action-link" href="${h.current_route_path(request, evolve=0)}">${_('Hide obsolete/hidden')}</a>
                 % else:
                     <a class="action-link" href="${h.current_route_path(request, evolve=1)}">${_('Show obsolete/hidden')}</a>
                 % endif
             % else:
                     <span class="action-link disabled">${_('Show hidden')}</span>
             % endif
         </div>
         <ul class="links">
             <li>
 
                 %if c.rhodecode_db_repo.fork:
                     <span>
                         <a  id="compare_fork_button"
                             title="${h.tooltip(_('Compare fork with %s' % c.rhodecode_db_repo.fork.repo_name))}"
                             class="btn btn-small"
                             href="${h.route_path('repo_compare',
                                 repo_name=c.rhodecode_db_repo.fork.repo_name,
-                                source_ref_type=c.rhodecode_db_repo.landing_rev[0],
-                                source_ref=c.rhodecode_db_repo.landing_rev[1],
-                                target_ref_type='branch' if request.GET.get('branch') else c.rhodecode_db_repo.landing_rev[0],
-                                target_ref=request.GET.get('branch') or c.rhodecode_db_repo.landing_rev[1],
+                                source_ref_type=c.rhodecode_db_repo.landing_ref_type,
+                                source_ref=c.rhodecode_db_repo.landing_ref_name,
+                                target_ref_type='branch' if request.GET.get('branch') else c.rhodecode_db_repo.landing_ref_type,
+                                target_ref=request.GET.get('branch') or c.rhodecode_db_repo.landing_ref_name,
                                 _query=dict(merge=1, target_repo=c.repo_name))}"
                         >
                         ${_('Compare fork with Parent (%s)' % c.rhodecode_db_repo.fork.repo_name)}
                         </a>
                     </span>
                 %endif
 
                 ## pr open link
                 %if h.is_hg(c.rhodecode_repo) or h.is_git(c.rhodecode_repo):
                     <span>
                         <a id="open_new_pull_request" class="btn btn-small btn-success" href="${h.route_path('pullrequest_new',repo_name=c.repo_name)}">
                             ${_('Open new pull request')}
                         </a>
                     </span>
                 %endif
 
             </li>
         </ul>
     </div>
 
     % if c.pagination:
         <script type="text/javascript" src="${h.asset('js/src/plugins/jquery.commits-graph.js')}"></script>
 
         <div class="graph-header">
             ${self.breadcrumbs('breadcrumbs_light')}
         </div>
 
         <div id="graph">
             <div class="graph-col-wrapper">
               <div id="graph_nodes">
                 <div id="graph_canvas"></div>
             </div>
             <div id="graph_content" class="graph_full_width">
 
               <div class="table">
                 <table id="changesets" class="rctable">
                     <tr>
                       ## checkbox
                       <th colspan="4">
                         ## clear selection
                         <div title="${_('Clear selection')}" class="btn btn-sm" id="rev_range_clear" style="display:none">
                             <i class="icon-cancel-circled2"></i>
                         </div>
                         <div class="btn btn-sm disabled" disabled="disabled" id="rev_range_more" style="display:none;">${_('Select second commit')}</div>
                         <a href="#" class="btn btn-success btn-sm" id="rev_range_container" style="display:none;"></a>
                       </th>
 
                       ## commit message expand arrow
                       <th></th>
                       <th>${_('Commit Message')}</th>
 
                       <th>${_('Age')}</th>
                       <th>${_('Author')}</th>
 
                       <th>${_('Refs')}</th>
                       ## comments
                       <th></th>
                     </tr>
 
                     <tbody class="commits-range">
                         <%include file='changelog_elements.mako'/>
                     </tbody>
                 </table>
               </div>
             </div>
             <div class="pagination-wh pagination-left">
             ${c.pagination.render()}
             </div>
             <div id="commit-counter" data-total=${c.total_cs} class="pull-right">
                 ${_ungettext('showing %d out of %d commit', 'showing %d out of %d commits', c.showing_commits) % (c.showing_commits, c.total_cs)}
             </div>
         </div>
 
         <script type="text/javascript">
         var cache = {};
         $(function(){
 
             // Create links to commit ranges when range checkboxes are selected
             var $commitCheckboxes = $('.commit-range');
             // cache elements
             var $commitRangeMore = $('#rev_range_more');
             var $commitRangeContainer = $('#rev_range_container');
             var $commitRangeClear = $('#rev_range_clear');
 
             var checkboxRangeSelector = function(e){
                 var selectedCheckboxes = [];
                 for (pos in $commitCheckboxes){
                     if($commitCheckboxes[pos].checked){
                         selectedCheckboxes.push($commitCheckboxes[pos]);
                     }
                 }
                 var open_new_pull_request = $('#open_new_pull_request');
 
                 if (open_new_pull_request) {
                     var selected_changes = selectedCheckboxes.length;
                     open_new_pull_request.hide();
                     if (selected_changes == 1) {
                         open_new_pull_request.html(_gettext('Open new pull request for selected commit'));
                     } else {
                         open_new_pull_request.html(_gettext('Open new pull request'));
                     }
                     open_new_pull_request.show();
                 }
 
                 if (selectedCheckboxes.length > 0) {
                     $('#compare_fork_button').hide();
                     var commitStart = $(selectedCheckboxes[selectedCheckboxes.length-1]).data();
 
                     var revStart = commitStart.commitId;
 
                     var commitEnd = $(selectedCheckboxes[0]).data();
                     var revEnd = commitEnd.commitId;
 
                     var lbl_start = '{0}'.format(commitStart.commitIdx, commitStart.shortId);
                     var lbl_end = '{0}'.format(commitEnd.commitIdx, commitEnd.shortId);
 
                     var url = pyroutes.url('repo_commit', {'repo_name': '${c.repo_name}', 'commit_id': revStart+'...'+revEnd});
                     var link = _gettext('Show commit range {0} ... {1}').format(lbl_start, lbl_end);
 
                     if (selectedCheckboxes.length > 1) {
                         $commitRangeClear.show();
                         $commitRangeMore.hide();
 
                         $commitRangeContainer
                             .attr('href',url)
                             .html(link)
                             .show();
 
 
                     } else {
                         $commitRangeContainer.hide();
                         $commitRangeClear.show();
                         $commitRangeMore.show();
                     }
 
                     // pull-request link
                     if (selectedCheckboxes.length == 1){
                         var _url = pyroutes.url('pullrequest_new', {'repo_name': '${c.repo_name}', 'commit': revEnd});
                         open_new_pull_request.attr('href', _url);
                     } else {
                         var _url = pyroutes.url('pullrequest_new', {'repo_name': '${c.repo_name}'});
                         open_new_pull_request.attr('href', _url);
                     }
 
                 } else {
                     $commitRangeContainer.hide();
                     $commitRangeClear.hide();
                     $commitRangeMore.hide();
 
                     %if c.branch_name:
                         var _url = pyroutes.url('pullrequest_new', {'repo_name': '${c.repo_name}', 'branch':'${c.branch_name}'});
                         open_new_pull_request.attr('href', _url);
                     %else:
                         var _url = pyroutes.url('pullrequest_new', {'repo_name': '${c.repo_name}'});
                         open_new_pull_request.attr('href', _url);
                     %endif
                     $('#compare_fork_button').show();
                 }
             };
 
             $commitCheckboxes.on('click', checkboxRangeSelector);
 
             $commitRangeClear.on('click',function(e) {
                 $commitCheckboxes.attr('checked', false);
                 checkboxRangeSelector();
                 e.preventDefault();
             });
 
             // make sure the buttons are consistent when navigate back and forth
             checkboxRangeSelector();
 
             var msgs = $('.message');
             // get first element height
             var el = $('#graph_content .container')[0];
             var row_h = el.clientHeight;
             for (var i=0; i < msgs.length; i++) {
                 var m = msgs[i];
 
                 var h = m.clientHeight;
                 var pad = $(m).css('padding');
                 if (h > row_h) {
                     var offset = row_h - (h+12);
                     $(m.nextElementSibling).css('display','block');
                     $(m.nextElementSibling).css('margin-top',offset+'px');
                 }
             }
 
             $("#clear_filter").on("click", function() {
                 var filter = {'repo_name': '${c.repo_name}'};
                 window.location = pyroutes.url('repo_commits', filter);
             });
 
             $("#branch_filter").select2({
                 'dropdownAutoWidth': true,
                 'width': 'resolve',
                 'placeholder': "${c.selected_name or _('Branch filter')}",
                 containerCssClass: "drop-menu",
                 dropdownCssClass: "drop-menu-dropdown",
                 query: function(query){
                   var key = 'cache';
                   var cached = cache[key] ;
                   if(cached) {
                     var data = {results: []};
                     //filter results
                     $.each(cached.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({'id': this.id, 'text': this.text, 'type': this.type})
                             }
                         });
                         data.results.push({'text': section, 'children': children});
                         query.callback({results: data.results});
                     });
                   }else{
                       $.ajax({
                         url: pyroutes.url('repo_refs_changelog_data', {'repo_name': '${c.repo_name}'}),
                         data: {},
                         dataType: 'json',
                         type: 'GET',
                         success: function(data) {
                           cache[key] = data;
                           query.callback({results: data.results});
                         }
                       })
                   }
                 }
             });
             $('#branch_filter').on('change', function(e){
                 var data = $('#branch_filter').select2('data');
                 //type: branch_closed
                 var selected = data.text;
                 var filter = {'repo_name': '${c.repo_name}'};
                 if(data.type == 'branch' || data.type == 'branch_closed'){
                     filter["branch"] = selected;
                     if (data.type == 'branch_closed') {
                         filter["evolve"] = '1';
                     }
                 }
                 else if (data.type == 'book'){
                     filter["bookmark"] = selected;
                 }
                 window.location = pyroutes.url('repo_commits', filter);
             });
 
             commitsController = new CommitsController();
             % if not c.changelog_for_path:
                 commitsController.reloadGraph();
             % endif
 
         });
 
     </script>
         </div>
     % else:
         ${_('There are no changes yet')}
     % endif
 </div>
 </%def>

rhodecode/templates/compare/compare_diff.mako

@@ -1,308 +1,308 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.mako"/>
 <%namespace name="cbdiffs" file="/codeblocks/diffs.mako"/>
 
 <%def name="title()">
     %if c.compare_home:
         ${_('%s Compare') % c.repo_name}
     %else:
         ${_('%s Compare') % c.repo_name} - ${'%s@%s' % (c.source_repo.repo_name, c.source_ref)} &gt; ${'%s@%s' % (c.target_repo.repo_name, c.target_ref)}
     %endif
     %if c.rhodecode_name:
         &middot; ${h.branding(c.rhodecode_name)}
     %endif
 </%def>
 
 <%def name="breadcrumbs_links()"></%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='repositories')}
 </%def>
 
 <%def name="menu_bar_subnav()">
     ${self.repo_menu(active='compare')}
 </%def>
 
 <%def name="main()">
     <script type="text/javascript">
         // set fake commitId on this commit-range page
         templateContext.commit_data.commit_id = "${h.EmptyCommit().raw_id}";
     </script>
 
     <div class="box">
         <div class="summary changeset">
             <div class="summary-detail">
               <div class="summary-detail-header">
                   <span class="breadcrumbs files_location">
                     <h4>
                         ${_('Compare Commits')}
                         % if c.file_path:
                         ${_('for file')} <a href="#${('a_' + h.FID('',c.file_path))}">${c.file_path}</a>
                         % endif
 
                         % if c.commit_ranges:
                         <code>
                         r${c.commit_ranges[0].idx}:${h.short_id(c.commit_ranges[0].raw_id)}...r${c.commit_ranges[-1].idx}:${h.short_id(c.commit_ranges[-1].raw_id)}
                         </code>
                         % endif
                     </h4>
                   </span>
 
                   <div class="clear-fix"></div>
               </div>
 
               <div class="fieldset">
                 <div class="left-label-summary">
                     <p class="spacing">${_('Target')}:</p>
                     <div class="right-label-summary">
                         <div class="code-header" >
                             <div class="compare_header">
                                 ## The hidden elements are replaced with a select2 widget
                                 ${h.hidden('compare_source')}
                             </div>
                         </div>
                     </div>
                 </div>
               </div>
 
               <div class="fieldset">
                 <div class="left-label-summary">
                     <p class="spacing">${_('Source')}:</p>
                     <div class="right-label-summary">
                         <div class="code-header" >
                             <div class="compare_header">
                                 ## The hidden elements are replaced with a select2 widget
                                 ${h.hidden('compare_target')}
                             </div>
                         </div>
                     </div>
                 </div>
               </div>
 
               <div class="fieldset">
                 <div class="left-label-summary">
                     <p class="spacing">${_('Actions')}:</p>
                     <div class="right-label-summary">
                         <div class="code-header" >
                             <div class="compare_header">
                                 <div class="compare-buttons">
                                 % if c.compare_home:
                                   <a id="compare_revs" class="btn btn-primary"> ${_('Compare Commits')}</a>
                                   %if c.rhodecode_db_repo.fork:
 
                                        <a class="btn btn-default" title="${h.tooltip(_('Compare fork with %s' % c.rhodecode_db_repo.fork.repo_name))}"
                                           href="${h.route_path('repo_compare',
                                                 repo_name=c.rhodecode_db_repo.fork.repo_name,
-                                                source_ref_type=c.rhodecode_db_repo.landing_rev[0],
-                                                source_ref=c.rhodecode_db_repo.landing_rev[1],
-                                                target_repo=c.repo_name,target_ref_type='branch' if request.GET.get('branch') else c.rhodecode_db_repo.landing_rev[0],
-                                                target_ref=request.GET.get('branch') or c.rhodecode_db_repo.landing_rev[1],
+                                                source_ref_type=c.rhodecode_db_repo.landing_ref_type,
+                                                source_ref=c.rhodecode_db_repo.landing_ref_name,
+                                                target_repo=c.repo_name,target_ref_type='branch' if request.GET.get('branch') else c.rhodecode_db_repo.landing_ref_type,
+                                                target_ref=request.GET.get('branch') or c.rhodecode_db_repo.landing_ref_name,
                                                 _query=dict(merge=1))}"
                                         >
                                        ${_('Compare with origin')}
                                        </a>
 
                                   %endif
 
                                   <a class="btn disabled tooltip" disabled="disabled" title="${_('Action unavailable in current view')}">${_('Swap')}</a>
                                   <a class="btn disabled tooltip" disabled="disabled" title="${_('Action unavailable in current view')}">${_('Comment')}</a>
                                   <div id="changeset_compare_view_content">
                                      <div class="help-block">${_('Compare commits, branches, bookmarks or tags.')}</div>
                                   </div>
 
                                 % elif c.preview_mode:
                                   <a class="btn disabled tooltip" disabled="disabled" title="${_('Action unavailable in current view')}">${_('Compare Commits')}</a>
                                   <a class="btn disabled tooltip" disabled="disabled" title="${_('Action unavailable in current view')}">${_('Swap')}</a>
                                   <a class="btn disabled tooltip" disabled="disabled" title="${_('Action unavailable in current view')}">${_('Comment')}</a>
 
                                 % else:
                                   <a id="compare_revs" class="btn btn-primary"> ${_('Compare Commits')}</a>
                                   <a id="btn-swap" class="btn btn-primary" href="${c.swap_url}">${_('Swap')}</a>
 
                                   ## allow comment only if there are commits to comment on
                                   % if c.diffset and c.diffset.files and c.commit_ranges:
                                     <a id="compare_changeset_status_toggle" class="btn btn-primary">${_('Comment')}</a>
                                   % else:
                                     <a class="btn disabled tooltip" disabled="disabled" title="${_('Action unavailable in current view')}">${_('Comment')}</a>
                                   % endif
                                 % endif
                                 </div>
                             </div>
                         </div>
                     </div>
                     </div>
               </div>
 
               ## commit status form
               <div class="fieldset" id="compare_changeset_status" style="display: none; margin-bottom: -80px;">
                 <div class="left-label-summary">
                     <p class="spacing">${_('Commit status')}:</p>
                     <div class="right-label-summary">
                         <%namespace name="comment" file="/changeset/changeset_file_comment.mako"/>
                         ## main comment form and it status
                         <%
                         def revs(_revs):
                             form_inputs = []
                             for cs in _revs:
                                 tmpl = '<input type="hidden" data-commit-id="%(cid)s" name="commit_ids" value="%(cid)s">' % {'cid': cs.raw_id}
                                 form_inputs.append(tmpl)
                             return form_inputs
                         %>
                         <div>
                             ${comment.comments(h.route_path('repo_commit_comment_create', repo_name=c.repo_name, commit_id='0'*16), None, is_compare=True, form_extras=revs(c.commit_ranges))}
                         </div>
                     </div>
                 </div>
               </div>
               <div class="clear-fix"></div>
             </div> <!-- end summary-detail -->
         </div> <!-- end summary -->
 
         ## use JS script to load it quickly before potentially large diffs render long time
         ## this prevents from situation when large diffs block rendering of select2 fields
         <script type="text/javascript">
 
                 var cache = {};
 
                 var formatSelection = function(repoName){
                     return function(data, container, escapeMarkup) {
                         var selection = data ? this.text(data) : "";
                         return escapeMarkup('{0}@{1}'.format(repoName, selection));
                     }
                 };
 
                 var feedCompareData = function(query, cachedValue){
                     var data = {results: []};
                     //filter results
                     $.each(cachedValue.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({
                                     'id': this.id,
                                     'text': this.text,
                                     'type': this.type
                                 })
                             }
                         });
                         data.results.push({
                             'text': section,
                             'children': children
                         })
                     });
                     //push the typed in changeset
                     data.results.push({
                         'text': _gettext('specify commit'),
                         'children': [{
                             'id': query.term,
                             'text': query.term,
                             'type': 'rev'
                         }]
                     });
                     query.callback(data);
                 };
 
                 var loadCompareData = function(repoName, query, cache){
                     $.ajax({
                         url: pyroutes.url('repo_refs_data', {'repo_name': repoName}),
                         data: {},
                         dataType: 'json',
                         type: 'GET',
                         success: function(data) {
                             cache[repoName] = data;
                             query.callback({results: data.results});
                         }
                     })
                 };
 
                 var enable_fields = ${"false" if c.preview_mode else "true"};
                 $("#compare_source").select2({
                     placeholder: "${'%s@%s' % (c.source_repo.repo_name, c.source_ref)}",
                     containerCssClass: "drop-menu",
                     dropdownCssClass: "drop-menu-dropdown",
                     formatSelection: formatSelection("${c.source_repo.repo_name}"),
                     dropdownAutoWidth: true,
                     query: function(query) {
                         var repoName = '${c.source_repo.repo_name}';
                         var cachedValue = cache[repoName];
 
                         if (cachedValue){
                             feedCompareData(query, cachedValue);
                         }
                         else {
                             loadCompareData(repoName, query, cache);
                         }
                     }
                 }).select2("enable", enable_fields);
 
                 $("#compare_target").select2({
                     placeholder: "${'%s@%s' % (c.target_repo.repo_name, c.target_ref)}",
                     dropdownAutoWidth: true,
                     containerCssClass: "drop-menu",
                     dropdownCssClass: "drop-menu-dropdown",
                     formatSelection: formatSelection("${c.target_repo.repo_name}"),
                     query: function(query) {
                         var repoName = '${c.target_repo.repo_name}';
                         var cachedValue = cache[repoName];
 
                         if (cachedValue){
                             feedCompareData(query, cachedValue);
                         }
                         else {
                             loadCompareData(repoName, query, cache);
                         }
                     }
                 }).select2("enable", enable_fields);
                 var initial_compare_source = {id: "${c.source_ref}", type:"${c.source_ref_type}"};
                 var initial_compare_target = {id: "${c.target_ref}", type:"${c.target_ref_type}"};
 
                 $('#compare_revs').on('click', function(e) {
                     var source = $('#compare_source').select2('data') || initial_compare_source;
                     var target = $('#compare_target').select2('data')  || initial_compare_target;
                     if (source && target) {
                         var url_data = {
                             repo_name: "${c.repo_name}",
                             source_ref: source.id,
                             source_ref_type: source.type,
                             target_ref: target.id,
                             target_ref_type: target.type
                         };
                         window.location = pyroutes.url('repo_compare', url_data);
                     }
                 });
                 $('#compare_changeset_status_toggle').on('click', function(e) {
                     $('#compare_changeset_status').toggle();
                 });
 
         </script>
 
         ## table diff data
         <div class="table">
             % if not c.compare_home:
                 <div id="changeset_compare_view_content">
                     <div class="pull-left">
                       <div class="btn-group">
                           <a class="${('collapsed' if c.collapse_all_commits else '')}" href="#expand-commits" onclick="toggleCommitExpand(this); return false" data-toggle-commits-cnt=${len(c.commit_ranges)} >
                               % if c.collapse_all_commits:
                                 <i class="icon-plus-squared-alt icon-no-margin"></i>
                                 ${_ungettext('Expand {} commit', 'Expand {} commits', len(c.commit_ranges)).format(len(c.commit_ranges))}
                               % else:
                                 <i class="icon-minus-squared-alt icon-no-margin"></i>
                                 ${_ungettext('Collapse {} commit', 'Collapse {} commits', len(c.commit_ranges)).format(len(c.commit_ranges))}
                               % endif
                           </a>
                       </div>
                     </div>
                     <div style="padding:0 10px 10px 0px" class="pull-left"></div>
                     ## commit compare generated below
                     <%include file="compare_commits.mako"/>
                     ${cbdiffs.render_diffset_menu(c.diffset)}
                     ${cbdiffs.render_diffset(c.diffset)}
                  </div>
             % endif
 
         </div>
     </div>
 
 </%def>

rhodecode/templates/files/files_browser.mako

@@ -1,84 +1,84 b''
 
 <div id="codeblock" class="browserblock">
     <div class="browser-header">
         <div class="browser-nav">
 
             <div class="info_box">
 
               <div class="info_box_elem previous">
                   <a id="prev_commit_link" data-commit-id="${c.prev_commit.raw_id}" class=" ${('disabled' if c.url_prev == '#' else '')}" href="${c.url_prev}" title="${_('Previous commit')}"><i class="icon-left"></i></a>
               </div>
 
               ${h.hidden('refs_filter')}
 
               <div class="info_box_elem next">
                   <a id="next_commit_link" data-commit-id="${c.next_commit.raw_id}" class=" ${('disabled' if c.url_next == '#' else '')}" href="${c.url_next}" title="${_('Next commit')}"><i class="icon-right"></i></a>
               </div>
             </div>
 
             % if h.HasRepoPermissionAny('repository.write','repository.admin')(c.repo_name):
               <div>
                 <a class="btn btn-primary new-file" href="${h.route_path('repo_files_upload_file',repo_name=c.repo_name,commit_id=c.commit.raw_id,f_path=c.f_path)}">
                     ${_('Upload File')}
                 </a>
                 <a class="btn btn-primary new-file" href="${h.route_path('repo_files_add_file',repo_name=c.repo_name,commit_id=c.commit.raw_id,f_path=c.f_path)}">
                     ${_('Add File')}
                 </a>
               </div>
             % endif
 
             % if c.enable_downloads:
               <% at_path = '{}'.format(request.GET.get('at') or c.commit.raw_id[:6]) %>
               <div class="btn btn-default new-file">
                   % if c.f_path == '/':
                     <a href="${h.route_path('repo_archivefile',repo_name=c.repo_name, fname='{}.zip'.format(c.commit.raw_id))}">
                         ${_('Download full tree ZIP')}
                     </a>
                   % else:
                     <a href="${h.route_path('repo_archivefile',repo_name=c.repo_name, fname='{}.zip'.format(c.commit.raw_id), _query={'at_path':c.f_path})}">
                         ${_('Download this tree ZIP')}
                     </a>
                   % endif
               </div>
             % endif
 
             <div class="files-quick-filter">
                 <ul class="files-filter-box">
                     <li class="files-filter-box-path">
                         <i class="icon-search"></i>
                     </li>
                     <li class="files-filter-box-input">
                         <input onkeydown="NodeFilter.initFilter(event)" class="init" type="text" placeholder="Quick filter" name="filter" size="25" id="node_filter" autocomplete="off">
                     </li>
                 </ul>
             </div>
         </div>
 
     </div>
 
     ## file tree is computed from caches, and filled in
     <div id="file-tree">
     ${c.file_tree |n}
     </div>
 
     %if c.readme_data:
     <div id="readme" class="anchor">
     <div class="box">
-        <div class="readme-title" title="${h.tooltip(_('Readme file from commit %s:%s') % (c.rhodecode_db_repo.landing_rev[0], c.rhodecode_db_repo.landing_rev[1]))}">
+        <div class="readme-title" title="${h.tooltip(_('Readme file from commit %s:%s') % (c.rhodecode_db_repo.landing_ref_type, c.rhodecode_db_repo.landing_ref_name))}">
             <div>
                 <i class="icon-file-text"></i>
-                <a href="${h.route_path('repo_files',repo_name=c.repo_name,commit_id=c.rhodecode_db_repo.landing_rev[1],f_path=c.readme_file)}">
+                <a href="${h.route_path('repo_files',repo_name=c.repo_name,commit_id=c.rhodecode_db_repo.landing_ref_name,f_path=c.readme_file)}">
                     ${c.readme_file}
                 </a>
             </div>
         </div>
         <div class="readme codeblock">
           <div class="readme_box">
             ${c.readme_data|n}
           </div>
         </div>
     </div>
     </div>
     %endif
 
 </div>

rhodecode/templates/summary/summary.mako

@@ -1,118 +1,118 b''
 <%inherit file="/summary/summary_base.mako"/>
 
 <%namespace name="components" file="/summary/components.mako"/>
 
 
 <%def name="menu_bar_subnav()">
     ${self.repo_menu(active='summary')}
 </%def>
 
 <%def name="main()">
 
 <div id="repo-summary" class="summary">
     ${components.summary_detail(breadcrumbs_links=self.breadcrumbs_links(), show_downloads=True)}
 </div><!--end repo-summary-->
 
 
 <div class="box">
         %if not c.repo_commits:
             <div class="empty-repo">
                 <div class="title">
                   <h3>${_('Quick start')}</h3>
                 </div>
                 <div class="clear-fix"></div>
             </div>
          %endif
         <div class="table">
             <div id="shortlog_data">
                 <%include file='summary_commits.mako'/>
             </div>
         </div>
 </div>
 
 %if c.readme_data:
 <div id="readme" class="anchor">
 <div class="box">
 
-    <div class="readme-title" title="${h.tooltip(_('Readme file from commit %s:%s') % (c.rhodecode_db_repo.landing_rev[0], c.rhodecode_db_repo.landing_rev[1]))}">
+    <div class="readme-title" title="${h.tooltip(_('Readme file from commit %s:%s') % (c.rhodecode_db_repo.landing_ref_type, c.rhodecode_db_repo.landing_ref_name))}">
         <div>
             <i class="icon-file-text"></i>
-            <a href="${h.route_path('repo_files',repo_name=c.repo_name,commit_id=c.rhodecode_db_repo.landing_rev[1],f_path=c.readme_file)}">
+            <a href="${h.route_path('repo_files',repo_name=c.repo_name,commit_id=c.rhodecode_db_repo.landing_ref_name,f_path=c.readme_file)}">
                 ${c.readme_file}
             </a>
         </div>
     </div>
     <div class="readme codeblock">
       <div class="readme_box">
         ${c.readme_data|n}
       </div>
     </div>
 </div>
 </div>
 %endif
 
 <script type="text/javascript">
 $(document).ready(function(){
 
     var showCloneField = function(clone_url_format){
         $.each(['http', 'http_id', 'ssh'], function (idx, val) {
             if(val === clone_url_format){
                 $('#clone_option_' + val).show();
                 $('#clone_option').val(val)
             } else {
                 $('#clone_option_' + val).hide();
             }
         });
     };
     // default taken from session
     showCloneField(templateContext.session_attrs.clone_url_format);
 
     $('#clone_option').on('change', function(e) {
         var selected = $(this).val();
 
         storeUserSessionAttr('rc_user_session_attr.clone_url_format', selected);
         showCloneField(selected)
     });
 
     var initialCommitData = {
         id: null,
         text: 'tip',
         type: 'tag',
         raw_id: null,
         files_url: null
     };
 
     select2RefSwitcher('#download_options', initialCommitData);
 
     // on change of download options
     $('#download_options').on('change', function(e) {
         // format of Object {text: "v0.0.3", type: "tag", id: "rev"}
         var ext = '.zip';
         var selected_cs = e.added;
         var fname = e.added.raw_id + ext;
         var href = pyroutes.url('repo_archivefile', {'repo_name': templateContext.repo_name, 'fname':fname});
         // set new label
         $('#archive_link').html('{0}{1}'.format(escapeHtml(e.added.text), ext));
 
         // set new url to button,
         $('#archive_link').attr('href', href)
     });
 
 
     // calculate size of repository
     calculateSize = function () {
 
         var callback = function (data) {
             % if c.show_stats:
                 showRepoStats('lang_stats', data);
             % endif
         };
 
         showRepoSize('repo_size_container', templateContext.repo_name, templateContext.repo_landing_commit, callback);
 
     }
 
 })
 </script>
 
 </%def>