u/ewong/rhodecode-enterprise-ce-fork Commit - r883:ae526446

frontend: wrap our legacy js code inside polymer element

ergo -

r883:ae526446 default

parent child

rhodecode/public/js/src/components/rhodecode-legacy-js/rhodecode-legacy-js.html

0 created 644 +7 0

@@ -0,0 +1,7 b''
	1	<link rel="import" href="../../../../../../bower_components/polymer/polymer.html">
	2	<dom-module id="rhodecode-legacy-js">
	3	<template>
	4	<script src="../../../scripts.js"></script>
	5	</template>
	6	<script src="rhodecode-legacy-js.js"></script>
	7	</dom-module>

rhodecode/public/js/src/components/rhodecode-legacy-js/rhodecode-legacy-js.js

0 created 644 +3 0

@@ -0,0 +1,3 b''
	1	Polymer({
	2	is: 'rhodecode-legacy-js',
	3	});

rhodecode/public/js/src/components/shared-components.html

0 +2 -1

             <!-- required for stamped out templates that might use common elements  -->
+            <link rel="import" href="rhodecode-legacy-js/rhodecode-legacy-js.html">
             <link rel="import" href="../../../../../bower_components/iron-ajax/iron-ajax.html">
             <link rel="import" href="shared-styles.html">
             <link rel="import" href="channelstream-connection/channelstream-connection.html">
             <link rel="import" href="rhodecode-toast/rhodecode-toast.html">
             <link rel="import" href="rhodecode-toggle/rhodecode-toggle.html">
             <link rel="import" href="rhodecode-unsafe-html/rhodecode-unsafe-html.html">
-            <link rel="import" href="rhodecode-app/rhodecode-app.html">
  No newline at end of file
+            <link rel="import" href="rhodecode-app/rhodecode-app.html">

rhodecode/templates/base/root.html

0 +1 -2

             ## -*- coding: utf-8 -*-
             <!DOCTYPE html>
             <%
             c.template_context['repo_name'] = getattr(c, 'repo_name', '')
             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]
             if getattr(c, 'rhodecode_user', None) and 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['visual']['default_renderer'] = h.get_visual_attr(c, 'default_renderer')
             %>
             <html xmlns="http://www.w3.org/1999/xhtml">
                 <head>
                     <script src="${h.asset('js/vendors/webcomponentsjs/webcomponents-lite.min.js', ver=c.rhodecode_version_hash)}"></script>
                     <link rel="import" href="${h.asset('js/rhodecode-components.html', ver=c.rhodecode_version_hash)}">
                     <title>${self.title()}</title>
                     <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
                     <%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" />
                     ## CSS definitions
                     <%def name="css()">
                         <link rel="stylesheet" type="text/css" href="${h.asset('css/style.css', ver=c.rhodecode_version_hash)}" media="screen"/>
                         <!--[if lt IE 9]>
                             <link rel="stylesheet" type="text/css" href="${h.asset('css/ie.css', ver=c.rhodecode_version_hash)}" media="screen"/>
                         <![endif]-->
                         ## 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>
                             // setup Polymer options
                             window.Polymer = {lazyRegister: true, dom: 'shadow'};
                             // Load webcomponentsjs polyfill if browser does not support native Web Components
                             (function() {
                                 'use strict';
                                 var onload = function() {
                                     // For native Imports, manually fire WebComponentsReady so user code
                                     // can use the same code path for native and polyfill'd imports.
                                     if (!window.HTMLImports) {
                                         document.dispatchEvent(
                                                 new CustomEvent('WebComponentsReady', {bubbles: true})
                                         );
                                     }
                                 };
                                 var webComponentsSupported = (
                                         'registerElement' in document
                                         && 'import' in document.createElement('link')
                                         && 'content' in document.createElement('template')
                                 );
                                 if (!webComponentsSupported) {
                                 } else {
                                     onload();
                                 }
                             })();
                         </script>
                         <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 REPO_NAME = "${getattr(c, 'repo_name', '')}";
                         %if hasattr(c, 'rhodecode_db_repo'):
                         var REPO_LANDING_REV = '${c.rhodecode_db_repo.landing_rev[1]}';
                         var REPO_TYPE = '${c.rhodecode_db_repo.repo_type}';
                         %else:
                         var REPO_LANDING_REV = '';
                         var REPO_TYPE = '';
                         %endif
                         var APPLICATION_URL = "${h.url('home').rstrip('/')}";
                         var ASSET_URL = "${h.asset('')}";
                         var DEFAULT_RENDERER = "${h.get_visual_attr(c, 'default_renderer')}";
                         var CSRF_TOKEN = "${getattr(c, 'csrf_token', '')}";
                         % if getattr(c, 'rhodecode_user', None):
                         var USER = {name:'${c.rhodecode_user.username}'};
                         % else:
                         var USER = {name:null};
                         % endif
                         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.html"/>
                         <!--[if lt IE 9]>
                         <script language="javascript" type="text/javascript" src="${h.asset('js/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()|n}; </script>
