whitespace cleanup

rhodecode/controllers/admin/repos_groups.py

@@ -1,366 +1,366 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.admin.repos_groups
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Repositories groups controller for RhodeCode
 
     :created_on: Mar 23, 2010
     :author: marcink
     :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import logging
 import traceback
 import formencode
 
 from formencode import htmlfill
 
 from pylons import request, tmpl_context as c, url
 from pylons.controllers.util import redirect
 from pylons.i18n.translation import _
 
 from sqlalchemy.exc import IntegrityError
 
 import rhodecode
 from rhodecode.lib import helpers as h
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.auth import LoginRequired, HasPermissionAnyDecorator,\
     HasReposGroupPermissionAnyDecorator
 from rhodecode.lib.base import BaseController, render
 from rhodecode.model.db import RepoGroup, Repository
 from rhodecode.model.repos_group import ReposGroupModel
 from rhodecode.model.forms import ReposGroupForm
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from webob.exc import HTTPInternalServerError, HTTPNotFound
 from rhodecode.lib.utils2 import str2bool
 from sqlalchemy.sql.expression import func
 
 log = logging.getLogger(__name__)
 
 
 class ReposGroupsController(BaseController):
     """REST Controller styled on the Atom Publishing Protocol"""
     # To properly map this controller, ensure your config/routing.py
     # file has a resource setup:
     #     map.resource('repos_group', 'repos_groups')
 
     @LoginRequired()
     def __before__(self):
         super(ReposGroupsController, self).__before__()
 
     def __load_defaults(self):
         c.repo_groups = RepoGroup.groups_choices()
         c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
 
         repo_model = RepoModel()
         c.users_array = repo_model.get_users_js()
         c.users_groups_array = repo_model.get_users_groups_js()
 
     def __load_data(self, group_id):
         """
         Load defaults settings for edit, and update
 
         :param group_id:
         """
         self.__load_defaults()
         repo_group = RepoGroup.get_or_404(group_id)
         data = repo_group.get_dict()
         data['group_name'] = repo_group.name
 
         # fill repository users
         for p in repo_group.repo_group_to_perm:
             data.update({'u_perm_%s' % p.user.username:
                              p.permission.permission_name})
 
         # fill repository groups
         for p in repo_group.users_group_to_perm:
             data.update({'g_perm_%s' % p.users_group.users_group_name:
                              p.permission.permission_name})
 
         return data
 
     @HasPermissionAnyDecorator('hg.admin')
     def index(self, format='html'):
         """GET /repos_groups: All items in the collection"""
         # url('repos_groups')
         sk = lambda g: g.parents[0].group_name if g.parents else g.group_name
         c.groups = sorted(RepoGroup.query().all(), key=sk)
         return render('admin/repos_groups/repos_groups_show.html')
 
     @HasPermissionAnyDecorator('hg.admin')
     def create(self):
         """POST /repos_groups: Create a new item"""
         # url('repos_groups')
         self.__load_defaults()
         repos_group_form = ReposGroupForm(available_groups =
                                           c.repo_groups_choices)()
         try:
             form_result = repos_group_form.to_python(dict(request.POST))
             ReposGroupModel().create(
                     group_name=form_result['group_name'],
                     group_description=form_result['group_description'],
                     parent=form_result['group_parent_id']
             )
             Session().commit()
             h.flash(_('created repos group %s') \
                     % form_result['group_name'], category='success')
             #TODO: in futureaction_logger(, '', '', '', self.sa)
         except formencode.Invalid, errors:
 
             return htmlfill.render(
                 render('admin/repos_groups/repos_groups_add.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8")
         except Exception:
             log.error(traceback.format_exc())
             h.flash(_('error occurred during creation of repos group %s') \
                     % request.POST.get('group_name'), category='error')
 
         return redirect(url('repos_groups'))
 
     @HasPermissionAnyDecorator('hg.admin')
     def new(self, format='html'):
         """GET /repos_groups/new: Form to create a new item"""
         # url('new_repos_group')
         self.__load_defaults()
         return render('admin/repos_groups/repos_groups_add.html')
 
     @HasPermissionAnyDecorator('hg.admin')
     def update(self, id):
         """PUT /repos_groups/id: Update an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="PUT" />
         # Or using helpers:
         #    h.form(url('repos_group', id=ID),
         #           method='put')
         # url('repos_group', id=ID)
 
         self.__load_defaults()
         c.repos_group = RepoGroup.get(id)
 
         repos_group_form = ReposGroupForm(
             edit=True,
             old_data=c.repos_group.get_dict(),
             available_groups=c.repo_groups_choices
         )()
         try:
             form_result = repos_group_form.to_python(dict(request.POST))
             ReposGroupModel().update(id, form_result)
             Session().commit()
             h.flash(_('updated repos group %s') \
                     % form_result['group_name'], category='success')
             #TODO: in future action_logger(, '', '', '', self.sa)
         except formencode.Invalid, errors:
 
             return htmlfill.render(
                 render('admin/repos_groups/repos_groups_edit.html'),
                 defaults=errors.value,
                 errors=errors.error_dict or {},
                 prefix_error=False,
                 encoding="UTF-8")
         except Exception:
             log.error(traceback.format_exc())
             h.flash(_('error occurred during update of repos group %s') \
                     % request.POST.get('group_name'), category='error')
 
         return redirect(url('edit_repos_group', id=id))
 
     @HasPermissionAnyDecorator('hg.admin')
     def delete(self, id):
         """DELETE /repos_groups/id: Delete an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="DELETE" />
         # Or using helpers:
         #    h.form(url('repos_group', id=ID),
         #           method='delete')
         # url('repos_group', id=ID)
 
         gr = RepoGroup.get(id)
         repos = gr.repositories.all()
         if repos:
             h.flash(_('This group contains %s repositores and cannot be '
                       'deleted') % len(repos),
                     category='error')
             return redirect(url('repos_groups'))
 
         try:
             ReposGroupModel().delete(id)
             Session().commit()
             h.flash(_('removed repos group %s') % gr.group_name,
                     category='success')
             #TODO: in future action_logger(, '', '', '', self.sa)
         except IntegrityError, e:
             if str(e.message).find('groups_group_parent_id_fkey') != -1:
                 log.error(traceback.format_exc())
                 h.flash(_('Cannot delete this group it still contains '
                           'subgroups'),
                         category='warning')
             else:
                 log.error(traceback.format_exc())
                 h.flash(_('error occurred during deletion of repos '
                           'group %s') % gr.group_name, category='error')
 
         except Exception:
             log.error(traceback.format_exc())
             h.flash(_('error occurred during deletion of repos '
                       'group %s') % gr.group_name, category='error')
 
         return redirect(url('repos_groups'))
 
     @HasReposGroupPermissionAnyDecorator('group.admin')
     def delete_repos_group_user_perm(self, group_name):
         """
         DELETE an existing repositories group permission user
 
         :param group_name:
         """
         try:
             recursive = str2bool(request.POST.get('recursive', False))
             ReposGroupModel().delete_permission(
                 repos_group=group_name, obj=request.POST['user_id'],
                 obj_type='user', recursive=recursive
             )
             Session().commit()
         except Exception:
             log.error(traceback.format_exc())
             h.flash(_('An error occurred during deletion of group user'),
                     category='error')
             raise HTTPInternalServerError()
 
     @HasReposGroupPermissionAnyDecorator('group.admin')
     def delete_repos_group_users_group_perm(self, group_name):
         """
         DELETE an existing repositories group permission users group
 
         :param group_name:
         """
 
         try:
             recursive = str2bool(request.POST.get('recursive', False))
             ReposGroupModel().delete_permission(
                 repos_group=group_name, obj=request.POST['users_group_id'],
                 obj_type='users_group', recursive=recursive
             )
             Session().commit()
         except Exception:
             log.error(traceback.format_exc())
             h.flash(_('An error occurred during deletion of group'
                       ' users groups'),
                     category='error')
             raise HTTPInternalServerError()
 
     def show_by_name(self, group_name):
         """
         This is a proxy that does a lookup group_name -> id, and shows
         the group by id view instead
         """
         group_name = group_name.rstrip('/')
         id_ = RepoGroup.get_by_group_name(group_name)
         if id_:
             return self.show(id_.group_id)
         raise HTTPNotFound
 
     @HasReposGroupPermissionAnyDecorator('group.read', 'group.write',
                                          'group.admin')
     def show(self, id, format='html'):
         """GET /repos_groups/id: Show a specific item"""
         # url('repos_group', id=ID)
 
         c.group = RepoGroup.get_or_404(id)
         c.group_repos = c.group.repositories.all()
 
         #overwrite our cached list with current filter
         gr_filter = c.group_repos
         c.repo_cnt = 0
 
         groups = RepoGroup.query().order_by(RepoGroup.group_name)\
             .filter(RepoGroup.group_parent_id == id).all()
         c.groups = self.scm_model.get_repos_groups(groups)
 
         if c.visual.lightweight_dashboard is False:
             c.cached_repo_list = self.scm_model.get_repos(all_repos=gr_filter)
 
             c.repos_list = c.cached_repo_list
         ## lightweight version of dashboard
         else:
             c.repos_list = Repository.query()\
                             .filter(Repository.group_id == id)\
                             .order_by(func.lower(Repository.repo_name))\
                             .all()
             repos_data = []
             total_records = len(c.repos_list)
 
             _tmpl_lookup = rhodecode.CONFIG['pylons.app_globals'].mako_lookup
             template = _tmpl_lookup.get_template('data_table/_dt_elements.html')
 
             quick_menu = lambda repo_name: (template.get_def("quick_menu")
                                             .render(repo_name, _=_, h=h, c=c))
             repo_lnk = lambda name, rtype, private, fork_of: (
                 template.get_def("repo_name")
                 .render(name, rtype, private, fork_of, short_name=False,
                         admin=False, _=_, h=h, c=c))
             last_change = lambda last_change:  (template.get_def("last_change")
                                            .render(last_change, _=_, h=h, c=c))
             rss_lnk = lambda repo_name: (template.get_def("rss")
                                            .render(repo_name, _=_, h=h, c=c))
             atom_lnk = lambda repo_name: (template.get_def("atom")
                                            .render(repo_name, _=_, h=h, c=c))
 
             for repo in c.repos_list:
                 repos_data.append({
                     "menu": quick_menu(repo.repo_name),
                     "raw_name": repo.repo_name.lower(),
                     "name": repo_lnk(repo.repo_name, repo.repo_type,
                                      repo.private, repo.fork),
                     "last_change": last_change(repo.last_db_change),
                     "desc": repo.description,
                     "owner": h.person(repo.user.username),
                     "rss": rss_lnk(repo.repo_name),
                     "atom": atom_lnk(repo.repo_name),
                 })
 
             c.data = json.dumps({
                 "totalRecords": total_records,
                 "startIndex": 0,
                 "sort": "name",
                 "dir": "asc",
                 "records": repos_data
-            })        
-        
+            })
+
         return render('admin/repos_groups/repos_groups.html')
 
     @HasPermissionAnyDecorator('hg.admin')
     def edit(self, id, format='html'):
         """GET /repos_groups/id/edit: Form to edit an existing item"""
         # url('edit_repos_group', id=ID)
 
         c.repos_group = ReposGroupModel()._get_repos_group(id)
         defaults = self.__load_data(c.repos_group.group_id)
 
         # we need to exclude this group from the group list for editing
         c.repo_groups = filter(lambda x: x[0] != c.repos_group.group_id,
                                c.repo_groups)
 
         return htmlfill.render(
             render('admin/repos_groups/repos_groups_edit.html'),
             defaults=defaults,
             encoding="UTF-8",
             force_defaults=False
         )

rhodecode/controllers/files.py

@@ -1,545 +1,545 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.files
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     Files controller for RhodeCode
 
     :created_on: Apr 21, 2010
     :author: marcink
     :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 from __future__ import with_statement
 import os
 import logging
 import traceback
 import tempfile
 
 from pylons import request, response, tmpl_context as c, url
 from pylons.i18n.translation import _
 from pylons.controllers.util import redirect
 from pylons.decorators import jsonify
 
 from rhodecode.lib import diffs
 from rhodecode.lib import helpers as h
 
 from rhodecode.lib.compat import OrderedDict
 from rhodecode.lib.utils2 import convert_line_endings, detect_mode, safe_str,\
     str2bool
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.vcs.backends.base import EmptyChangeset
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.exceptions import RepositoryError, \
     ChangesetDoesNotExistError, EmptyRepositoryError, \
     ImproperArchiveTypeError, VCSError, NodeAlreadyExistsError
 from rhodecode.lib.vcs.nodes import FileNode
 
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.db import Repository
 
 from rhodecode.controllers.changeset import anchor_url, _ignorews_url,\
     _context_url, get_line_ctx, get_ignore_ws
 
 
 log = logging.getLogger(__name__)
 
 
 class FilesController(BaseRepoController):
 
     def __before__(self):
         super(FilesController, self).__before__()
         c.cut_off_limit = self.cut_off_limit
 
     def __get_cs_or_redirect(self, rev, repo_name, redirect_after=True):
         """
         Safe way to get changeset if error occur it redirects to tip with
         proper message
 
         :param rev: revision to fetch
         :param repo_name: repo name to redirect after
         """
 
         try:
             return c.rhodecode_repo.get_changeset(rev)
         except EmptyRepositoryError, e:
             if not redirect_after:
                 return None
             url_ = url('files_add_home',
                        repo_name=c.repo_name,
                        revision=0, f_path='')
             add_new = '<a href="%s">[%s]</a>' % (url_, _('click here to add new file'))
             h.flash(h.literal(_('There are no files yet %s') % add_new),
                     category='warning')
             redirect(h.url('summary_home', repo_name=repo_name))
 
         except RepositoryError, e:
             h.flash(str(e), category='warning')
             redirect(h.url('files_home', repo_name=repo_name, revision='tip'))
 
     def __get_filenode_or_redirect(self, repo_name, cs, path):
         """
         Returns file_node, if error occurs or given path is directory,
         it'll redirect to top level path
 
         :param repo_name: repo_name
         :param cs: given changeset
         :param path: path to lookup
         """
 
         try:
             file_node = cs.get_node(path)
             if file_node.is_dir():
                 raise RepositoryError('given path is a directory')
         except RepositoryError, e:
             h.flash(str(e), category='warning')
             redirect(h.url('files_home', repo_name=repo_name,
                            revision=cs.raw_id))
 
         return file_node
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def index(self, repo_name, revision, f_path, annotate=False):
         # redirect to given revision from form if given
         post_revision = request.POST.get('at_rev', None)
         if post_revision:
             cs = self.__get_cs_or_redirect(post_revision, repo_name)
             redirect(url('files_home', repo_name=c.repo_name,
                          revision=cs.raw_id, f_path=f_path))
 
         c.changeset = self.__get_cs_or_redirect(revision, repo_name)
         c.branch = request.GET.get('branch', None)
         c.f_path = f_path
         c.annotate = annotate
         cur_rev = c.changeset.revision
 
         # prev link
         try:
             prev_rev = c.rhodecode_repo.get_changeset(cur_rev).prev(c.branch)
             c.url_prev = url('files_home', repo_name=c.repo_name,
                          revision=prev_rev.raw_id, f_path=f_path)
             if c.branch:
                 c.url_prev += '?branch=%s' % c.branch
         except (ChangesetDoesNotExistError, VCSError):
             c.url_prev = '#'
 
         # next link
         try:
             next_rev = c.rhodecode_repo.get_changeset(cur_rev).next(c.branch)
             c.url_next = url('files_home', repo_name=c.repo_name,
                      revision=next_rev.raw_id, f_path=f_path)
             if c.branch:
                 c.url_next += '?branch=%s' % c.branch
         except (ChangesetDoesNotExistError, VCSError):
             c.url_next = '#'
 
         # files or dirs
         try:
             c.file = c.changeset.get_node(f_path)
 
             if c.file.is_file():
                 _hist = c.rhodecode_repo.get_changeset().get_file_history(f_path)
                 c.file_changeset = c.changeset
                 if _hist:
-                    c.file_changeset = (c.changeset 
+                    c.file_changeset = (c.changeset
                                         if c.changeset.revision < _hist[0].revision
                                         else _hist[0])
                 c.file_history = self._get_node_history(None, f_path, _hist)
                 c.authors = []
                 for a in set([x.author for x in _hist]):
                     c.authors.append((h.email(a), h.person(a)))
             else:
                 c.authors = c.file_history = []
         except RepositoryError, e:
             h.flash(str(e), category='warning')
             redirect(h.url('files_home', repo_name=repo_name,
                            revision='tip'))
 
         if request.environ.get('HTTP_X_PARTIAL_XHR'):
             return render('files/files_ypjax.html')
 
         return render('files/files.html')
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def rawfile(self, repo_name, revision, f_path):
         cs = self.__get_cs_or_redirect(revision, repo_name)
         file_node = self.__get_filenode_or_redirect(repo_name, cs, f_path)
 
         response.content_disposition = 'attachment; filename=%s' % \
             safe_str(f_path.split(Repository.url_sep())[-1])
 
         response.content_type = file_node.mimetype
         return file_node.content
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def raw(self, repo_name, revision, f_path):
         cs = self.__get_cs_or_redirect(revision, repo_name)
         file_node = self.__get_filenode_or_redirect(repo_name, cs, 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:
             'image/x-icon': ('image/x-icon', 'inline'),
             'image/png': ('image/png', 'inline'),
             'image/gif': ('image/gif', 'inline'),
             'image/jpeg': ('image/jpeg', 'inline'),
             'image/svg+xml': ('image/svg+xml', 'inline'),
         }
 
         mimetype = file_node.mimetype
         try:
             mimetype, dispo = 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, dispo = '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, dispo = 'text/plain', 'inline'
 
         if dispo == 'attachment':
             dispo = 'attachment; filename=%s' % \
                         safe_str(f_path.split(os.sep)[-1])
 
         response.content_disposition = dispo
         response.content_type = mimetype
         return file_node.content
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     def edit(self, repo_name, revision, f_path):
         repo = Repository.get_by_repo_name(repo_name)
         if repo.enable_locking and repo.locked[0]:
             h.flash(_('This repository is has been locked by %s on %s')
                 % (h.person_by_id(repo.locked[0]),
                    h.fmt_date(h.time_to_datetime(repo.locked[1]))),
                   'warning')
             return redirect(h.url('files_home',
                                   repo_name=repo_name, revision='tip'))
 
         r_post = request.POST
 
         c.cs = self.__get_cs_or_redirect(revision, repo_name)
         c.file = self.__get_filenode_or_redirect(repo_name, c.cs, f_path)
 
         if c.file.is_binary:
             return redirect(url('files_home', repo_name=c.repo_name,
                          revision=c.cs.raw_id, f_path=f_path))
 
         c.f_path = f_path
 
         if r_post:
 
             old_content = c.file.content
             sl = old_content.splitlines(1)
             first_line = sl[0] if sl else ''
             # modes:  0 - Unix, 1 - Mac, 2 - DOS
             mode = detect_mode(first_line, 0)
             content = convert_line_endings(r_post.get('content'), mode)
 
             message = r_post.get('message') or (_('Edited %s via RhodeCode')
                                                 % (f_path))
             author = self.rhodecode_user.full_contact
 
             if content == old_content:
                 h.flash(_('No changes'),
                     category='warning')
                 return redirect(url('changeset_home', repo_name=c.repo_name,
                                     revision='tip'))
 
             try:
                 self.scm_model.commit_change(repo=c.rhodecode_repo,
                                              repo_name=repo_name, cs=c.cs,
                                              user=self.rhodecode_user,
                                              author=author, message=message,
                                              content=content, f_path=f_path)
                 h.flash(_('Successfully committed to %s') % f_path,
                         category='success')
 
             except Exception:
                 log.error(traceback.format_exc())
                 h.flash(_('Error occurred during commit'), category='error')
             return redirect(url('changeset_home',
                                 repo_name=c.repo_name, revision='tip'))
 
         return render('files/files_edit.html')
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.write', 'repository.admin')
     def add(self, repo_name, revision, f_path):
 
         repo = Repository.get_by_repo_name(repo_name)
         if repo.enable_locking and repo.locked[0]:
             h.flash(_('This repository is has been locked by %s on %s')
                 % (h.person_by_id(repo.locked[0]),
                    h.fmt_date(h.time_to_datetime(repo.locked[1]))),
                   'warning')
             return redirect(h.url('files_home',
                                   repo_name=repo_name, revision='tip'))
 
         r_post = request.POST
         c.cs = self.__get_cs_or_redirect(revision, repo_name,
                                          redirect_after=False)
         if c.cs is None:
             c.cs = EmptyChangeset(alias=c.rhodecode_repo.alias)
 
         c.f_path = f_path
 
         if r_post:
             unix_mode = 0
             content = convert_line_endings(r_post.get('content'), unix_mode)
 
             message = r_post.get('message') or (_('Added %s via RhodeCode')
                                                 % (f_path))
             location = r_post.get('location')
             filename = r_post.get('filename')
             file_obj = r_post.get('upload_file', None)
 
             if file_obj is not None and hasattr(file_obj, 'filename'):
                 filename = file_obj.filename
                 content = file_obj.file
 
             node_path = os.path.join(location, filename)
             author = self.rhodecode_user.full_contact
 
             if not content:
                 h.flash(_('No content'), category='warning')
                 return redirect(url('changeset_home', repo_name=c.repo_name,
                                     revision='tip'))
             if not filename:
                 h.flash(_('No filename'), category='warning')
                 return redirect(url('changeset_home', repo_name=c.repo_name,
                                     revision='tip'))
 
             try:
                 self.scm_model.create_node(repo=c.rhodecode_repo,
                                            repo_name=repo_name, cs=c.cs,
                                            user=self.rhodecode_user,
                                            author=author, message=message,
                                            content=content, f_path=node_path)
                 h.flash(_('Successfully committed to %s') % node_path,
                         category='success')
             except NodeAlreadyExistsError, e:
                 h.flash(_(e), category='error')
             except Exception:
                 log.error(traceback.format_exc())
                 h.flash(_('Error occurred during commit'), category='error')
             return redirect(url('changeset_home',
                                 repo_name=c.repo_name, revision='tip'))
 
         return render('files/files_add.html')
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def archivefile(self, repo_name, fname):
 
         fileformat = None
         revision = None
         ext = None
         subrepos = request.GET.get('subrepos') == 'true'
 
         for a_type, ext_data in settings.ARCHIVE_SPECS.items():
             archive_spec = fname.split(ext_data[1])
             if len(archive_spec) == 2 and archive_spec[1] == '':
                 fileformat = a_type or ext_data[1]
                 revision = archive_spec[0]
                 ext = ext_data[1]
 
         try:
             dbrepo = RepoModel().get_by_repo_name(repo_name)
             if dbrepo.enable_downloads is False:
                 return _('downloads disabled')
 
             if c.rhodecode_repo.alias == 'hg':
                 # patch and reset hooks section of UI config to not run any
                 # hooks on fetching archives with subrepos
                 for k, v in c.rhodecode_repo._repo.ui.configitems('hooks'):
                     c.rhodecode_repo._repo.ui.setconfig('hooks', k, None)
 
             cs = c.rhodecode_repo.get_changeset(revision)
             content_type = settings.ARCHIVE_SPECS[fileformat][0]
         except ChangesetDoesNotExistError:
             return _('Unknown revision %s') % revision
         except EmptyRepositoryError:
             return _('Empty repository')
         except (ImproperArchiveTypeError, KeyError):
             return _('Unknown archive type')
 
         fd, archive = tempfile.mkstemp()
         t = open(archive, 'wb')
         cs.fill_archive(stream=t, kind=fileformat, subrepos=subrepos)
         t.close()
 
         def get_chunked_archive(archive):
             stream = open(archive, 'rb')
             while True:
                 data = stream.read(16 * 1024)
                 if not data:
                     stream.close()
                     os.close(fd)
                     os.remove(archive)
                     break
                 yield data
 
         response.content_disposition = str('attachment; filename=%s-%s%s' \
                                            % (repo_name, revision[:12], ext))
         response.content_type = str(content_type)
         return get_chunked_archive(archive)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def diff(self, repo_name, f_path):
         ignore_whitespace = request.GET.get('ignorews') == '1'
         line_context = request.GET.get('context', 3)
         diff1 = request.GET.get('diff1', '')
         diff2 = request.GET.get('diff2', '')
         c.action = request.GET.get('diff')
         c.no_changes = diff1 == diff2
         c.f_path = f_path
         c.big_diff = False
         c.anchor_url = anchor_url
         c.ignorews_url = _ignorews_url
         c.context_url = _context_url
         c.changes = OrderedDict()
         c.changes[diff2] = []
 
         #special case if we want a show rev only, it's impl here
         #to reduce JS and callbacks
         if request.GET.get('show_rev'):
             if str2bool(request.GET.get('annotate', 'False')):
                 _url = url('files_annotate_home', repo_name=c.repo_name,
                            revision=diff1, f_path=c.f_path)
             else:
                 _url = url('files_home', repo_name=c.repo_name,
                            revision=diff1, f_path=c.f_path)
 
             return redirect(_url)
         try:
             if diff1 not in ['', None, 'None', '0' * 12, '0' * 40]:
                 c.changeset_1 = c.rhodecode_repo.get_changeset(diff1)
                 node1 = c.changeset_1.get_node(f_path)
             else:
                 c.changeset_1 = EmptyChangeset(repo=c.rhodecode_repo)
                 node1 = FileNode('.', '', changeset=c.changeset_1)
 
             if diff2 not in ['', None, 'None', '0' * 12, '0' * 40]:
                 c.changeset_2 = c.rhodecode_repo.get_changeset(diff2)
                 node2 = c.changeset_2.get_node(f_path)
             else:
                 c.changeset_2 = EmptyChangeset(repo=c.rhodecode_repo)
                 node2 = FileNode('.', '', changeset=c.changeset_2)
         except RepositoryError:
             return redirect(url('files_home', repo_name=c.repo_name,
                                 f_path=f_path))
 
         if c.action == 'download':
             _diff = diffs.get_gitdiff(node1, node2,
                                       ignore_whitespace=ignore_whitespace,
                                       context=line_context)
             diff = diffs.DiffProcessor(_diff, format='gitdiff')
 
             diff_name = '%s_vs_%s.diff' % (diff1, diff2)
             response.content_type = 'text/plain'
             response.content_disposition = (
                 'attachment; filename=%s' % diff_name
             )
             return diff.raw_diff()
 
         elif c.action == 'raw':
             _diff = diffs.get_gitdiff(node1, node2,
                                       ignore_whitespace=ignore_whitespace,
                                       context=line_context)
             diff = diffs.DiffProcessor(_diff, format='gitdiff')
             response.content_type = 'text/plain'
             return diff.raw_diff()
 
         else:
             fid = h.FID(diff2, node2.path)
             line_context_lcl = get_line_ctx(fid, request.GET)
             ign_whitespace_lcl = get_ignore_ws(fid, request.GET)
 
             lim = request.GET.get('fulldiff') or self.cut_off_limit
             _, cs1, cs2, diff, st = diffs.wrapped_diff(filenode_old=node1,
                                          filenode_new=node2,
                                          cut_off_limit=lim,
                                          ignore_whitespace=ign_whitespace_lcl,
                                          line_context=line_context_lcl,
                                          enable_comments=False)
 
             c.changes = [('', node2, diff, cs1, cs2, st,)]
 
         return render('files/file_diff.html')
 
     def _get_node_history(self, cs, f_path, changesets=None):
         if cs is None:
             # if we pass empty CS calculate history based on tip
             cs = c.rhodecode_repo.get_changeset()
         if changesets is None:
             changesets = cs.get_file_history(f_path)
 
         hist_l = []
 
         changesets_group = ([], _("Changesets"))
         branches_group = ([], _("Branches"))
         tags_group = ([], _("Tags"))
         _hg = cs.repository.alias == 'hg'
         for chs in changesets:
             _branch = '(%s)' % chs.branch if _hg else ''
             n_desc = 'r%s:%s %s' % (chs.revision, chs.short_id, _branch)
             changesets_group[0].append((chs.raw_id, n_desc,))
 
         hist_l.append(changesets_group)
 
         for name, chs in c.rhodecode_repo.branches.items():
             branches_group[0].append((chs, name),)
         hist_l.append(branches_group)
 
         for name, chs in c.rhodecode_repo.tags.items():
             tags_group[0].append((chs, name),)
         hist_l.append(tags_group)
 
         return hist_l
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     @jsonify
     def nodelist(self, repo_name, revision, f_path):
         if request.environ.get('HTTP_X_PARTIAL_XHR'):
             cs = self.__get_cs_or_redirect(revision, repo_name)
             _d, _f = ScmModel().get_nodes(repo_name, cs.raw_id, f_path,
                                           flat=False)
             return {'nodes': _d + _f}

rhodecode/lib/middleware/errormator.py

@@ -1,31 +1,31 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.lib.middleware.errormator
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     middleware to handle errormator publishing of errors
 
     :created_on: October 18, 2012
     :author: marcink
     :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 try:
     from errormator_client import make_errormator_middleware
 except ImportError:
     Errormator = None
 else:
-    Errormator = make_errormator_middleware
  No newline at end of file
+    Errormator = make_errormator_middleware

rhodecode/lib/middleware/sentry.py

@@ -1,47 +1,47 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.lib.middleware.sentry
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     middleware to handle sentry/raven publishing of errors
 
     :created_on: September 18, 2012
     :author: marcink
     :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 try:
     from raven.base import Client
     from raven.contrib.pylons import list_from_setting
     from raven.middleware import Sentry as Middleware
 except ImportError:
     Sentry = None
 else:
     class Sentry(Middleware):
         def __init__(self, app, config, client_cls=Client):
             client = client_cls(
                 dsn=config.get('sentry.dsn'),
                 servers=list_from_setting(config, 'sentry.servers'),
                 name=config.get('sentry.name'),
                 key=config.get('sentry.key'),
                 public_key=config.get('sentry.public_key'),
                 secret_key=config.get('sentry.secret_key'),
                 project=config.get('sentry.project'),
                 site=config.get('sentry.site'),
                 include_paths=list_from_setting(config, 'sentry.include_paths'),
                 exclude_paths=list_from_setting(config, 'sentry.exclude_paths'),
             )
-            super(Sentry, self).__init__(app, client)
  No newline at end of file
+            super(Sentry, self).__init__(app, client)

rhodecode/templates/changelog/changelog.html

@@ -1,302 +1,302 b''
 ## -*- coding: utf-8 -*-
 
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
 ${_('%s Changelog') % c.repo_name} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_(u'Home'),h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_name,h.url('summary_home',repo_name=c.repo_name))}
     &raquo;
     <% size = c.size if c.size <= c.total_cs else c.total_cs %>
     ${_('Changelog')} - ${ungettext('showing %d out of %d revision', 'showing %d out of %d revisions', size) % (size, c.total_cs)}
 </%def>
 
 <%def name="page_nav()">
 	${self.menu('changelog')}
 </%def>
 
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <div class="table">
 		% if c.pagination:
 			<div id="graph">
 				<div id="graph_nodes">
 					<canvas id="graph_canvas"></canvas>
 				</div>
 				<div id="graph_content">
                     <div class="info_box" style="clear: both;padding: 10px 6px;vertical-align: right;text-align: right;">
                     <a href="#" class="ui-btn small" id="rev_range_container" style="display:none"></a>
                     <a href="#" class="ui-btn small" id="rev_range_clear" style="display:none">${_('Clear selection')}</a>