-                        <script language="javascript" type="text/javascript" src="${h.asset('js/scripts.js', ver=c.rhodecode_version_hash)}"></script>
                         ## avoide escaping the %N
+                        <script language="javascript" type="text/javascript" src="${h.asset('js/rhodecode-components.js', ver=c.rhodecode_version_hash)}"></script>
                         <script>CodeMirror.modeURL = "${h.asset('') + 'js/mode/%N/%N.js?ver='+c.rhodecode_version_hash}";</script>
-                        <script language="javascript" type="text/javascript" src="${h.asset('js/rhodecode-components.js', ver=c.rhodecode_version_hash)}"></script>
                         ## JAVASCRIPT EXTRA - optionally inject some extra JS for specificed templates
                         ${self.js_extra()}
                         <script type="text/javascript">
                         $(document).ready(function(){
                           show_more_event();
                           timeagoActivate();
                         })
                         </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>
                  ## IE hacks
                   <!--[if IE 7]>
                   <script>$(document.body).addClass('ie7')</script>
                   <![endif]-->
                   <!--[if IE 8]>
                   <script>$(document.body).addClass('ie8')</script>
                   <![endif]-->
                   <!--[if IE 9]>
                   <script>$(document.body).addClass('ie9')</script>
                   <![endif]-->
                   ${next.body()}
                   %if c.post_code:
                     ${c.post_code|n}
                   %endif
                 <rhodecode-app></rhodecode-app>
                 </body>
             </html>

rhodecode/tests/functional/test_home.py

0 +1 -1

             # -*- coding: utf-8 -*-
             # Copyright (C) 2010-2016  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 json
             from mock import patch
             import pytest
             from pylons import tmpl_context as c
             import rhodecode
             from rhodecode.lib.utils import map_groups
             from rhodecode.model.db import Repository, User, RepoGroup
             from rhodecode.model.meta import Session
             from rhodecode.model.repo import RepoModel
             from rhodecode.model.repo_group import RepoGroupModel
             from rhodecode.model.settings import SettingsModel
             from rhodecode.tests import TestController, url, TEST_USER_ADMIN_LOGIN
             from rhodecode.tests.fixture import Fixture
             fixture = Fixture()
             class TestHomeController(TestController):
                 def test_index(self):
                     self.log_user()
                     response = self.app.get(url(controller='home', action='index'))
                     # if global permission is set
                     response.mustcontain('Add Repository')
                     # search for objects inside the JavaScript JSON
                     for repo in Repository.getAll():
                         response.mustcontain('"name_raw": "%s"' % repo.repo_name)
                 def test_index_contains_statics_with_ver(self):
                     self.log_user()
                     response = self.app.get(url(controller='home', action='index'))
                     rhodecode_version_hash = c.rhodecode_version_hash
                     response.mustcontain('style.css?ver={0}'.format(rhodecode_version_hash))