-                    
+
                     %if c.rhodecode_db_repo.fork:
                         <a title="${_('compare fork with %s' % c.rhodecode_db_repo.fork.repo_name)}" href="${h.url('compare_url',repo_name=c.repo_name,org_ref_type='branch',org_ref=request.GET.get('branch') or 'default',other_ref_type='branch',other_ref='default',repo=c.rhodecode_db_repo.fork.repo_name)}" class="ui-btn small">${_('Compare fork')}</a>
                     %endif
                     %if h.is_hg(c.rhodecode_repo):
                     <a id="open_new_pr" href="${h.url('pullrequest_home',repo_name=c.repo_name)}" class="ui-btn small">${_('Open new pull request')}</a>
                     %endif
                     </div>
 					<div class="container_header">
 				        ${h.form(h.url.current(),method='get')}
 				        <div class="info_box" style="float:left">
 				          ${h.submit('set',_('Show'),class_="ui-btn")}
 				          ${h.text('size',size=1,value=c.size)}
 				          ${_('revisions')}
 				        </div>
 				        ${h.end_form()}
                     <div style="float:right">${h.select('branch_filter',c.branch_name,c.branch_filters)}</div>
 					</div>
 
 				%for cnt,cs in enumerate(c.pagination):
 					<div id="chg_${cnt+1}" class="container ${'tablerow%s' % (cnt%2)}">
 						<div class="left">
 							<div>
 							${h.checkbox(cs.raw_id,class_="changeset_range")}
 							<span class="tooltip" title="${h.tooltip(h.age(cs.date))}"><a href="${h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id)}"><span class="changeset_id">${cs.revision}:<span class="changeset_hash">${h.short_id(cs.raw_id)}</span></span></a></span>
 							</div>
 							<div class="author">
 								<div class="gravatar">
 									<img alt="gravatar" src="${h.gravatar_url(h.email_or_none(cs.author),16)}"/>
 								</div>
 								<div title="${cs.author}" class="user">${h.shorter(h.person(cs.author),22)}</div>
 							</div>
                             <div class="date">${h.fmt_date(cs.date)}</div>
 						</div>
 						<div class="mid">
                             <div class="message">${h.urlify_commit(cs.message, c.repo_name,h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}</div>
                             <div class="expand"><span class="expandtext">&darr; ${_('show more')} &darr;</span></div>
 						</div>
 						<div class="right">
 									<div class="changes">
                                         <div id="changed_total_${cs.raw_id}" style="float:right;" class="changed_total tooltip" title="${h.tooltip(_('Affected number of files, click to show more details'))}">${len(cs.affected_files)}</div>
                                         <div class="comments-container">
                                         %if len(c.comments.get(cs.raw_id,[])) > 0:
                                             <div class="comments-cnt" title="${('comments')}">
                                               <a href="${h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id,anchor='comment-%s' % c.comments[cs.raw_id][0].comment_id)}">
                                                <div class="comments-cnt">${len(c.comments[cs.raw_id])}</div>
                                                <img src="${h.url('/images/icons/comments.png')}">
                                               </a>
                                             </div>
                                         %endif
                                         </div>
                                         <div class="changeset-status-container">
                                             %if c.statuses.get(cs.raw_id):
                                               <div title="${_('Changeset status')}" class="changeset-status-lbl">${c.statuses.get(cs.raw_id)[1]}</div>
                                               <div class="changeset-status-ico">
                                               %if c.statuses.get(cs.raw_id)[2]:
                                                 <a class="tooltip" title="${_('Click to open associated pull request')}" href="${h.url('pullrequest_show',repo_name=c.statuses.get(cs.raw_id)[3],pull_request_id=c.statuses.get(cs.raw_id)[2])}"><img src="${h.url('/images/icons/flag_status_%s.png' % c.statuses.get(cs.raw_id)[0])}" /></a>
                                               %else:
                                                 <img src="${h.url('/images/icons/flag_status_%s.png' % c.statuses.get(cs.raw_id)[0])}" />
                                               %endif
                                               </div>
                                             %endif
                                         </div>
 									</div>
 								   %if cs.parents:
 									%for p_cs in reversed(cs.parents):
 										<div class="parent">${_('Parent')}
 											<span class="changeset_id">${p_cs.revision}:<span class="changeset_hash">${h.link_to(h.short_id(p_cs.raw_id),
 											h.url('changeset_home',repo_name=c.repo_name,revision=p_cs.raw_id),title=p_cs.message)}</span></span>
 										</div>
 									%endfor
 								   %else:
                                         <div class="parent">${_('No parents')}</div>
                                    %endif
 
 								<span class="logtags">
 									%if len(cs.parents)>1:
 									<span class="merge">${_('merge')}</span>
 									%endif
 									%if cs.branch:
 									<span class="branchtag" title="${'%s %s' % (_('branch'),cs.branch)}">
 									   ${h.link_to(h.shorter(cs.branch),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}
                                     </span>
 									%endif
                                     %if h.is_hg(c.rhodecode_repo):
                                       %for book in cs.bookmarks:
                                       <span class="bookbook" title="${'%s %s' % (_('bookmark'),book)}">
                                          ${h.link_to(h.shorter(book),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}
                                       </span>
                                       %endfor
                                     %endif
 									%for tag in cs.tags:
 										<span class="tagtag"  title="${'%s %s' % (_('tag'),tag)}">
 										${h.link_to(h.shorter(tag),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}</span>
 									%endfor
 								</span>
 						</div>
 					</div>
 
 				%endfor
 				<div class="pagination-wh pagination-left">
 					${c.pagination.pager('$link_previous ~2~ $link_next')}
 				</div>
 				</div>
 			</div>
 
 			<script type="text/javascript" src="${h.url('/js/graph.js')}"></script>
 			<script type="text/javascript">
 				YAHOO.util.Event.onDOMReady(function(){
 
                     //Monitor range checkboxes and build a link to changesets
                     //ranges
                     var checkboxes = YUD.getElementsByClassName('changeset_range');
                     var url_tmpl = "${h.url('changeset_home',repo_name=c.repo_name,revision='__REVRANGE__')}";
                     YUE.on(checkboxes,'click',function(e){
                     	var clicked_cb = e.currentTarget;
                         var checked_checkboxes = [];
                         for (pos in checkboxes){
                             if(checkboxes[pos].checked){
                                 checked_checkboxes.push(checkboxes[pos]);
                             }
                         }
 
                         if(checked_checkboxes.length>0){
                           // modify open pull request to show we have selected cs
                           YUD.get('open_new_pr').innerHTML = _TM['Open new pull request for selected changesets'];
-                                                  	
+
                         }else{
-                          YUD.get('open_new_pr').innerHTML = _TM['Open new pull request'];                        	
+                          YUD.get('open_new_pr').innerHTML = _TM['Open new pull request'];
                         }
-                        
+
                         if(checked_checkboxes.length>1){
                         	var rev_end = checked_checkboxes[0].name;
                         	var rev_start = checked_checkboxes[checked_checkboxes.length-1].name;
 
                         	// now select all checkboxes in the middle.
                         	var checked = false;
                         	for (var i=0; i<checkboxes.length; i++){
                         		var cb = checkboxes[i];
                         		var rev = cb.name;
 
                         		if (rev == rev_end){
                         			checked = true;
                         		}
                                 if (checked){
                                     cb.checked = true;
                                 }
                                 else{
                                     cb.checked = false;
                                 }
                         		if (rev == rev_start){
                                     checked = false;
                                 }
- 
+
                         	}
-                        	
+
                             var url = url_tmpl.replace('__REVRANGE__',
                             		rev_start+'...'+rev_end);
 
                             var link = _TM['Show selected changes __S -> __E'];
                             link = link.replace('__S',rev_start.substr(0,6));
                             link = link.replace('__E',rev_end.substr(0,6));
                             YUD.get('rev_range_container').href = url;
                             YUD.get('rev_range_container').innerHTML = link;
                             YUD.setStyle('rev_range_container','display','');
                             YUD.setStyle('rev_range_clear','display','');
-                        
+
                         }
                         else{
                         	YUD.setStyle('rev_range_container','display','none');
                         	YUD.setStyle('rev_range_clear','display','none');
                         }
                     });
                     YUE.on('rev_range_clear','click',function(e){
                         for (var i=0; i<checkboxes.length; i++){
                             var cb = checkboxes[i];
                             cb.checked = false;
                         }
                         YUE.preventDefault(e);
                     })
                     var msgs = YUQ('.message');
                     // get first element height
                     var el = YUQ('#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 = YUD.getStyle(m,'padding');
                     	if(h > row_h){
                     		var offset = row_h - (h+12);
                     		YUD.setStyle(m.nextElementSibling,'display','block');
                     		YUD.setStyle(m.nextElementSibling,'margin-top',offset+'px');
                     	};
                     }
                     YUE.on(YUQ('.expand'),'click',function(e){
                     	var elem = e.currentTarget.parentNode.parentNode;
                     	YUD.setStyle(e.currentTarget,'display','none');
                     	YUD.setStyle(elem,'height','auto');
 
                     	//redraw the graph, line_count and jsdata are global vars
                         set_canvas(100);
 
                         var r = new BranchRenderer();
                         r.render(jsdata,100,line_count);
 
                     })
 
                     // Fetch changeset details
                     YUE.on(YUD.getElementsByClassName('changed_total'),'click',function(e){
                     	var id = e.currentTarget.id;
                     	var url = "${h.url('changelog_details',repo_name=c.repo_name,cs='__CS__')}";
                     	var url = url.replace('__CS__',id.replace('changed_total_',''));
                     	ypjax(url,id,function(){tooltip_activate()});
                     });
 
                     // change branch filter
                     YUE.on(YUD.get('branch_filter'),'change',function(e){
                     	var selected_branch = e.currentTarget.options[e.currentTarget.selectedIndex].value;
                     	var url_main = "${h.url('changelog_home',repo_name=c.repo_name)}";
                     	var url = "${h.url('changelog_home',repo_name=c.repo_name,branch='__BRANCH__')}";
                     	var url = url.replace('__BRANCH__',selected_branch);
                     	if(selected_branch != ''){
                     		window.location = url;
                     	}else{
                     		window.location = url_main;
                     	}
 
                     });
 
 					function set_canvas(width) {
 						var c = document.getElementById('graph_nodes');
 						var t = document.getElementById('graph_content');
 						canvas = document.getElementById('graph_canvas');
 						var div_h = t.clientHeight;
 						c.style.height=div_h+'px';
 						canvas.setAttribute('height',div_h);
 						c.style.height=width+'px';
 						canvas.setAttribute('width',width);
 					};
 					var heads = 1;
 					var line_count = 0;
 					var jsdata = ${c.jsdata|n};
 
 					for (var i=0;i<jsdata.length;i++) {
                         var in_l = jsdata[i][2];
                         for (var j in in_l) {
                             var m = in_l[j][1];
                             if (m > line_count)
                                 line_count = m;
                         }
 					}
 					set_canvas(100);
 
 					var r = new BranchRenderer();
 					r.render(jsdata,100,line_count);
 
 				});
 			</script>
 		%else:
 			${_('There are no changes yet')}
 		%endif
     </div>
 </div>
 </%def>

rhodecode/templates/changeset/changeset_range.html

@@ -1,122 +1,122 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('%s Changesets') % c.repo_name} - r${c.cs_ranges[0].revision}:${h.short_id(c.cs_ranges[0].raw_id)} -> r${c.cs_ranges[-1].revision}:${h.short_id(c.cs_ranges[-1].raw_id)} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_(u'Home'),h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_name,h.url('summary_home',repo_name=c.repo_name))}
     &raquo;
     ${_('Changesets')} - r${c.cs_ranges[0].revision}:${h.short_id(c.cs_ranges[0].raw_id)} -> r${c.cs_ranges[-1].revision}:${h.short_id(c.cs_ranges[-1].raw_id)}
 </%def>
 
 <%def name="page_nav()">
     ${self.menu('changelog')}
 </%def>
 
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <div class="table">
 		<div id="body" class="diffblock">
 			<div class="code-header cv">
 		        <h3 class="code-header-title">${_('Compare View')}</h3>
                 <div>
 				${_('Changesets')} - r${c.cs_ranges[0].revision}:${h.short_id(c.cs_ranges[0].raw_id)} -> r${c.cs_ranges[-1].revision}:${h.short_id(c.cs_ranges[-1].raw_id)}
 				</div>
 			</div>
 		</div>
 	    <div id="changeset_compare_view_content">
 			<div class="container">
 			<table class="compare_view_commits noborder">
             %for cnt,cs in enumerate(c.cs_ranges):
                 <tr>
                 <td><div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(h.email_or_none(cs.author),14)}"/></div></td>
                 <td>${h.link_to('r%s:%s' % (cs.revision,h.short_id(cs.raw_id)),h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}</td>
                 <td><div class="author">${h.person(cs.author)}</div></td>
                 <td><span class="tooltip" title="${h.age(cs.date)}">${cs.date}</span></td>
                 <td>
                   %if c.statuses:
                     <div title="${h.tooltip(_('Changeset status'))}" class="changeset-status-ico"><img src="${h.url('/images/icons/flag_status_%s.png' % c.statuses[cnt])}" /></div>
                   %endif
                 </td>
                 <td><div class="message">${h.urlify_commit(h.wrap_paragraphs(cs.message),c.repo_name)}</div></td>
                 </tr>
             %endfor
             </table>
 	        </div>
 	        <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">${_('Files affected')}</div>
 	        <div class="cs_files">
 	               %for cs in c.cs_ranges:
 	                   <div class="cur_cs">${h.link_to('r%s:%s' % (cs.revision,h.short_id(cs.raw_id)),h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}</div>
 	                %for change,filenode,diff,cs1,cs2,st in c.changes[cs.raw_id]:
 	                    <div class="cs_${change}">${h.link_to(h.safe_unicode(filenode.path),h.url.current(anchor=h.FID(cs.raw_id,filenode.path)))}</div>
 	                %endfor
 	               %endfor
 	        </div>
 	    </div>
 
     </div>
     <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>
     <%namespace name="diff_block" file="/changeset/diff_block.html"/>
      %for cs in c.cs_ranges:
           ##${comment.comment_inline_form(cs)}
           ## diff block
           <div class="h3">
           <a class="tooltip" title="${h.tooltip(cs.message)}" href="${h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id)}">${'r%s:%s' % (cs.revision,h.short_id(cs.raw_id))}</a>
              <div class="gravatar">
                  <img alt="gravatar" src="${h.gravatar_url(h.email_or_none(cs.author),20)}"/>
              </div>
              <div class="right">
               <span class="logtags">
                 %if len(cs.parents)>1:
                 <span class="merge">${_('merge')}</span>
                 %endif
                 %if cs.branch:
                 <span class="branchtag" title="${'%s %s' % (_('branch'),cs.branch)}">
                    ${h.link_to(h.shorter(cs.branch),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}
                 </span>
                 %endif
                 %if h.is_hg(c.rhodecode_repo):
                   %for book in cs.bookmarks:
                   <span class="bookbook" title="${'%s %s' % (_('bookmark'),book)}">
                      ${h.link_to(h.shorter(book),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}
                   </span>
                   %endfor
                 %endif
                 %for tag in cs.tags:
                     <span class="tagtag"  title="${'%s %s' % (_('tag'),tag)}">
                     ${h.link_to(h.shorter(tag),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}</span>
                 %endfor
-              </span>        
-            </div>   
+              </span>
+            </div>
            </div>
           ${diff_block.diff_block(c.changes[cs.raw_id])}
           ##${comment.comments(cs)}
 
      %endfor
      <script type="text/javascript">
 
       YUE.onDOMReady(function(){
 
           YUE.on(YUQ('.diff-menu-activate'),'click',function(e){
               var act = e.currentTarget.nextElementSibling;
 
               if(YUD.hasClass(act,'active')){
                   YUD.removeClass(act,'active');
                   YUD.setStyle(act,'display','none');
               }else{
                   YUD.addClass(act,'active');
                   YUD.setStyle(act,'display','');
               }
           });
       })
     </script>
     </div>
 </%def>

rhodecode/templates/followers/followers_data.html

@@ -1,32 +1,32 b''
 ## -*- coding: utf-8 -*-
 
 % for f in c.followers_pager:
     <div>
         <div class="follower_user">
             <div class="gravatar">
                 <img alt="gravatar" src="${h.gravatar_url(f.user.email,24)}"/>
             </div>
             <span style="font-size: 20px"> <b>${f.user.username}</b> (${f.user.name} ${f.user.lastname})</span>
         </div>
         <div style="clear:both;padding-top: 10px"></div>
         <div class="follower_date">${_('Started following -')}
         <span class="tooltip" title="${h.tooltip(f.follows_from)}"> ${h.age(f.follows_from)}</span></div>
         <div style="border-bottom: 1px solid #DDD;margin:10px 0px 10px 0px"></div>
     </div>
 % endfor
 
 <div class="pagination-wh pagination-left">
 <script type="text/javascript">
 YUE.onDOMReady(function(){
     YUE.delegate("followers","click",function(e, matchedEl, container){
         ypjax(e.target.href,"followers",function(){
         	show_more_event();
         	tooltip_activate();
-        	show_changeset_tooltip();	
+        	show_changeset_tooltip();
         });
         YUE.preventDefault(e);
     },'.pager_link');
 });
 </script>
 ${c.followers_pager.pager('$link_previous ~2~ $link_next')}
 </div>

rhodecode/templates/forks/forks_data.html

@@ -1,43 +1,43 b''
 ## -*- coding: utf-8 -*-
 
 % if c.forks_pager:
 	% for f in c.forks_pager:
 	    <div>
 	        <div class="fork_user">
 	            <div class="gravatar">
 	                <img alt="gravatar" src="${h.gravatar_url(f.user.email,24)}"/>
 	            </div>
 	            <span style="font-size: 20px">
 	             <b>${f.user.username}</b> (${f.user.name} ${f.user.lastname}) /
 	              ${h.link_to(f.repo_name,h.url('summary_home',repo_name=f.repo_name))}
 	             </span>
 	             <div style="padding:5px 3px 3px 42px;">${f.description}</div>
 	        </div>
 	        <div style="clear:both;padding-top: 10px"></div>
 	        <div class="follower_date">${_('forked')} -
 	        <span class="tooltip" title="${h.tooltip(h.fmt_date(f.created_on))}"> ${h.age(f.created_on)}</span>
             <a title="${_('compare fork with %s' % c.repo_name)}"
                href="${h.url('compare_url',repo_name=f.repo_name,org_ref_type='branch',org_ref='default',other_ref_type='branch',other_ref='default', repo=c.repo_name)}"
                class="ui-btn small">${_('Compare fork')}</a>
              </div>
 	        <div style="border-bottom: 1px solid #DDD;margin:10px 0px 10px 0px"></div>
 	    </div>
 	% endfor
   <div class="pagination-wh pagination-left">
   <script type="text/javascript">
   YUE.onDOMReady(function(){
       YUE.delegate("forks","click",function(e, matchedEl, container){
           ypjax(e.target.href,"forks",function(){
         	  show_more_event();
         	  tooltip_activate();
-        	  show_changeset_tooltip(); 
+        	  show_changeset_tooltip();
           });
           YUE.preventDefault(e);
       },'.pager_link');
   });
   </script>
   ${c.forks_pager.pager('$link_previous ~2~ $link_next')}
   </div>
 % else:
 	${_('There are no forks yet')}
 % endif

rhodecode/templates/index_base.html

@@ -1,332 +1,331 b''
 <%page args="parent" />
     <div class="box">
         <!-- box / title -->
         <div class="title">
             <h5>
             <input class="q_filter_box" id="q_filter" size="15" type="text" name="filter" value="${_('quick filter...')}"/> ${parent.breadcrumbs()} <span id="repo_count">0</span> ${_('repositories')}
             </h5>
             %if c.rhodecode_user.username != 'default':
                 %if h.HasPermissionAny('hg.admin','hg.create.repository')():
                 <ul class="links">
                   <li>
                   %if c.group:
                     <span>${h.link_to(_('ADD REPOSITORY'),h.url('admin_settings_create_repository',parent_group=c.group.group_id))}</span>
                   %else:
                     <span>${h.link_to(_('ADD REPOSITORY'),h.url('admin_settings_create_repository'))}</span>
                   %endif
                   </li>
                 </ul>
                 %endif
             %endif
         </div>
         <!-- end box / title -->
         <div class="table">
            % if c.groups:
             <div id='groups_list_wrap' class="yui-skin-sam">
               <table id="groups_list">
                   <thead>
                       <tr>
                           <th class="left"><a href="#">${_('Group name')}</a></th>
                           <th class="left"><a href="#">${_('Description')}</a></th>
                           ##<th class="left"><a href="#">${_('Number of repositories')}</a></th>
                       </tr>
                   </thead>
 
                   ## REPO GROUPS
                   % for gr in c.groups:
                     <tr>
                         <td>
                             <div style="white-space: nowrap">
                             <img class="icon" alt="${_('Repositories group')}" src="${h.url('/images/icons/database_link.png')}"/>
                             ${h.link_to(gr.name,url('repos_group_home',group_name=gr.group_name))}
                             </div>
                         </td>
                         %if c.visual.stylify_metatags:
                             <td>${h.urlify_text(h.desc_stylize(gr.group_description))}</td>
                         %else:
                             <td>${gr.group_description}</td>
                         %endif
                         ## this is commented out since for multi nested repos can be HEAVY!
                         ## in number of executed queries during traversing uncomment at will
                         ##<td><b>${gr.repositories_recursive_count}</b></td>
                     </tr>
                   % endfor
 
               </table>
             </div>
             <div style="height: 20px"></div>
             % endif
             <div id="welcome" style="display:none;text-align:center">
                 <h1><a href="${h.url('home')}">${c.rhodecode_name} ${c.rhodecode_version}</a></h1>
             </div>
              <%cnt=0%>
              <%namespace name="dt" file="/data_table/_dt_elements.html"/>
             % if c.visual.lightweight_dashboard is False:
               ## old full detailed version
             <div id='repos_list_wrap' class="yui-skin-sam">
             <table id="repos_list">
             <thead>
                 <tr>
                     <th class="left"></th>
                     <th class="left">${_('Name')}</th>
                     <th class="left">${_('Description')}</th>
                     <th class="left">${_('Last change')}</th>
                     <th class="left">${_('Tip')}</th>
                     <th class="left">${_('Owner')}</th>
                     <th class="left">${_('RSS')}</th>
                     <th class="left">${_('Atom')}</th>
                 </tr>
             </thead>
             <tbody>
             %for cnt,repo in enumerate(c.repos_list):
                 <tr class="parity${(cnt+1)%2}">
                     ##QUICK MENU
                     <td class="quick_repo_menu">
                       ${dt.quick_menu(repo['name'])}
                     </td>
                     ##REPO NAME AND ICONS
                     <td class="reponame">
                       ${dt.repo_name(repo['name'],repo['dbrepo']['repo_type'],repo['dbrepo']['private'],h.AttributeDict(repo['dbrepo_fork']),pageargs.get('short_repo_names'))}
                     </td>
                     ##DESCRIPTION
                     <td><span class="tooltip" title="${h.tooltip(repo['description'])}">
                        %if c.visual.stylify_metatags:
                        ${h.urlify_text(h.desc_stylize(h.truncate(repo['description'],60)))}</span>
                        %else:
                        ${h.truncate(repo['description'],60)}</span>
                        %endif
                     </td>
                     ##LAST CHANGE DATE
                     <td>
                       ${dt.last_change(repo['last_change'])}
                     </td>
                     ##LAST REVISION
                     <td>
                         ${dt.revision(repo['name'],repo['rev'],repo['tip'],repo['author'],repo['last_msg'])}
                     </td>
                     ##
                     <td title="${repo['contact']}">${h.person(repo['contact'])}</td>
                     <td>
                       ${dt.rss(repo['name'])}
                     </td>
                     <td>
                       ${dt.atom(repo['name'])}
                     </td>
                 </tr>
             %endfor
             </tbody>
             </table>
             </div>
             % else:
               ## lightweight version
                 <div class="yui-skin-sam" id="repos_list_wrap"></div>
                 <div id="user-paginator" style="padding: 0px 0px 0px 0px"></div>
             % endif
         </div>
     </div>
     % if c.visual.lightweight_dashboard is False:
     <script>
       YUD.get('repo_count').innerHTML = ${cnt+1 if cnt else 0};
       var func = function(node){
           return node.parentNode.parentNode.parentNode.parentNode;
       }
 
       // groups table sorting
       var myColumnDefs = [
           {key:"name",label:"${_('Group name')}",sortable:true,
               sortOptions: { sortFunction: groupNameSort }},
           {key:"desc",label:"${_('Description')}",sortable:true},
       ];
 
       var myDataSource = new YAHOO.util.DataSource(YUD.get("groups_list"));
 
       myDataSource.responseType = YAHOO.util.DataSource.TYPE_HTMLTABLE;
       myDataSource.responseSchema = {
           fields: [
               {key:"name"},
               {key:"desc"},
           ]
       };
 
       var myDataTable = new YAHOO.widget.DataTable("groups_list_wrap", myColumnDefs, myDataSource,{
           sortedBy:{key:"name",dir:"asc"},
           paginator: new YAHOO.widget.Paginator({
               rowsPerPage: 5,
               alwaysVisible: false,
               template : "{PreviousPageLink} {FirstPageLink} {PageLinks} {LastPageLink} {NextPageLink}",
               pageLinks: 5,
               containerClass: 'pagination-wh',
               currentPageClass: 'pager_curpage',
               pageLinkClass: 'pager_link',
               nextPageLinkLabel: '&gt;',
               previousPageLinkLabel: '&lt;',
               firstPageLinkLabel: '&lt;&lt;',
               lastPageLinkLabel: '&gt;&gt;',
               containers:['user-paginator']
-          }),          
+          }),
           MSG_SORTASC:"${_('Click to sort ascending')}",
           MSG_SORTDESC:"${_('Click to sort descending')}"
       });
 
       // main table sorting
       var myColumnDefs = [
           {key:"menu",label:"",sortable:false,className:"quick_repo_menu hidden"},
           {key:"name",label:"${_('Name')}",sortable:true,
               sortOptions: { sortFunction: nameSort }},
           {key:"desc",label:"${_('Description')}",sortable:true},
           {key:"last_change",label:"${_('Last Change')}",sortable:true,
               sortOptions: { sortFunction: ageSort }},
           {key:"tip",label:"${_('Tip')}",sortable:true,
         	  sortOptions: { sortFunction: revisionSort }},
           {key:"owner",label:"${_('Owner')}",sortable:true},
           {key:"rss",label:"",sortable:false},
           {key:"atom",label:"",sortable:false},
       ];
 
       var myDataSource = new YAHOO.util.DataSource(YUD.get("repos_list"));
 
       myDataSource.responseType = YAHOO.util.DataSource.TYPE_HTMLTABLE;
 
       myDataSource.responseSchema = {
           fields: [
               {key:"menu"},
               //{key:"raw_name"},
               {key:"name"},
               {key:"desc"},
               {key:"last_change"},
               {key:"tip"},
               {key:"owner"},
               {key:"rss"},
               {key:"atom"},
           ]
       };
 
       var myDataTable = new YAHOO.widget.DataTable("repos_list_wrap", myColumnDefs, myDataSource,
               {
     	       sortedBy:{key:"name",dir:"asc"},
                MSG_SORTASC:"${_('Click to sort ascending')}",
                MSG_SORTDESC:"${_('Click to sort descending')}",
                MSG_EMPTY:"${_('No records found.')}",
                MSG_ERROR:"${_('Data error.')}",
                MSG_LOADING:"${_('Loading...')}",
               }
       );
       myDataTable.subscribe('postRenderEvent',function(oArgs) {
           tooltip_activate();
           quick_repo_menu();
           q_filter('q_filter',YUQ('div.table tr td a.repo_name'),func);
       });
 
     </script>
     % else:
       <script>
         //var url = "${h.url('formatted_users', format='json')}";
         var data = ${c.data|n};
         var myDataSource = new YAHOO.util.DataSource(data);
         myDataSource.responseType = YAHOO.util.DataSource.TYPE_JSON;
-      
+
         myDataSource.responseSchema = {
             resultsList: "records",
             fields: [
                {key:"menu"},
                {key:"raw_name"},
                {key:"name"},
                {key:"desc"},
                {key:"last_change"},
                {key:"owner"},
                {key:"rss"},
                {key:"atom"},
             ]
          };
         myDataSource.doBeforeCallback = function(req,raw,res,cb) {
             // This is the filter function
             var data     = res.results || [],
                 filtered = [],
                 i,l;
-      
+
             if (req) {
                 req = req.toLowerCase();
                 for (i = 0; i<data.length; i++) {
                     var pos = data[i].raw_name.toLowerCase().indexOf(req)
                     if (pos != -1) {
                         filtered.push(data[i]);
                     }
                 }
                 res.results = filtered;
             }
             YUD.get('repo_count').innerHTML = res.results.length;
             return res;
         }
-      
+
         // main table sorting
         var myColumnDefs = [
             {key:"menu",label:"",sortable:false,className:"quick_repo_menu hidden"},
             {key:"name",label:"${_('Name')}",sortable:true,
                 sortOptions: { sortFunction: nameSort }},
             {key:"desc",label:"${_('Description')}",sortable:true},
             {key:"last_change",label:"${_('Last Change')}",sortable:true,
                 sortOptions: { sortFunction: ageSort }},
             {key:"owner",label:"${_('Owner')}",sortable:true},
             {key:"rss",label:"",sortable:false},
             {key:"atom",label:"",sortable:false},
         ];
-      
+
         var myDataTable = new YAHOO.widget.DataTable("repos_list_wrap", myColumnDefs, myDataSource,{
           sortedBy:{key:"name",dir:"asc"},
           paginator: new YAHOO.widget.Paginator({
               rowsPerPage: 15,
               alwaysVisible: false,
               template : "{PreviousPageLink} {FirstPageLink} {PageLinks} {LastPageLink} {NextPageLink}",
               pageLinks: 5,
               containerClass: 'pagination-wh',
               currentPageClass: 'pager_curpage',
               pageLinkClass: 'pager_link',
               nextPageLinkLabel: '&gt;',
               previousPageLinkLabel: '&lt;',
               firstPageLinkLabel: '&lt;&lt;',
               lastPageLinkLabel: '&gt;&gt;',
               containers:['user-paginator']
           }),
-      
+
           MSG_SORTASC:"${_('Click to sort ascending')}",
           MSG_SORTDESC:"${_('Click to sort descending')}",
           MSG_EMPTY:"${_('No records found.')}",
           MSG_ERROR:"${_('Data error.')}",
           MSG_LOADING:"${_('Loading...')}",
         }
         );
         myDataTable.subscribe('postRenderEvent',function(oArgs) {
             tooltip_activate();
             quick_repo_menu();
         });
-      
+
         var filterTimeout = null;
-      
+
         updateFilter  = function () {
             // Reset timeout
             filterTimeout = null;
-      
+
             // Reset sort
             var state = myDataTable.getState();
                 state.sortedBy = {key:'name', dir:YAHOO.widget.DataTable.CLASS_ASC};
-      
+
             // Get filtered data
             myDataSource.sendRequest(YUD.get('q_filter').value,{
                 success : myDataTable.onDataReturnInitializeTable,
                 failure : myDataTable.onDataReturnInitializeTable,
                 scope   : myDataTable,
                 argument: state
             });
-      
+
         };
         YUE.on('q_filter','click',function(){
             YUD.get('q_filter').value = '';
          });
-      
+
         YUE.on('q_filter','keyup',function (e) {
             clearTimeout(filterTimeout);
             filterTimeout = setTimeout(updateFilter,600);
         });
       </script>
     % endif
-    
  No newline at end of file

rhodecode/templates/journal/journal.html

@@ -1,210 +1,210 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 <%def name="title()">
     ${_('Journal')} - ${c.rhodecode_name}
 </%def>
 <%def name="breadcrumbs()">
 	${c.rhodecode_name}
 </%def>
 <%def name="page_nav()">
 	${self.menu('home')}
 </%def>
 <%def name="head_extra()">
 <link href="${h.url('journal_atom', api_key=c.rhodecode_user.api_key)}" rel="alternate" title="${_('ATOM journal feed')}" type="application/atom+xml" />
 <link href="${h.url('journal_rss', api_key=c.rhodecode_user.api_key)}" rel="alternate" title="${_('RSS journal feed')}" type="application/rss+xml" />
 </%def>
 <%def name="main()">
 
     <div class="box box-left">
 	    <!-- box / title -->
 	    <div class="title">
 	        <h5>${_('Journal')}</h5>
              <ul class="links">
                <li>
                  <span><a id="refresh" href="${h.url('journal')}"><img class="icon" title="${_('Refresh')}" alt="${_('Refresh')}" src="${h.url('/images/icons/arrow_refresh.png')}"/></a></span>
                </li>
                <li>
                  <span><a href="${h.url('journal_rss', api_key=c.rhodecode_user.api_key)}"><img class="icon" title="${_('RSS feed')}" alt="${_('RSS feed')}" src="${h.url('/images/icons/rss_16.png')}"/></a></span>
                </li>
                <li>
                  <span><a href="${h.url('journal_atom', api_key=c.rhodecode_user.api_key)}"><img class="icon" title="${_('ATOM feed')}" alt="${_('ATOM feed')}" src="${h.url('/images/icons/atom.png')}"/></a></span>
                </li>
              </ul>
 	    </div>
 	    <div id="journal">${c.journal_data}</div>
     </div>
     <div class="box box-right">
         <!-- box / title -->
         <div class="title">
             <h5>
             <input class="q_filter_box" id="q_filter" size="15" type="text" name="filter" value="${_('quick filter...')}"/>
-            <a id="show_watched" class="link-white" href="#watched">${_('Watched')}</a> / <a id="show_my" class="link-white" href="#my">${_('My repos')}</a> 
+            <a id="show_watched" class="link-white" href="#watched">${_('Watched')}</a> / <a id="show_my" class="link-white" href="#my">${_('My repos')}</a>
             </h5>
              %if h.HasPermissionAny('hg.admin','hg.create.repository')():
              <ul class="links">
                <li>
                  <span>${h.link_to(_('ADD'),h.url('admin_settings_create_repository'))}</span>
                </li>
              </ul>
              %endif
         </div>
         <!-- end box / title -->
         <div id="my" class="table" style="display:none">
         ## loaded via AJAX
         ${_('Loading...')}
         </div>
 
         <div id="watched" class="table">
           %if c.following:
             <table>
             <thead>
                 <tr>
                 <th class="left">${_('Name')}</th>
             </thead>
              <tbody>
                 %for entry in c.following:
                   <tr>
                     <td>
                       %if entry.follows_user_id:
                         <img title="${_('following user')}" alt="${_('user')}" src="${h.url('/images/icons/user.png')}"/>
                         ${entry.follows_user.full_contact}
                       %endif
 
                       %if entry.follows_repo_id:
                         <div style="float:right;padding-right:5px">
                         <span id="follow_toggle_${entry.follows_repository.repo_id}" class="following" title="${_('Stop following this repository')}"
                               onclick="javascript:toggleFollowingRepo(this,${entry.follows_repository.repo_id},'${str(h.get_token())}')">
                         </span>
                         </div>
 
                          %if h.is_hg(entry.follows_repository):
                            <img class="icon" title="${_('Mercurial repository')}" alt="${_('Mercurial repository')}" src="${h.url('/images/icons/hgicon.png')}"/>
                          %elif h.is_git(entry.follows_repository):
                            <img class="icon" title="${_('Git repository')}" alt="${_('Git repository')}" src="${h.url('/images/icons/giticon.png')}"/>
                          %endif
 
                         %if entry.follows_repository.private and c.visual.show_private_icon:
                           <img class="icon" title="${_('private repository')}" alt="${_('private repository')}" src="${h.url('/images/icons/lock.png')}"/>
                         %elif not entry.follows_repository.private and c.visual.show_public_icon:
                           <img class="icon" title="${_('public repository')}" alt="${_('public repository')}" src="${h.url('/images/icons/lock_open.png')}"/>
                         %endif
                         <span class="watched_repo">
                             ${h.link_to(entry.follows_repository.repo_name,h.url('summary_home',repo_name=entry.follows_repository.repo_name))}
                         </span>
                       %endif
                     </td>
                   </tr>
                 %endfor
             </tbody>
             </table>
           %else:
               <div style="padding:5px 0px 10px 0px;">
               ${_('You are not following any users or repositories')}
               </div>
           %endif
         </div>
     </div>
 
     <script type="text/javascript">
     var show_my = function(e){
         YUD.setStyle('watched','display','none');
         YUD.setStyle('my','display','');
 
         var url = "${h.url('admin_settings_my_repos')}";
         ypjax(url, 'my', function(){
             tooltip_activate();
             quick_repo_menu();
             var nodes = YUQ('#my tr td a.repo_name');
             var func = function(node){
                 return node.parentNode.parentNode.parentNode;
-            }            
+            }
             q_filter('q_filter',nodes,func);
-        });        
-        
+        });
+
     }
     YUE.on('show_my','click',function(e){
         show_my(e);
     })
     var show_watched = function(e){
     	YUD.setStyle('my','display','none');
         YUD.setStyle('watched','display','');
         var nodes = YUQ('#watched .watched_repo a');
         var target = 'q_filter';
         var func = function(node){
             return node.parentNode.parentNode;
         }
         q_filter(target,nodes,func);
     }
     YUE.on('show_watched','click',function(e){
         show_watched(e);
     })
     //init watched
     show_watched();
-    
+
     var tabs = {
         'watched': show_watched,
         'my': show_my,
     }
     var url = location.href.split('#');
     if (url[1]) {
         //We have a hash
         var tabHash = url[1];
         tabs[tabHash]();
-    }    
-    
+    }
+
     YUE.on('refresh','click',function(e){
         ypjax(e.currentTarget.href,"journal",function(){
         	show_more_event();
         	tooltip_activate();
         	show_changeset_tooltip();
         	});
         YUE.preventDefault(e);
     });
 
 
     // main table sorting
     var myColumnDefs = [
         {key:"menu",label:"",sortable:false,className:"quick_repo_menu hidden"},
         {key:"name",label:"${_('Name')}",sortable:true,
             sortOptions: { sortFunction: nameSort }},
         {key:"tip",label:"${_('Tip')}",sortable:true,
             sortOptions: { sortFunction: revisionSort }},
         {key:"action1",label:"",sortable:false},
         {key:"action2",label:"",sortable:false},
     ];
 
     var myDataSource = new YAHOO.util.DataSource(YUD.get("repos_list"));
 
     myDataSource.responseType = YAHOO.util.DataSource.TYPE_HTMLTABLE;
 
     myDataSource.responseSchema = {
         fields: [
             {key:"menu"},
             {key:"name"},
             {key:"tip"},
             {key:"action1"},
             {key:"action2"}
         ]
     };
 
     var myDataTable = new YAHOO.widget.DataTable("repos_list_wrap", myColumnDefs, myDataSource,
             {
               sortedBy:{key:"name",dir:"asc"},
               MSG_SORTASC:"${_('Click to sort ascending')}",
               MSG_SORTDESC:"${_('Click to sort descending')}",
               MSG_EMPTY:"${_('No records found.')}",
               MSG_ERROR:"${_('Data error.')}",
               MSG_LOADING:"${_('Loading...')}",
             }
     );
     myDataTable.subscribe('postRenderEvent',function(oArgs) {
         tooltip_activate();
         quick_repo_menu();
         var func = function(node){
             return node.parentNode.parentNode.parentNode.parentNode;
         }
         q_filter('q_filter',YUQ('#my tr td a.repo_name'),func);
     });
 
     </script>
 </%def>