-                    response.mustcontain('scripts.js?ver={0}'.format(rhodecode_version_hash))
+                    response.mustcontain('rhodecode-components.js?ver={0}'.format(rhodecode_version_hash))
                 def test_index_contains_backend_specific_details(self, backend):
                     self.log_user()
                     response = self.app.get(url(controller='home', action='index'))
                     tip = backend.repo.get_commit().raw_id
                     # html in javascript variable:
                     response.mustcontain(r'<i class=\"icon-%s\"' % (backend.alias, ))
                     response.mustcontain(r'href=\"/%s\"' % (backend.repo_name, ))
                     response.mustcontain("""/%s/changeset/%s""" % (backend.repo_name, tip))
                     response.mustcontain("""Added a symlink""")
                 def test_index_with_anonymous_access_disabled(self):
                     with fixture.anon_access(False):
                         response = self.app.get(url(controller='home', action='index'),
                                                 status=302)
                         assert 'login' in response.location
                 def test_index_page_on_groups(self, autologin_user, repo_group):
                     response = self.app.get(url('repo_group_home', group_name='gr1'))
                     response.mustcontain("gr1/repo_in_group")
                 def test_index_page_on_group_with_trailing_slash(
                         self, autologin_user, repo_group):
                     response = self.app.get(url('repo_group_home', group_name='gr1') + '/')
                     response.mustcontain("gr1/repo_in_group")
                 @pytest.fixture(scope='class')
                 def repo_group(self, request):
                     gr = fixture.create_repo_group('gr1')
                     fixture.create_repo(name='gr1/repo_in_group', repo_group=gr)
                     @request.addfinalizer
                     def cleanup():
                         RepoModel().delete('gr1/repo_in_group')
                         RepoGroupModel().delete(repo_group='gr1', force_delete=True)
                         Session().commit()
                 def test_index_with_name_with_tags(self, autologin_user):
                     user = User.get_by_username('test_admin')
                     user.name = '<img src="/image1" onload="alert(\'Hello, World!\');">'
                     user.lastname = (
                         '<img src="/image2" onload="alert(\'Hello, World!\');">')
                     Session().add(user)
                     Session().commit()
                     response = self.app.get(url(controller='home', action='index'))
                     response.mustcontain(
                         '&lt;img src=&#34;/image1&#34; onload=&#34;'
                         'alert(&#39;Hello, World!&#39;);&#34;&gt;')
                     response.mustcontain(
                         '&lt;img src=&#34;/image2&#34; onload=&#34;'
                         'alert(&#39;Hello, World!&#39;);&#34;&gt;')
                 @pytest.mark.parametrize("name, state", [
                     ('Disabled', False),
                     ('Enabled', True),
                 ])
                 def test_index_show_version(self, autologin_user, name, state):
                     version_string = 'RhodeCode Enterprise %s' % rhodecode.__version__
                     sett = SettingsModel().create_or_update_setting(
                         'show_version', state, 'bool')
                     Session().add(sett)
                     Session().commit()
                     SettingsModel().invalidate_settings_cache()
                     response = self.app.get(url(controller='home', action='index'))
                     if state is True:
                         response.mustcontain(version_string)
                     if state is False:
                         response.mustcontain(no=[version_string])
             class TestUserAutocompleteData(TestController):
                 def test_returns_list_of_users(self, user_util):
                     self.log_user()
                     user = user_util.create_user(is_active=True)
                     user_name = user.username
                     response = self.app.get(
                         url(controller='home', action='user_autocomplete_data'),
                         headers={'X-REQUESTED-WITH': 'XMLHttpRequest', }, status=200)
                     result = json.loads(response.body)
                     values = [suggestion['value'] for suggestion in result['suggestions']]
                     assert user_name in values
                 def test_returns_inactive_users_when_active_flag_sent(self, user_util):
                     self.log_user()
                     user = user_util.create_user(is_active=False)
                     user_name = user.username
                     response = self.app.get(
                         url(controller='home', action='user_autocomplete_data',
                             user_groups='true', active='0'),
                         headers={'X-REQUESTED-WITH': 'XMLHttpRequest', }, status=200)
                     result = json.loads(response.body)
                     values = [suggestion['value'] for suggestion in result['suggestions']]
                     assert user_name in values
                 def test_returns_groups_when_user_groups_sent(self, user_util):
                     self.log_user()
                     group = user_util.create_user_group(user_groups_active=True)
                     group_name = group.users_group_name
                     response = self.app.get(
                         url(controller='home', action='user_autocomplete_data',
                             user_groups='true'),
                         headers={'X-REQUESTED-WITH': 'XMLHttpRequest', }, status=200)
                     result = json.loads(response.body)
                     values = [suggestion['value'] for suggestion in result['suggestions']]
                     assert group_name in values
                 def test_result_is_limited_when_query_is_sent(self):
                     self.log_user()
                     fake_result = [
                         {
                             'first_name': 'John',
                             'value_display': 'hello{} (John Smith)'.format(i),
                             'icon_link': '/images/user14.png',
                             'value': 'hello{}'.format(i),
                             'last_name': 'Smith',
                             'username': 'hello{}'.format(i),
                             'id': i,
                             'value_type': u'user'
                         }
                         for i in range(10)
                     ]
                     users_patcher = patch.object(
                         RepoModel, 'get_users', return_value=fake_result)
                     groups_patcher = patch.object(
                         RepoModel, 'get_user_groups', return_value=fake_result)
                     query = 'hello'
                     with users_patcher as users_mock, groups_patcher as groups_mock:
                         response = self.app.get(
                             url(controller='home', action='user_autocomplete_data',
                                 user_groups='true', query=query),
                             headers={'X-REQUESTED-WITH': 'XMLHttpRequest', }, status=200)
                     result = json.loads(response.body)
                     users_mock.assert_called_once_with(
                         name_contains=query, only_active=True)
                     groups_mock.assert_called_once_with(
                         name_contains=query, only_active=True)
                     assert len(result['suggestions']) == 20
             def assert_and_get_content(result):
                 repos = []
                 groups = []
                 commits = []
                 for data in result:
                     for data_item in data['children']:
                         assert data_item['id']
                         assert data_item['text']
                         assert data_item['url']
                         if data_item['type'] == 'repo':
                             repos.append(data_item)
                         elif data_item['type'] == 'group':
                             groups.append(data_item)
                         elif data_item['type'] == 'commit':
                             commits.append(data_item)
                         else:
                             raise Exception('invalid type %s' % data_item['type'])
                 return repos, groups, commits
             class TestGotoSwitcherData(TestController):
                 required_repos_with_groups = [
                     'abc',
                     'abc-fork',
                     'forks/abcd',
                     'abcd',
                     'abcde',
                     'a/abc',
                     'aa/abc',
                     'aaa/abc',
                     'aaaa/abc',
                     'repos_abc/aaa/abc',
                     'abc_repos/abc',
                     'abc_repos/abcd',
                     'xxx/xyz',
                     'forked-abc/a/abc'
                 ]
                 @pytest.fixture(autouse=True, scope='class')
                 def prepare(self, request, pylonsapp):
                     for repo_and_group in self.required_repos_with_groups:
                         # create structure of groups and return the last group
                         repo_group = map_groups(repo_and_group)
                         RepoModel()._create_repo(
                             repo_and_group, 'hg', 'test-ac', TEST_USER_ADMIN_LOGIN,
                             repo_group=getattr(repo_group, 'group_id', None))
                         Session().commit()
                     request.addfinalizer(self.cleanup)
                 def cleanup(self):
                     # first delete all repos
                     for repo_and_groups in self.required_repos_with_groups:
                         repo = Repository.get_by_repo_name(repo_and_groups)
                         if repo:
                             RepoModel().delete(repo)
                             Session().commit()
                     # then delete all empty groups
                     for repo_and_groups in self.required_repos_with_groups:
                         if '/' in repo_and_groups:
                             r_group = repo_and_groups.rsplit('/', 1)[0]
                             repo_group = RepoGroup.get_by_group_name(r_group)
                             if not repo_group:
                                 continue
                             parents = repo_group.parents
                             RepoGroupModel().delete(repo_group, force_delete=True)
                             Session().commit()
                             for el in reversed(parents):
                                 RepoGroupModel().delete(el, force_delete=True)
                                 Session().commit()
                 def test_returns_list_of_repos_and_groups(self):
                     self.log_user()
                     response = self.app.get(
                         url(controller='home', action='goto_switcher_data'),
                         headers={'X-REQUESTED-WITH': 'XMLHttpRequest', }, status=200)
                     result = json.loads(response.body)['results']
                     repos, groups, commits = assert_and_get_content(result)
                     assert len(repos) == len(Repository.get_all())
                     assert len(groups) == len(RepoGroup.get_all())
                     assert len(commits) == 0
                 def test_returns_list_of_repos_and_groups_filtered(self):
                     self.log_user()
                     response = self.app.get(
                         url(controller='home', action='goto_switcher_data'),
                         headers={'X-REQUESTED-WITH': 'XMLHttpRequest', },
                         params={'query': 'abc'}, status=200)
                     result = json.loads(response.body)['results']
                     repos, groups, commits = assert_and_get_content(result)
                     assert len(repos) == 13
                     assert len(groups) == 5
                     assert len(commits) == 0
                 def test_returns_list_of_properly_sorted_and_filtered(self):
                     self.log_user()
                     response = self.app.get(
                         url(controller='home', action='goto_switcher_data'),
                         headers={'X-REQUESTED-WITH': 'XMLHttpRequest', },
                         params={'query': 'abc'}, status=200)
                     result = json.loads(response.body)['results']
                     repos, groups, commits = assert_and_get_content(result)
                     test_repos = [x['text'] for x in repos[:4]]
                     assert ['abc', 'abcd', 'a/abc', 'abcde'] == test_repos
                     test_groups = [x['text'] for x in groups[:4]]
                     assert ['abc_repos', 'repos_abc',
                             'forked-abc', 'forked-abc/a'] == test_groups
             class TestRepoListData(TestController):
                 def test_returns_list_of_repos_and_groups(self, user_util):
                     self.log_user()
                     response = self.app.get(
                         url(controller='home', action='repo_list_data'),
                         headers={'X-REQUESTED-WITH': 'XMLHttpRequest', }, status=200)
                     result = json.loads(response.body)['results']
                     repos, groups, commits = assert_and_get_content(result)
                     assert len(repos) == len(Repository.get_all())
                     assert len(groups) == 0
                     assert len(commits) == 0
                 def test_returns_list_of_repos_and_groups_filtered(self):
                     self.log_user()
                     response = self.app.get(
                         url(controller='home', action='repo_list_data'),
                         headers={'X-REQUESTED-WITH': 'XMLHttpRequest', },
                         params={'query': 'vcs_test_git'}, status=200)
                     result = json.loads(response.body)['results']
                     repos, groups, commits = assert_and_get_content(result)
                     assert len(repos) == len(Repository.query().filter(
                         Repository.repo_name.ilike('%vcs_test_git%')).all())
                     assert len(groups) == 0
                     assert len(commits) == 0
                 def test_returns_list_of_repos_and_groups_filtered_with_type(self):
                     self.log_user()
                     response = self.app.get(
                         url(controller='home', action='repo_list_data'),
                         headers={'X-REQUESTED-WITH': 'XMLHttpRequest', },
                         params={'query': 'vcs_test_git', 'repo_type': 'git'}, status=200)
                     result = json.loads(response.body)['results']
                     repos, groups, commits = assert_and_get_content(result)
                     assert len(repos) == len(Repository.query().filter(
                         Repository.repo_name.ilike('%vcs_test_git%')).all())
                     assert len(groups) == 0
                     assert len(commits) == 0
                 def test_returns_list_of_repos_non_ascii_query(self):
                     self.log_user()
                     response = self.app.get(
                         url(controller='home', action='repo_list_data'),
                         headers={'X-REQUESTED-WITH': 'XMLHttpRequest', },
                         params={'query': 'ć_vcs_test_ą', 'repo_type': 'git'}, status=200)
                     result = json.loads(response.body)['results']
                     repos, groups, commits = assert_and_get_content(result)
                     assert len(repos) == 0
                     assert len(groups) == 0
                     assert len(commits) == 0

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	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

	Repositories
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
t s	Toggle sidebar on some pages