rhodecode/templates/journal/journal_page_repos.html

@@ -1,47 +1,47 b''
 %if c.user_repos:
 <div id='repos_list_wrap' class="yui-skin-sam">
 <table id="repos_list">
  <thead>
       <tr>
       <th></th>
       <th class="left">${_('Name')}</th>
       <th class="left">${_('Revision')}</th>
       <th class="left">${_('Action')}</th>
       <th class="left">${_('Action')}</th>
  </thead>
  <tbody>
      <%namespace name="dt" file="/data_table/_dt_elements.html"/>
      %for repo in c.user_repos:
         <tr>
             ##QUICK MENU
             <td class="quick_repo_menu">
               ${dt.quick_menu(repo['name'])}
             </td>
             ##REPO NAME AND ICONS
             <td class="reponame">
               ${dt.repo_name(repo['name'],repo['dbrepo']['repo_type'],repo['dbrepo']['private'],h.AttributeDict(repo['dbrepo_fork']))}
             </td>
             ##LAST REVISION
             <td>
                 ${dt.revision(repo['name'],repo['rev'],repo['tip'],repo['author'],repo['last_msg'])}
             </td>
             ##
             <td><a href="${h.url('repo_settings_home',repo_name=repo['name'])}" title="${_('edit')}"><img class="icon" alt="${_('private')}" src="${h.url('/images/icons/application_form_edit.png')}"/></a></td>
             <td>
               ${h.form(url('repo_settings_delete', repo_name=repo['name']),method='delete')}
                 ${h.submit('remove_%s' % repo['name'],'',class_="delete_icon action_button",onclick="return confirm('"+_('Confirm to delete this repository: %s') % repo['name']+"');")}
               ${h.end_form()}
             </td>
         </tr>
      %endfor
  </tbody>
  </table>
  </div>
  %else:
     <div style="padding:5px 0px 10px 0px;">
     ${_('No repositories yet')}
     %if h.HasPermissionAny('hg.admin','hg.create.repository')():
         ${h.link_to(_('create one now'),h.url('admin_settings_create_repository'),class_="ui-btn")}
     %endif
     </div>
- %endif
  No newline at end of file
+ %endif

rhodecode/templates/pullrequests/pullrequest_show.html

@@ -1,207 +1,207 b''
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${c.repo_name} ${_('Pull request #%s') % c.pull_request.pull_request_id}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_(u'Home'),h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_name,h.url('changelog_home',repo_name=c.repo_name))}
     &raquo;
     ${_('Pull request #%s') % c.pull_request.pull_request_id}
 </%def>
 
 <%def name="main()">
 
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
         %if c.pull_request.is_closed():
         <div style="padding:10px; font-size:22px;width:100%;text-align: center; color:#88D882">${_('Closed %s') % (h.age(c.pull_request.updated_on))} ${_('with status %s') % h.changeset_status_lbl(c.current_changeset_status)}</div>
         %endif
     <h3>${_('Title')}: ${c.pull_request.title}</h3>
 
     <div class="form">
       <div id="summary" class="fields">
          <div class="field">
           <div class="label-summary">
               <label>${_('Status')}:</label>
           </div>
           <div class="input">
             <div class="changeset-status-container" style="float:none;clear:both">
             %if c.current_changeset_status:
               <div title="${_('Pull request status')}" class="changeset-status-lbl">[${h.changeset_status_lbl(c.current_changeset_status)}]</div>
               <div class="changeset-status-ico" style="padding:1px 4px"><img src="${h.url('/images/icons/flag_status_%s.png' % c.current_changeset_status)}" /></div>
             %endif
             </div>
           </div>
          </div>
          <div class="field">
           <div class="label-summary">
               <label>${_('Still not reviewed by')}:</label>
           </div>
           <div class="input">
             % if len(c.pull_request_pending_reviewers) > 0:
                 <div class="tooltip" title="${h.tooltip(','.join([x.username for x in c.pull_request_pending_reviewers]))}">${ungettext('%d reviewer', '%d reviewers',len(c.pull_request_pending_reviewers)) % len(c.pull_request_pending_reviewers)}</div>
             %else:
                 <div>${_('pull request was reviewed by all reviewers')}</div>
             %endif
           </div>
          </div>
       </div>
     </div>
     <div style="white-space:pre-wrap;padding:3px 3px 5px 20px">${h.literal(c.pull_request.description)}</div>
     <div style="padding:4px 4px 10px 20px">
       <div>${_('Created on')}: ${h.fmt_date(c.pull_request.created_on)}</div>
     </div>
 
     <div style="min-height:160px">
       ##DIFF
       <div class="table" style="float:left;clear:none">
           <div id="body" class="diffblock">
               <div style="white-space:pre-wrap;padding:5px">${_('Compare view')}</div>
           </div>
           <div id="changeset_compare_view_content">
               ##CS
               <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">${_('Incoming changesets')}</div>
               <%include file="/compare/compare_cs.html" />
 
               ## FILES
               <div id="affected_files">
               % if c.files:
                 <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">${_('Files affected')}</div>
-                <div class="cs_files">              
+                <div class="cs_files">
                 %for fid, change, f, stat in c.files:
                     <div class="cs_${change}">
                       <div class="node">${h.link_to(h.safe_unicode(f),h.url.current(anchor=fid))}</div>
                       <div class="changes">${h.fancy_file_stats(stat)}</div>
                     </div>
                 %endfor
                </div>
               %else:
                 <div class="ui-btn" style="text-align: center;margin-top:5px">${_('Click to load diff details')}</div>
               %endif
               </div>
           </div>
       </div>
       ## REVIEWERS
        <div style="float:left; border-left:1px dashed #eee">
        <h4>${_('Pull request reviewers')}</h4>
         <div id="reviewers" style="padding:0px 0px 0px 15px">
           ## members goes here !
           <div class="group_members_wrap">
             <ul id="review_members" class="group_members">
             %for member,status in c.pull_request_reviewers:
               <li id="reviewer_${member.user_id}">
                 <div class="reviewers_member">
                     <div style="float:left;padding:0px 3px 0px 0px" class="tooltip" title="${h.tooltip(h.changeset_status_lbl(status[0][1].status if status else 'not_reviewed'))}">
                       <img src="${h.url(str('/images/icons/flag_status_%s.png' % (status[0][1].status if status else 'not_reviewed')))}"/>
                     </div>
                   <div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(member.email,14)}"/> </div>
                   <div style="float:left">${member.full_name} (${_('owner')})</div>
                   <input type="hidden" value="${member.user_id}" name="review_members" />
                   %if not c.pull_request.is_closed() and (h.HasPermissionAny('hg.admin', 'repository.admin')() or c.pull_request.author.user_id == c.rhodecode_user.user_id):
                   <span class="delete_icon action_button" onclick="removeReviewer(${member.user_id})"></span>
                   %endif
                 </div>
               </li>
             %endfor
             </ul>
           </div>
           %if not c.pull_request.is_closed():
           <div class='ac'>
             %if h.HasPermissionAny('hg.admin', 'repository.admin')() or c.pull_request.author.user_id == c.rhodecode_user.user_id:
             <div class="reviewer_ac">
                ${h.text('user', class_='yui-ac-input')}
                <span class="help-block">${_('Add reviewer to this pull request.')}</span>
                <div id="reviewers_container"></div>
             </div>
             <div style="padding:0px 10px">
              <span id="update_pull_request" class="ui-btn xsmall">${_('save')}</span>
             </div>
             %endif
           </div>
           %endif
         </div>
        </div>
     </div>
     <script>
     var _USERS_AC_DATA = ${c.users_array|n};
     var _GROUPS_AC_DATA = ${c.users_groups_array|n};
     AJAX_COMMENT_URL = "${url('pullrequest_comment',repo_name=c.repo_name,pull_request_id=c.pull_request.pull_request_id)}";
     AJAX_COMMENT_DELETE_URL = "${url('pullrequest_comment_delete',repo_name=c.repo_name,comment_id='__COMMENT_ID__')}";
     AJAX_UPDATE_PULLREQUEST = "${url('pullrequest_update',repo_name=c.repo_name,pull_request_id=c.pull_request.pull_request_id)}"
     </script>
 
     ## diff block
     <div id="diff_block_container" style="clear:both;">
     <%namespace name="diff_block" file="/changeset/diff_block.html"/>
     %for fid, change, f, stat in c.files:
       ${diff_block.diff_block_simple([c.changes[fid]])}
     %endfor
     </div>
 
     ## template for inline comment form
     <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>
     ${comment.comment_inline_form()}
 
     ## render comments and inlines
     ${comment.generate_comments()}
 
     % if not c.pull_request.is_closed():
       ## main comment form and it status
       ${comment.comments(h.url('pullrequest_comment', repo_name=c.repo_name,
                                 pull_request_id=c.pull_request.pull_request_id),
                                 c.current_changeset_status,
                                 close_btn=True)}
     %endif
 
     <script type="text/javascript">
       YUE.onDOMReady(function(){
     	  PullRequestAutoComplete('user', 'reviewers_container', _USERS_AC_DATA, _GROUPS_AC_DATA);
 
           YUE.on(YUQ('.show-inline-comments'),'change',function(e){
               var show = 'none';
               var target = e.currentTarget;
               if(target.checked){
                   var show = ''
               }
               var boxid = YUD.getAttribute(target,'id_for');
               var comments = YUQ('#{0} .inline-comments'.format(boxid));
               for(c in comments){
                  YUD.setStyle(comments[c],'display',show);
               }
               var btns = YUQ('#{0} .inline-comments-button'.format(boxid));
               for(c in btns){
                   YUD.setStyle(btns[c],'display',show);
                }
           })
 
           YUE.on(YUQ('.line'),'click',function(e){
               var tr = e.currentTarget;
               injectInlineForm(tr);
           });
 
           // inject comments into they proper positions
           var file_comments = YUQ('.inline-comment-placeholder');
           renderInlineComments(file_comments);
 
           YUE.on(YUD.get('update_pull_request'),'click',function(e){
 
         	  var reviewers_ids = [];
         	  var ids = YUQ('#review_members input');
         	  for(var i=0; i<ids.length;i++){
         		  var id = ids[i].value
         		  reviewers_ids.push(id);
         	  }
         	  updateReviewers(reviewers_ids);
           })
       })
     </script>
 
 </div>
 
 </%def>

rhodecode/templates/summary/summary.html

@@ -1,719 +1,719 b''
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('%s Summary') % c.repo_name} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_(u'Home'),h.url('/'))}
     &raquo;
     ${h.repo_link(c.dbrepo.groups_and_repo)}
     &raquo;
     ${_('summary')}
 </%def>
 
 <%def name="page_nav()">
 	${self.menu('summary')}
 </%def>
 
 <%def name="head_extra()">
 <link href="${h.url('atom_feed_home',repo_name=c.dbrepo.repo_name,api_key=c.rhodecode_user.api_key)}" rel="alternate" title="${_('repo %s ATOM feed') % c.repo_name}" type="application/atom+xml" />
 <link href="${h.url('rss_feed_home',repo_name=c.dbrepo.repo_name,api_key=c.rhodecode_user.api_key)}" rel="alternate" title="${_('repo %s RSS feed') % c.repo_name}" type="application/rss+xml" />
 </%def>
 
 <%def name="main()">
     <%
     summary = lambda n:{False:'summary-short'}.get(n)
     %>
     %if c.show_stats:
         <div class="box box-left">
     %else:
         <div class="box">
     %endif
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <!-- end box / title -->
 	<div class="form">
 	  <div id="summary" class="fields">
 
 			 <div class="field">
 			  <div class="label-summary">
 			      <label>${_('Name')}:</label>
 			  </div>
 			  <div class="input ${summary(c.show_stats)}">
                   <div style="float:right;padding:5px 0px 0px 5px">
                      %if c.rhodecode_user.username != 'default':
                       ${h.link_to(_('RSS'),h.url('rss_feed_home',repo_name=c.dbrepo.repo_name,api_key=c.rhodecode_user.api_key),class_='rss_icon')}
                       ${h.link_to(_('ATOM'),h.url('atom_feed_home',repo_name=c.dbrepo.repo_name,api_key=c.rhodecode_user.api_key),class_='atom_icon')}
                      %else:
                       ${h.link_to(_('RSS'),h.url('rss_feed_home',repo_name=c.dbrepo.repo_name),class_='rss_icon')}
                       ${h.link_to(_('ATOM'),h.url('atom_feed_home',repo_name=c.dbrepo.repo_name),class_='atom_icon')}
                      %endif
                   </div>
                   %if c.rhodecode_user.username != 'default':
                       %if c.following:
                       <span id="follow_toggle" class="following tooltip" title="${_('Stop following this repository')}"
                             onclick="javascript:toggleFollowingRepo(this,${c.dbrepo.repo_id},'${str(h.get_token())}')">
                       </span>
                       %else:
                       <span id="follow_toggle" class="follow tooltip" title="${_('Start following this repository')}"
                             onclick="javascript:toggleFollowingRepo(this,${c.dbrepo.repo_id},'${str(h.get_token())}')">
                       </span>
                       %endif
                   %endif:
-                 
+
                    ## locking icon
                     %if c.rhodecode_db_repo.enable_locking:
                       %if c.rhodecode_db_repo.locked[0]:
-                        <span class="locking_locked tooltip" title="${_('Repository locked by %s') % h.person_by_id(c.rhodecode_db_repo.locked[0])}"></span>                     
+                        <span class="locking_locked tooltip" title="${_('Repository locked by %s') % h.person_by_id(c.rhodecode_db_repo.locked[0])}"></span>
                       %else:
                         <span class="locking_unlocked tooltip" title="${_('Repository unlocked')}"></span>
                       %endif
-                    %endif                   
+                    %endif
                  ##REPO TYPE
 		         %if h.is_hg(c.dbrepo):
 		           <img style="margin-bottom:2px" class="icon" title="${_('Mercurial repository')}" alt="${_('Mercurial repository')}" src="${h.url('/images/icons/hgicon.png')}"/>
 		         %endif
 		         %if h.is_git(c.dbrepo):
 		           <img style="margin-bottom:2px" class="icon" title="${_('Git repository')}" alt="${_('Git repository')}" src="${h.url('/images/icons/giticon.png')}"/>
 		         %endif
 
                  ##PUBLIC/PRIVATE
 	             %if c.dbrepo.private:
 	                <img style="margin-bottom:2px" class="icon" title="${_('private repository')}" alt="${_('private repository')}" src="${h.url('/images/icons/lock.png')}"/>
 	             %else:
 	                <img style="margin-bottom:2px" class="icon" title="${_('public repository')}" alt="${_('public repository')}" src="${h.url('/images/icons/lock_open.png')}"/>
 	             %endif
 
 	              ##REPO NAME
 			      <span class="repo_name" title="${_('Non changable ID %s') % c.dbrepo.repo_id}">${h.repo_link(c.dbrepo.groups_and_repo)}</span>
 
                   ##FORK
 		          %if c.dbrepo.fork:
 	            	<div style="margin-top:5px;clear:both"">
 	            	<a href="${h.url('summary_home',repo_name=c.dbrepo.fork.repo_name)}"><img class="icon" alt="${_('public')}" title="${_('Fork of')} ${c.dbrepo.fork.repo_name}" src="${h.url('/images/icons/arrow_divide.png')}"/>
 	            	    ${_('Fork of')} ${c.dbrepo.fork.repo_name}
 	            	</a>
 	            	</div>
 		          %endif
 		          ##REMOTE
 				  %if c.dbrepo.clone_uri:
                     <div style="margin-top:5px;clear:both">
                     <a href="${h.url(str(h.hide_credentials(c.dbrepo.clone_uri)))}"><img class="icon" alt="${_('remote clone')}" title="${_('Clone from')} ${h.hide_credentials(c.dbrepo.clone_uri)}" src="${h.url('/images/icons/connect.png')}"/>
                         ${_('Clone from')} ${h.hide_credentials(c.dbrepo.clone_uri)}
                     </a>
                     </div>
 				  %endif
 			  </div>
 			 </div>
 
 			 <div class="field">
 			  <div class="label-summary">
 			      <label>${_('Description')}:</label>
 			  </div>
               %if c.visual.stylify_metatags:
                 <div class="input ${summary(c.show_stats)} desc">${h.urlify_text(h.desc_stylize(c.dbrepo.description))}</div>
               %else:
                 <div class="input ${summary(c.show_stats)} desc">${h.urlify_text(c.dbrepo.description)}</div>
               %endif
 			 </div>
 
 			 <div class="field">
 			  <div class="label-summary">
 			      <label>${_('Contact')}:</label>
 			  </div>
 			  <div class="input ${summary(c.show_stats)}">
 			  	<div class="gravatar">
 			  		<img alt="gravatar" src="${h.gravatar_url(c.dbrepo.user.email)}"/>
 			  	</div>
 			  		${_('Username')}: ${c.dbrepo.user.username}<br/>
 			  		${_('Name')}: ${c.dbrepo.user.name} ${c.dbrepo.user.lastname}<br/>
 			  		${_('Email')}: <a href="mailto:${c.dbrepo.user.email}">${c.dbrepo.user.email}</a>
 			  </div>
 			 </div>
 
 			 <div class="field">
 			  <div class="label-summary">
 			      <label>${_('Clone url')}:</label>
 			  </div>
 			  <div class="input ${summary(c.show_stats)}">
                   <div  style="display:none" id="clone_by_name" class="ui-btn clone">${_('Show by Name')}</div>
                   <div id="clone_by_id" class="ui-btn clone">${_('Show by ID')}</div>
 			      <input style="width:80%;margin-left:105px" type="text" id="clone_url" readonly="readonly" value="${c.clone_repo_url}"/>
                   <input style="display:none;width:80%;margin-left:105px" type="text" id="clone_url_id" readonly="readonly" value="${c.clone_repo_url_id}"/>
 			  </div>
 			 </div>
 
 			 <div class="field">
 			  <div class="label-summary">
 			      <label>${_('Trending files')}:</label>
 			  </div>
 			  <div class="input ${summary(c.show_stats)}">
                 %if c.show_stats:
 			    <div id="lang_stats"></div>
                 %else:
                    ${_('Statistics are disabled for this repository')}
                    %if h.HasPermissionAll('hg.admin')('enable stats on from summary'):
                         ${h.link_to(_('enable'),h.url('edit_repo',repo_name=c.repo_name),class_="ui-btn")}
                    %endif
                 %endif
 			  </div>
 			 </div>
 
 			 <div class="field">
 			  <div class="label-summary">
 			      <label>${_('Download')}:</label>
 			  </div>
 			  <div class="input ${summary(c.show_stats)}">
 		        %if len(c.rhodecode_repo.revisions) == 0:
 		          ${_('There are no downloads yet')}
 		        %elif c.enable_downloads is False:
 		          ${_('Downloads are disabled for this repository')}
                     %if h.HasPermissionAll('hg.admin')('enable downloads on from summary'):
                         ${h.link_to(_('enable'),h.url('edit_repo',repo_name=c.repo_name),class_="ui-btn")}
                     %endif
 		        %else:
 			        ${h.select('download_options',c.rhodecode_repo.get_changeset().raw_id,c.download_options)}
 			             <span id="${'zip_link'}">${h.link_to(_('Download as zip'), h.url('files_archive_home',repo_name=c.dbrepo.repo_name,fname='tip.zip'),class_="archive_icon ui-btn")}</span>
                     <span style="vertical-align: bottom">
                         <input id="archive_subrepos" type="checkbox" name="subrepos" />
                         <label for="archive_subrepos" class="tooltip" title="${h.tooltip(_('Check this to download archive with subrepos'))}" >${_('with subrepos')}</label>
                     </span>
 			    %endif
 			  </div>
 			 </div>
 	  </div>
 	</div>
 </div>
 
 %if c.show_stats:
 <div class="box box-right"  style="min-height:455px">
     <!-- box / title -->
     <div class="title">
         <h5>${_('Commit activity by day / author')}</h5>
     </div>
 
     <div class="graph">
          <div style="padding:0 10px 10px 17px;">
          %if c.no_data:
            ${c.no_data_msg}
            %if h.HasPermissionAll('hg.admin')('enable stats on from summary'):
                 ${h.link_to(_('enable'),h.url('edit_repo',repo_name=c.repo_name),class_="ui-btn")}
            %endif
         %else:
             ${_('Stats gathered: ')} ${c.stats_percentage}%
         %endif
         </div>
         <div id="commit_history" style="width:450px;height:300px;float:left"></div>
         <div style="clear: both;height: 10px"></div>
         <div id="overview" style="width:450px;height:100px;float:left"></div>
 
     	<div id="legend_data" style="clear:both;margin-top:10px;">
 	    	<div id="legend_container"></div>
 	    	<div id="legend_choices">
 				<table id="legend_choices_tables" class="noborder" style="font-size:smaller;color:#545454"></table>
 	    	</div>
     	</div>
     </div>
 </div>
 %endif
 
 <div class="box">
     <div class="title">
         <div class="breadcrumbs">
         %if c.repo_changesets:
             ${h.link_to(_('Shortlog'),h.url('shortlog_home',repo_name=c.repo_name))}
         %else:
             ${_('Quick start')}
          %endif
         </div>
     </div>
     <div class="table">
         <div id="shortlog_data">
             <%include file='../shortlog/shortlog_data.html'/>
         </div>
     </div>
 </div>
 
 %if c.readme_data:
 <div id="readme" class="box header-pos-fix" style="background-color: #FAFAFA">
     <div id="readme" class="title" title="${_("Readme file at revision '%s'" % c.rhodecode_db_repo.landing_rev)}">
         <div class="breadcrumbs">
             <a href="${h.url('files_home',repo_name=c.repo_name,revision='tip',f_path=c.readme_file)}">${c.readme_file}</a>
             <a class="permalink" href="#readme" title="${_('Permalink to this readme')}">&para;</a>
         </div>
     </div>
     <div id="readme" class="readme">
       <div class="readme_box">
         ${c.readme_data|n}
       </div>
     </div>
 </div>
 %endif
 
 <script type="text/javascript">
 var clone_url = 'clone_url';
 YUE.on(clone_url,'click',function(e){
     if(YUD.hasClass(clone_url,'selected')){
         return
     }
     else{
         YUD.addClass(clone_url,'selected');
         YUD.get(clone_url).select();
     }
 })
 
 YUE.on('clone_by_name','click',function(e){
     // show url by name and hide name button
     YUD.setStyle('clone_url','display','');
     YUD.setStyle('clone_by_name','display','none');
 
     // hide url by id and show name button
     YUD.setStyle('clone_by_id','display','');
     YUD.setStyle('clone_url_id','display','none');
 
 })
 YUE.on('clone_by_id','click',function(e){
 
 	// show url by id and hide id button
 	YUD.setStyle('clone_by_id','display','none');
     YUD.setStyle('clone_url_id','display','');
 
     // hide url by name and show id button
 	YUD.setStyle('clone_by_name','display','');
 	YUD.setStyle('clone_url','display','none');
 })
 
 
 var tmpl_links = {};
 %for cnt,archive in enumerate(c.rhodecode_repo._get_archives()):
   tmpl_links["${archive['type']}"] = '${h.link_to('__NAME__', h.url('files_archive_home',repo_name=c.dbrepo.repo_name, fname='__CS__'+archive['extension'],subrepos='__SUB__'),class_='archive_icon ui-btn')}';
 %endfor
 
 YUE.on(['download_options','archive_subrepos'],'change',function(e){
    var sm = YUD.get('download_options');
    var new_cs = sm.options[sm.selectedIndex];
 
    for(k in tmpl_links){
        var s = YUD.get(k+'_link');
        if(s){
          var title_tmpl = "${_('Download %s as %s') % ('__CS_NAME__','__CS_EXT__')}";
          title_tmpl= title_tmpl.replace('__CS_NAME__',new_cs.text);
          title_tmpl = title_tmpl.replace('__CS_EXT__',k);
 
          var url = tmpl_links[k].replace('__CS__',new_cs.value);
          var subrepos = YUD.get('archive_subrepos').checked;
          url = url.replace('__SUB__',subrepos);
          url = url.replace('__NAME__',title_tmpl);
          s.innerHTML = url
        }
    }
 });
 </script>
 %if c.show_stats:
 <script type="text/javascript">
 var data = ${c.trending_languages|n};
 var total = 0;
 var no_data = true;
 var tbl = document.createElement('table');
 tbl.setAttribute('class','trending_language_tbl');
 var cnt = 0;
 for (var i=0;i<data.length;i++){
 	total+= data[i][1].count;
 }
 for (var i=0;i<data.length;i++){
     cnt += 1;
     no_data = false;
 
     var hide = cnt>2;
     var tr = document.createElement('tr');
     if (hide){
         tr.setAttribute('style','display:none');
         tr.setAttribute('class','stats_hidden');
     }
     var k = data[i][0];
     var obj = data[i][1];
     var percentage = Math.round((obj.count/total*100),2);
 
     var td1 = document.createElement('td');
     td1.width = 150;
     var trending_language_label = document.createElement('div');
     trending_language_label.innerHTML = obj.desc+" ("+k+")";
     td1.appendChild(trending_language_label);
 
     var td2 = document.createElement('td');
     td2.setAttribute('style','padding-right:14px !important');
     var trending_language = document.createElement('div');
     var nr_files = obj.count+" ${_('files')}";
 
     trending_language.title = k+" "+nr_files;
 
     if (percentage>22){
         trending_language.innerHTML = "<b style='font-size:0.8em'>"+percentage+"% "+nr_files+ "</b>";
     }
     else{
         trending_language.innerHTML = "<b style='font-size:0.8em'>"+percentage+"%</b>";
     }
 
     trending_language.setAttribute("class", 'trending_language top-right-rounded-corner bottom-right-rounded-corner');
     trending_language.style.width=percentage+"%";
     td2.appendChild(trending_language);
 
     tr.appendChild(td1);
     tr.appendChild(td2);
     tbl.appendChild(tr);
     if(cnt == 3){
         var show_more = document.createElement('tr');
         var td = document.createElement('td');
         lnk = document.createElement('a');
 
         lnk.href='#';
         lnk.innerHTML = "${_('show more')}";
         lnk.id='code_stats_show_more';
         td.appendChild(lnk);
 
         show_more.appendChild(td);
         show_more.appendChild(document.createElement('td'));
         tbl.appendChild(show_more);
     }
 
 }
 
 YUD.get('lang_stats').appendChild(tbl);
 YUE.on('code_stats_show_more','click',function(){
     l = YUD.getElementsByClassName('stats_hidden')
     for (e in l){
         YUD.setStyle(l[e],'display','');
     };
     YUD.setStyle(YUD.get('code_stats_show_more'),
             'display','none');
 });
 </script>
 <script type="text/javascript">
 /**
  * Plots summary graph
  *
  * @class SummaryPlot
  * @param {from} initial from for detailed graph
  * @param {to} initial to for detailed graph
  * @param {dataset}
  * @param {overview_dataset}
  */
 function SummaryPlot(from,to,dataset,overview_dataset) {
     var initial_ranges = {
         "xaxis":{
             "from":from,
             "to":to,
         },
     };
     var dataset = dataset;
     var overview_dataset = [overview_dataset];
     var choiceContainer = YUD.get("legend_choices");
     var choiceContainerTable = YUD.get("legend_choices_tables");
     var plotContainer = YUD.get('commit_history');
     var overviewContainer = YUD.get('overview');
 
     var plot_options = {
         bars: {show:true,align:'center',lineWidth:4},
         legend: {show:true, container:"legend_container"},
         points: {show:true,radius:0,fill:false},
         yaxis: {tickDecimals:0,},
         xaxis: {
             mode: "time",
             timeformat: "%d/%m",
             min:from,
             max:to,
         },
         grid: {
             hoverable: true,
             clickable: true,
             autoHighlight:true,
             color: "#999"
         },
         //selection: {mode: "x"}
     };
     var overview_options = {
         legend:{show:false},
         bars: {show:true,barWidth: 2,},
         shadowSize: 0,
         xaxis: {mode: "time", timeformat: "%d/%m/%y",},
         yaxis: {ticks: 3, min: 0,tickDecimals:0,},
         grid: {color: "#999",},
         selection: {mode: "x"}
     };
 
     /**
     *get dummy data needed in few places
     */
     function getDummyData(label){
         return {"label":label,
          "data":[{"time":0,
              "commits":0,
                  "added":0,
                  "changed":0,
                  "removed":0,
             }],
             "schema":["commits"],
             "color":'#ffffff',
         }
     }
 
     /**
      * generate checkboxes accordindly to data
      * @param keys
      * @returns
      */
     function generateCheckboxes(data) {
         //append checkboxes
         var i = 0;
         choiceContainerTable.innerHTML = '';
         for(var pos in data) {
 
             data[pos].color = i;
             i++;
             if(data[pos].label != ''){
                 choiceContainerTable.innerHTML +=
                     '<tr><td><input type="checkbox" id="id_user_{0}" name="{0}" checked="checked" /> \
                      <label for="id_user_{0}">{0}</label></td></tr>'.format(data[pos].label);
             }
         }
     }
 
     /**
      * ToolTip show
      */
     function showTooltip(x, y, contents) {
         var div=document.getElementById('tooltip');
         if(!div) {
             div = document.createElement('div');
             div.id="tooltip";
             div.style.position="absolute";
             div.style.border='1px solid #fdd';
             div.style.padding='2px';
             div.style.backgroundColor='#fee';
             document.body.appendChild(div);
         }
         YUD.setStyle(div, 'opacity', 0);
         div.innerHTML = contents;
         div.style.top=(y + 5) + "px";
         div.style.left=(x + 5) + "px";
 
         var anim = new YAHOO.util.Anim(div, {opacity: {to: 0.8}}, 0.2);
         anim.animate();
     }
 
     /**
      * This function will detect if selected period has some changesets
        for this user if it does this data is then pushed for displaying
        Additionally it will only display users that are selected by the checkbox
     */
     function getDataAccordingToRanges(ranges) {
 
         var data = [];
         var new_dataset = {};
         var keys = [];
         var max_commits = 0;
         for(var key in dataset){
 
             for(var ds in dataset[key].data){
                 commit_data = dataset[key].data[ds];
                 if (commit_data.time >= ranges.xaxis.from && commit_data.time <= ranges.xaxis.to){
 
                     if(new_dataset[key] === undefined){
                         new_dataset[key] = {data:[],schema:["commits"],label:key};
                     }
                     new_dataset[key].data.push(commit_data);
                 }
             }
             if (new_dataset[key] !== undefined){
                 data.push(new_dataset[key]);
             }
         }
 
         if (data.length > 0){
             return data;
         }
         else{
             //just return dummy data for graph to plot itself
             return [getDummyData('')];
         }
     }
 
     /**
     * redraw using new checkbox data
     */
     function plotchoiced(e,args){
         var cur_data = args[0];
         var cur_ranges = args[1];
 
         var new_data = [];
         var inputs = choiceContainer.getElementsByTagName("input");
 
         //show only checked labels
         for(var i=0; i<inputs.length; i++) {
             var checkbox_key = inputs[i].name;
 
             if(inputs[i].checked){
                 for(var d in cur_data){
                     if(cur_data[d].label == checkbox_key){
                         new_data.push(cur_data[d]);
                     }
                 }
             }
             else{
                 //push dummy data to not hide the label
                 new_data.push(getDummyData(checkbox_key));
             }
         }
 
         var new_options = YAHOO.lang.merge(plot_options, {
             xaxis: {
                 min: cur_ranges.xaxis.from,
                 max: cur_ranges.xaxis.to,
                 mode:"time",
                 timeformat: "%d/%m",
             },
         });
         if (!new_data){
             new_data = [[0,1]];
         }
         // do the zooming
        plot = YAHOO.widget.Flot(plotContainer, new_data, new_options);
 
        plot.subscribe("plotselected", plotselected);
 
        //resubscribe plothover
        plot.subscribe("plothover", plothover);
 
        // don't fire event on the overview to prevent eternal loop
        overview.setSelection(cur_ranges, true);
 
     }
 
     /**
      * plot only selected items from overview
      * @param ranges
      * @returns
      */
     function plotselected(ranges,cur_data) {
         //updates the data for new plot
         var data = getDataAccordingToRanges(ranges);
         generateCheckboxes(data);
 
         var new_options = YAHOO.lang.merge(plot_options, {
             xaxis: {
                 min: ranges.xaxis.from,
                 max: ranges.xaxis.to,
                 mode:"time",
                 timeformat: "%d/%m",
             },
         });
         // do the zooming
         plot = YAHOO.widget.Flot(plotContainer, data, new_options);
 
         plot.subscribe("plotselected", plotselected);
 
         //resubscribe plothover
         plot.subscribe("plothover", plothover);
 
         // don't fire event on the overview to prevent eternal loop
         overview.setSelection(ranges, true);
 
         //resubscribe choiced
         YUE.on(choiceContainer.getElementsByTagName("input"), "click", plotchoiced, [data, ranges]);
     }
 
     var previousPoint = null;
 
     function plothover(o) {
         var pos = o.pos;
         var item = o.item;
 
         //YUD.get("x").innerHTML = pos.x.toFixed(2);
         //YUD.get("y").innerHTML = pos.y.toFixed(2);
         if (item) {
             if (previousPoint != item.datapoint) {
                 previousPoint = item.datapoint;
 
                 var tooltip = YUD.get("tooltip");
                 if(tooltip) {
                       tooltip.parentNode.removeChild(tooltip);
                 }
                 var x = item.datapoint.x.toFixed(2);
                 var y = item.datapoint.y.toFixed(2);
 
                 if (!item.series.label){
                     item.series.label = 'commits';
                 }
                 var d = new Date(x*1000);
                 var fd = d.toDateString()
                 var nr_commits = parseInt(y);
 
                 var cur_data = dataset[item.series.label].data[item.dataIndex];
                 var added = cur_data.added;
                 var changed = cur_data.changed;
                 var removed = cur_data.removed;
 
                 var nr_commits_suffix = " ${_('commits')} ";
                 var added_suffix = " ${_('files added')} ";
                 var changed_suffix = " ${_('files changed')} ";
                 var removed_suffix = " ${_('files removed')} ";
 
 
                 if(nr_commits == 1){nr_commits_suffix = " ${_('commit')} ";}
                 if(added==1){added_suffix=" ${_('file added')} ";}
                 if(changed==1){changed_suffix=" ${_('file changed')} ";}
                 if(removed==1){removed_suffix=" ${_('file removed')} ";}
 
                 showTooltip(item.pageX, item.pageY, item.series.label + " on " + fd
                          +'<br/>'+
                          nr_commits + nr_commits_suffix+'<br/>'+
                          added + added_suffix +'<br/>'+
                          changed + changed_suffix + '<br/>'+
                          removed + removed_suffix + '<br/>');
             }
         }
         else {
               var tooltip = YUD.get("tooltip");
 
               if(tooltip) {
                     tooltip.parentNode.removeChild(tooltip);
               }
             previousPoint = null;
         }
     }
 
     /**
      * MAIN EXECUTION
      */
 
     var data = getDataAccordingToRanges(initial_ranges);
     generateCheckboxes(data);
 
     //main plot
     var plot = YAHOO.widget.Flot(plotContainer,data,plot_options);
 
     //overview
     var overview = YAHOO.widget.Flot(overviewContainer,
             overview_dataset, overview_options);
 
     //show initial selection on overview
     overview.setSelection(initial_ranges);
 
     plot.subscribe("plotselected", plotselected);
     plot.subscribe("plothover", plothover)
 
     overview.subscribe("plotselected", function (ranges) {
         plot.setSelection(ranges);
     });
 
     // user choices on overview
     YUE.on(choiceContainer.getElementsByTagName("input"), "click", plotchoiced, [data, initial_ranges]);
 }
     SummaryPlot(${c.ts_min},${c.ts_max},${c.commit_data|n},${c.overview_data|n});
 </script>
 %endif
 
 </%def>

rhodecode/tests/functional/test_home.py

@@ -1,79 +1,78 b''
 import time
 from rhodecode.tests import *
 from rhodecode.model.meta import Session
 from rhodecode.model.db import User, RhodeCodeSetting, Repository
 from rhodecode.lib.utils import set_rhodecode_config
 
 
 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')
         response.mustcontain('href="/%s/summary"' % HG_REPO)
 
         response.mustcontain("""<img class="icon" title="Mercurial repository" """
                         """alt="Mercurial repository" src="/images/icons/hg"""
                         """icon.png"/>""")
         response.mustcontain("""<img class="icon" title="public repository" """
                         """alt="public repository" src="/images/icons/lock_"""
                         """open.png"/>""")
 
         response.mustcontain(
 """<a title="Marcin Kuzminski &amp;lt;[e-mail]&amp;gt;:\n
 merge" class="tooltip" href="/vcs_test_hg/changeset/27cd5cce30c96924232"""
 """dffcd24178a07ffeb5dfc">r173:27cd5cce30c9</a>"""
 )
 
     def test_repo_summary_with_anonymous_access_disabled(self):
         anon = User.get_by_username('default')
         anon.active = False
         Session().add(anon)
         Session().commit()
         time.sleep(1.5)  # must sleep for cache (1s to expire)
         try:
             response = self.app.get(url(controller='summary',
                                         action='index', repo_name=HG_REPO),
                                         status=302)
             assert 'login' in response.location
 
         finally:
             anon = User.get_by_username('default')
             anon.active = True
             Session().add(anon)
             Session().commit()
 
     def test_index_with_anonymous_access_disabled(self):
         anon = User.get_by_username('default')
         anon.active = False
         Session().add(anon)
         Session().commit()
         time.sleep(1.5)  # must sleep for cache (1s to expire)
         try:
             response = self.app.get(url(controller='home', action='index'),
                                     status=302)
             assert 'login' in response.location
         finally:
             anon = User.get_by_username('default')
             anon.active = True
             Session().add(anon)
             Session().commit()
 
     def test_index_with_lightweight_dashboard(self):
         self.log_user()
 
         def set_l_dash(set_to):
             self.app.post(url('admin_setting', setting_id='visual'),
                           params=dict(_method='put',
                                       rhodecode_lightweight_dashboard=set_to,))
 
         set_l_dash(True)
 
         try:
             response = self.app.get(url(controller='home', action='index'))
             response.mustcontain("""var data = {"totalRecords": %s""" % len(Repository.getAll()))
         finally:
             set_l_dash(False)
-