sidebar: fixes to comment links, and new hovercard info about a comment.

rhodecode/model/changeset_status.py

@@ -1,397 +1,397 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import itertools
 import logging
 import collections
 
 from rhodecode.model import BaseModel
 from rhodecode.model.db import (
     ChangesetStatus, ChangesetComment, PullRequest, Session)
 from rhodecode.lib.exceptions import StatusChangeOnClosedPullRequestError
 from rhodecode.lib.markup_renderer import (
     DEFAULT_COMMENTS_RENDERER, RstTemplateRenderer)
 
 log = logging.getLogger(__name__)
 
 
 class ChangesetStatusModel(BaseModel):
 
     cls = ChangesetStatus
 
     def __get_changeset_status(self, changeset_status):
         return self._get_instance(ChangesetStatus, changeset_status)
 
     def __get_pull_request(self, pull_request):
         return self._get_instance(PullRequest, pull_request)
 
     def _get_status_query(self, repo, revision, pull_request,
                           with_revisions=False):
         repo = self._get_repo(repo)
 
         q = ChangesetStatus.query()\
             .filter(ChangesetStatus.repo == repo)
         if not with_revisions:
             q = q.filter(ChangesetStatus.version == 0)
 
         if revision:
             q = q.filter(ChangesetStatus.revision == revision)
         elif pull_request:
             pull_request = self.__get_pull_request(pull_request)
             # TODO: johbo: Think about the impact of this join, there must
             # be a reason why ChangesetStatus and ChanagesetComment is linked
             # to the pull request. Might be that we want to do the same for
             # the pull_request_version_id.
             q = q.join(ChangesetComment).filter(
                 ChangesetStatus.pull_request == pull_request,
                 ChangesetComment.pull_request_version_id == None)
         else:
             raise Exception('Please specify revision or pull_request')
         q = q.order_by(ChangesetStatus.version.asc())
         return q
 
     def calculate_group_vote(self, group_id, group_statuses_by_reviewers,
                              trim_votes=True):
         """
         Calculate status based on given group members, and voting rule
 
 
         group1 - 4 members, 3 required for approval
             user1 - approved
             user2 - reject
             user3 - approved
             user4 - rejected
 
         final_state: rejected, reasons not at least 3 votes
 
 
         group1 - 4 members, 2 required for approval
             user1 - approved
             user2 - reject
             user3 - approved
             user4 - rejected
 
         final_state: approved, reasons got at least 2 approvals
 
         group1 - 4 members, ALL required for approval
             user1 - approved
             user2 - reject
             user3 - approved
             user4 - rejected
 
         final_state: rejected, reasons not all approvals
 
 
         group1 - 4 members, ALL required for approval
             user1 - approved
             user2 - approved
             user3 - approved
             user4 - approved
 
         final_state: approved, reason all approvals received
 
         group1 - 4 members, 5 required for approval
             (approval should be shorted to number of actual members)
 
             user1 - approved
             user2 - approved
             user3 - approved
             user4 - approved
 
         final_state: approved, reason all approvals received
 
         """
         group_vote_data = {}
         got_rule = False
         members = collections.OrderedDict()
         for review_obj, user, reasons, mandatory, statuses \
                 in group_statuses_by_reviewers:
 
             if not got_rule:
                 group_vote_data = review_obj.rule_user_group_data()
                 got_rule = bool(group_vote_data)
 
             members[user.user_id] = statuses
 
         if not group_vote_data:
             return []
 
         required_votes = group_vote_data['vote_rule']
         if required_votes == -1:
             # -1 means all required, so we replace it with how many people
             # are in the members
             required_votes = len(members)
 
         if trim_votes and required_votes > len(members):
             # we require more votes than we have members in the group
             # in this case we trim the required votes to the number of members
             required_votes = len(members)
 
         approvals = sum([
             1 for statuses in members.values()
             if statuses and
                statuses[0][1].status == ChangesetStatus.STATUS_APPROVED])
 
         calculated_votes = []
         # we have all votes from users, now check if we have enough votes
         # to fill other
         fill_in = ChangesetStatus.STATUS_UNDER_REVIEW
         if approvals >= required_votes:
             fill_in = ChangesetStatus.STATUS_APPROVED
 
         for member, statuses in members.items():
             if statuses:
                 ver, latest = statuses[0]
                 if fill_in == ChangesetStatus.STATUS_APPROVED:
                     calculated_votes.append(fill_in)
                 else:
                     calculated_votes.append(latest.status)
             else:
                 calculated_votes.append(fill_in)
 
         return calculated_votes
 
     def calculate_status(self, statuses_by_reviewers):
         """
         Given the approval statuses from reviewers, calculates final approval
         status. There can only be 3 results, all approved, all rejected. If
         there is no consensus the PR is under review.
 
         :param statuses_by_reviewers:
         """
 
         def group_rule(element):
             review_obj = element[0]
             rule_data = review_obj.rule_user_group_data()
             if rule_data and rule_data['id']:
                 return rule_data['id']
 
         voting_groups = itertools.groupby(
             sorted(statuses_by_reviewers, key=group_rule), group_rule)
 
         voting_by_groups = [(x, list(y)) for x, y in voting_groups]
 
         reviewers_number = len(statuses_by_reviewers)
         votes = collections.defaultdict(int)
         for group, group_statuses_by_reviewers in voting_by_groups:
             if group:
                 # calculate how the "group" voted
                 for vote_status in self.calculate_group_vote(
                         group, group_statuses_by_reviewers):
                     votes[vote_status] += 1
             else:
 
                 for review_obj, user, reasons, mandatory, statuses \
                         in group_statuses_by_reviewers:
                     # individual vote
                     if statuses:
                         ver, latest = statuses[0]
                         votes[latest.status] += 1
 
         approved_votes_count = votes[ChangesetStatus.STATUS_APPROVED]
         rejected_votes_count = votes[ChangesetStatus.STATUS_REJECTED]
 
         # TODO(marcink): with group voting, how does rejected work,
         # do we ever get rejected state ?
 
-        if approved_votes_count == reviewers_number:
+        if approved_votes_count and (approved_votes_count == reviewers_number):
             return ChangesetStatus.STATUS_APPROVED
 
-        if rejected_votes_count == reviewers_number:
+        if rejected_votes_count and (rejected_votes_count == reviewers_number):
             return ChangesetStatus.STATUS_REJECTED
 
         return ChangesetStatus.STATUS_UNDER_REVIEW
 
     def get_statuses(self, repo, revision=None, pull_request=None,
                      with_revisions=False):
         q = self._get_status_query(repo, revision, pull_request,
                                    with_revisions)
         return q.all()
 
     def get_status(self, repo, revision=None, pull_request=None, as_str=True):
         """
         Returns latest status of changeset for given revision or for given
         pull request. Statuses are versioned inside a table itself and
         version == 0 is always the current one
 
         :param repo:
         :param revision: 40char hash or None
         :param pull_request: pull_request reference
         :param as_str: return status as string not object
         """
         q = self._get_status_query(repo, revision, pull_request)
 
         # need to use first here since there can be multiple statuses
         # returned from pull_request
         status = q.first()
         if as_str:
             status = status.status if status else status
             st = status or ChangesetStatus.DEFAULT
             return str(st)
         return status
 
     def _render_auto_status_message(
             self, status, commit_id=None, pull_request=None):
         """
         render the message using DEFAULT_COMMENTS_RENDERER (RST renderer),
         so it's always looking the same disregarding on which default
         renderer system is using.
 
         :param status: status text to change into
         :param commit_id: the commit_id we change the status for
         :param pull_request: the pull request we change the status for
         """
 
         new_status = ChangesetStatus.get_status_lbl(status)
 
         params = {
             'new_status_label': new_status,
             'pull_request': pull_request,
             'commit_id': commit_id,
         }
         renderer = RstTemplateRenderer()
         return renderer.render('auto_status_change.mako', **params)
 
     def set_status(self, repo, status, user, comment=None, revision=None,
                    pull_request=None, dont_allow_on_closed_pull_request=False):
         """
         Creates new status for changeset or updates the old ones bumping their
         version, leaving the current status at
 
         :param repo:
         :param revision:
         :param status:
         :param user:
         :param comment:
         :param dont_allow_on_closed_pull_request: don't allow a status change
             if last status was for pull request and it's closed. We shouldn't
             mess around this manually
         """
         repo = self._get_repo(repo)
 
         q = ChangesetStatus.query()
 
         if revision:
             q = q.filter(ChangesetStatus.repo == repo)
             q = q.filter(ChangesetStatus.revision == revision)
         elif pull_request:
             pull_request = self.__get_pull_request(pull_request)
             q = q.filter(ChangesetStatus.repo == pull_request.source_repo)
             q = q.filter(ChangesetStatus.revision.in_(pull_request.revisions))
         cur_statuses = q.all()
 
         # if statuses exists and last is associated with a closed pull request
         # we need to check if we can allow this status change
         if (dont_allow_on_closed_pull_request and cur_statuses
             and getattr(cur_statuses[0].pull_request, 'status', '')
                 == PullRequest.STATUS_CLOSED):
             raise StatusChangeOnClosedPullRequestError(
                 'Changing status on closed pull request is not allowed'
             )
 
         # update all current statuses with older version
         if cur_statuses:
             for st in cur_statuses:
                 st.version += 1
                 Session().add(st)
             Session().flush()
 
         def _create_status(user, repo, status, comment, revision, pull_request):
             new_status = ChangesetStatus()
             new_status.author = self._get_user(user)
             new_status.repo = self._get_repo(repo)
             new_status.status = status
             new_status.comment = comment
             new_status.revision = revision
             new_status.pull_request = pull_request
             return new_status
 
         if not comment:
             from rhodecode.model.comment import CommentsModel
             comment = CommentsModel().create(
                 text=self._render_auto_status_message(
                     status, commit_id=revision, pull_request=pull_request),
                 repo=repo,
                 user=user,
                 pull_request=pull_request,
                 send_email=False, renderer=DEFAULT_COMMENTS_RENDERER
             )
 
         if revision:
             new_status = _create_status(
                 user=user, repo=repo, status=status, comment=comment,
                 revision=revision, pull_request=pull_request)
             Session().add(new_status)
             return new_status
         elif pull_request:
             # pull request can have more than one revision associated to it
             # we need to create new version for each one
             new_statuses = []
             repo = pull_request.source_repo
             for rev in pull_request.revisions:
                 new_status = _create_status(
                     user=user, repo=repo, status=status, comment=comment,
                     revision=rev, pull_request=pull_request)
                 new_statuses.append(new_status)
                 Session().add(new_status)
             return new_statuses
 
     def aggregate_votes_by_user(self, commit_statuses, reviewers_data):
 
         commit_statuses_map = collections.defaultdict(list)
         for st in commit_statuses:
             commit_statuses_map[st.author.username] += [st]
 
         reviewers = []
 
         def version(commit_status):
             return commit_status.version
 
         for obj in reviewers_data:
             if not obj.user:
                 continue
             statuses = commit_statuses_map.get(obj.user.username, None)
             if statuses:
                 status_groups = itertools.groupby(
                     sorted(statuses, key=version), version)
                 statuses = [(x, list(y)[0]) for x, y in status_groups]
 
             reviewers.append((obj, obj.user, obj.reasons, obj.mandatory, statuses))
 
         return reviewers
 
     def reviewers_statuses(self, pull_request):
         _commit_statuses = self.get_statuses(
             pull_request.source_repo,
             pull_request=pull_request,
             with_revisions=True)
 
         return self.aggregate_votes_by_user(_commit_statuses, pull_request.reviewers)
 
     def calculated_review_status(self, pull_request, reviewers_statuses=None):
         """
         calculate pull request status based on reviewers, it should be a list
         of two element lists.
 
         :param reviewers_statuses:
         """
         reviewers = reviewers_statuses or self.reviewers_statuses(pull_request)
         return self.calculate_status(reviewers)

rhodecode/public/js/src/rhodecode.js

@@ -1,697 +1,706 b''
 // # Copyright (C) 2010-2020 RhodeCode GmbH
 // #
 // # This program is free software: you can redistribute it and/or modify
 // # it under the terms of the GNU Affero General Public License, version 3
 // # (only), as published by the Free Software Foundation.
 // #
 // # This program is distributed in the hope that it will be useful,
 // # but WITHOUT ANY WARRANTY; without even the implied warranty of
 // # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 // # GNU General Public License for more details.
 // #
 // # You should have received a copy of the GNU Affero General Public License
 // # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // #
 // # This program is dual-licensed. If you wish to learn more about the
 // # RhodeCode Enterprise Edition, including its added features, Support services,
 // # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 /**
 RhodeCode JS Files
 **/
 
 if (typeof console == "undefined" || typeof console.log == "undefined"){
     console = { log: function() {} }
 }
 
 // TODO: move the following function to submodules
 
 /**
  * show more
  */
 var show_more_event = function(){
   $('table .show_more').click(function(e) {
     var cid = e.target.id.substring(1);
     var button = $(this);
     if (button.hasClass('open')) {
       $('#'+cid).hide();
       button.removeClass('open');
     } else {
       $('#'+cid).show();
       button.addClass('open one');
     }
   });
 };
 
 var compare_radio_buttons = function(repo_name, compare_ref_type){
     $('#compare_action').on('click', function(e){
         e.preventDefault();
 
         var source = $('input[name=compare_source]:checked').val();
         var target = $('input[name=compare_target]:checked').val();
         if(source && target){
             var url_data = {
                 repo_name: repo_name,
                 source_ref: source,
                 source_ref_type: compare_ref_type,
                 target_ref: target,
                 target_ref_type: compare_ref_type,
                 merge: 1
             };
             window.location = pyroutes.url('repo_compare', url_data);
         }
     });
     $('.compare-radio-button').on('click', function(e){
         var source = $('input[name=compare_source]:checked').val();
         var target = $('input[name=compare_target]:checked').val();
         if(source && target){
             $('#compare_action').removeAttr("disabled");
             $('#compare_action').removeClass("disabled");
         }
     })
 };
 
 var showRepoSize = function(target, repo_name, commit_id, callback) {
     var container = $('#' + target);
     var url = pyroutes.url('repo_stats',
       {"repo_name": repo_name, "commit_id": commit_id});
 
     container.show();
     if (!container.hasClass('loaded')) {
         $.ajax({url: url})
             .complete(function (data) {
                 var responseJSON = data.responseJSON;
                 container.addClass('loaded');
                 container.html(responseJSON.size);
                 callback(responseJSON.code_stats)
             })
             .fail(function (data) {
                 console.log('failed to load repo stats');
             });
     }
 
 };
 
 var showRepoStats = function(target, data){
     var container = $('#' + target);
 
     if (container.hasClass('loaded')) {
         return
     }
 
     var total = 0;
     var no_data = true;
     var tbl = document.createElement('table');
     tbl.setAttribute('class', 'trending_language_tbl rctable');
 
     $.each(data, function(key, val){
         total += val.count;
     });
 
     var sortedStats = [];
     for (var obj in data){
         sortedStats.push([obj, data[obj]])
     }
     var sortedData = sortedStats.sort(function (a, b) {
         return b[1].count - a[1].count
     });
     var cnt = 0;
     $.each(sortedData, function(idx, val){
         cnt += 1;
         no_data = false;
 
         var tr = document.createElement('tr');
 
         var key = val[0];
         var obj = {"desc": val[1].desc, "count": val[1].count};
 
         // meta language names
         var td1 = document.createElement('td');
         var trending_language_label = document.createElement('div');
         trending_language_label.innerHTML = obj.desc;
         td1.appendChild(trending_language_label);
 
         // extensions
         var td2 = document.createElement('td');
         var extension = document.createElement('div');
         extension.innerHTML = ".{0}".format(key)
         td2.appendChild(extension);
 
         // number of files
         var td3 = document.createElement('td');
         var file_count = document.createElement('div');
         var percentage_num = Math.round((obj.count / total * 100), 2);
         var label = _ngettext('file', 'files', obj.count);
         file_count.innerHTML = "{0} {1} ({2}%)".format(obj.count, label, percentage_num) ;
         td3.appendChild(file_count);
 
         // percentage
         var td4 = document.createElement('td');
         td4.setAttribute("class", 'trending_language');
 
         var percentage = document.createElement('div');
         percentage.setAttribute('class', 'lang-bar');
         percentage.innerHTML = "&nbsp;";
         percentage.style.width = percentage_num + '%';
         td4.appendChild(percentage);
 
         tr.appendChild(td1);
         tr.appendChild(td2);
         tr.appendChild(td3);
         tr.appendChild(td4);
         tbl.appendChild(tr);
 
     });
 
     $(container).html(tbl);
     $(container).addClass('loaded');
 
     $('#code_stats_show_more').on('click', function (e) {
         e.preventDefault();
         $('.stats_hidden').each(function (idx) {
             $(this).css("display", "");
         });
         $('#code_stats_show_more').hide();
     });
 
 };
 
 // returns a node from given html;
 var fromHTML = function(html){
   var _html = document.createElement('element');
   _html.innerHTML = html;
   return _html;
 };
 
 // Toggle Collapsable Content
 function collapsableContent() {
 
     $('.collapsable-content').not('.no-hide').hide();
 
     $('.btn-collapse').unbind(); //in case we've been here before
     $('.btn-collapse').click(function() {
         var button = $(this);
         var togglename = $(this).data("toggle");
         $('.collapsable-content[data-toggle='+togglename+']').toggle();
         if ($(this).html()=="Show Less")
             $(this).html("Show More");
         else
             $(this).html("Show Less");
     });
 };
 
 var timeagoActivate = function() {
     $("time.timeago").timeago();
 };
 
 
 var clipboardActivate = function() {
     /*
     *
     * <i class="tooltip icon-plus clipboard-action" data-clipboard-text="${commit.raw_id}" title="${_('Copy the full commit id')}"></i>
     * */
     var clipboard = new ClipboardJS('.clipboard-action');
 
     clipboard.on('success', function(e) {
         var callback = function () {
             $(e.trigger).animate({'opacity': 1.00}, 200)
         };
         $(e.trigger).animate({'opacity': 0.15}, 200, callback);
         e.clearSelection();
     });
 };
 
 var tooltipActivate = function () {
     var delay = 50;
     var animation = 'fade';
     var theme = 'tooltipster-shadow';
     var debug = false;
 
     $('.tooltip').tooltipster({
         debug: debug,
         theme: theme,
         animation: animation,
         delay: delay,
         contentCloning: true,
         contentAsHTML: true,
 
         functionBefore: function (instance, helper) {
             var $origin = $(helper.origin);
             var data = '<div style="white-space: pre-wrap">{0}</div>'.format(instance.content());
             instance.content(data);
         }
     });
     var hovercardCache = {};
 
     var loadHoverCard = function (url, altHovercard, callback) {
         var id = url;
 
         if (hovercardCache[id] !== undefined) {
             callback(hovercardCache[id]);
             return true;
         }
 
         hovercardCache[id] = undefined;
         $.get(url, function (data) {
             hovercardCache[id] = data;
             callback(hovercardCache[id]);
             return true;
         }).fail(function (data, textStatus, errorThrown) {
 
             if (parseInt(data.status) === 404) {
                 var msg = "<p>{0}</p>".format(altHovercard || "No Data exists for this hovercard");
             } else {
                 var msg = "<p class='error-message'>Error while fetching hovercard.\nError code {0} ({1}).</p>".format(data.status,data.statusText);
             }
             callback(msg);
             return false
         });
     };
 
     $('.tooltip-hovercard').tooltipster({
         debug: debug,
         theme: theme,
         animation: animation,
         delay: delay,
         interactive: true,
         contentCloning: true,
 
         trigger: 'custom',
         triggerOpen: {
             mouseenter: true,
         },
         triggerClose: {
             mouseleave: true,
             originClick: true,
             touchleave: true
         },
         content: _gettext('Loading...'),
         contentAsHTML: true,
         updateAnimation: null,
 
         functionBefore: function (instance, helper) {
 
             var $origin = $(helper.origin);
 
             // we set a variable so the data is only loaded once via Ajax, not every time the tooltip opens
             if ($origin.data('loaded') !== true) {
                 var hovercardUrl = $origin.data('hovercardUrl');
-                var altHovercard =$origin.data('hovercardAlt');
+                var altHovercard = $origin.data('hovercardAlt');
 
                 if (hovercardUrl !== undefined && hovercardUrl !== "") {
-                    if (hovercardUrl.substr(0,12) === 'pyroutes.url'){
+                    var urlLoad = true;
+                    if (hovercardUrl.substr(0, 12) === 'pyroutes.url') {
                         hovercardUrl = eval(hovercardUrl)
+                    } else if (hovercardUrl.substr(0, 11) === 'javascript:') {
+                        var jsFunc = hovercardUrl.substr(11);
+                        urlLoad = false;
+                        loaded = true;
+                        instance.content(eval(jsFunc))
                     }
 
-                    var loaded = loadHoverCard(hovercardUrl, altHovercard, function (data) {
-                        instance.content(data);
-                    })
+                    if (urlLoad) {
+                        var loaded = loadHoverCard(hovercardUrl, altHovercard, function (data) {
+                            instance.content(data);
+                        })
+                    }
+
                 } else {
                     if ($origin.data('hovercardAltHtml')) {
                         var data =  atob($origin.data('hovercardAltHtml'));
                     } else {
                         var data = '<div style="white-space: pre-wrap">{0}</div>'.format(altHovercard)
                     }
                     var loaded = true;
                     instance.content(data);
                 }
 
                 // to remember that the data has been loaded
                 $origin.data('loaded', loaded);
             }
         }
     })
 };
 
 // Formatting values in a Select2 dropdown of commit references
 var formatSelect2SelectionRefs = function(commit_ref){
   var tmpl = '';
   if (!commit_ref.text || commit_ref.type === 'sha'){
     return commit_ref.text;
   }
   if (commit_ref.type === 'branch'){
     tmpl = tmpl.concat('<i class="icon-branch"></i> ');
   } else if (commit_ref.type === 'tag'){
     tmpl = tmpl.concat('<i class="icon-tag"></i> ');
   } else if (commit_ref.type === 'book'){
     tmpl = tmpl.concat('<i class="icon-bookmark"></i> ');
   }
   return tmpl.concat(escapeHtml(commit_ref.text));
 };
 
 // takes a given html element and scrolls it down offset pixels
 function offsetScroll(element, offset) {
     setTimeout(function() {
         var location = element.offset().top;
         // some browsers use body, some use html
         $('html, body').animate({ scrollTop: (location - offset) });
     }, 100);
 }
 
 // scroll an element `percent`% from the top of page in `time` ms
 function scrollToElement(element, percent, time) {
     percent = (percent === undefined ? 25 : percent);
     time = (time === undefined ? 100 : time);
 
     var $element = $(element);
     if ($element.length == 0) {
         throw('Cannot scroll to {0}'.format(element))
     }
     var elOffset = $element.offset().top;
     var elHeight = $element.height();
     var windowHeight = $(window).height();
     var offset = elOffset;
     if (elHeight < windowHeight) {
         offset = elOffset - ((windowHeight / (100 / percent)) - (elHeight / 2));
     }
     setTimeout(function() {
         $('html, body').animate({ scrollTop: offset});
     }, time);
 }
 
 /**
  * global hooks after DOM is loaded
  */
 $(document).ready(function() {
     firefoxAnchorFix();
 
     $('.navigation a.menulink').on('click', function(e){
         var menuitem = $(this).parent('li');
         if (menuitem.hasClass('open')) {
             menuitem.removeClass('open');
         } else {
             menuitem.addClass('open');
             $(document).on('click', function(event) {
                 if (!$(event.target).closest(menuitem).length) {
                     menuitem.removeClass('open');
                 }
             });
         }
     });
 
     $('body').on('click', '.cb-lineno a', function(event) {
         function sortNumber(a,b) {
             return a - b;
         }
 
         var lineNo = $(this).data('lineNo');
         var lineName = $(this).attr('name');
 
         if (lineNo) {
             var prevLine = $('.cb-line-selected a').data('lineNo');
 
             // on shift, we do a range selection, if we got previous line
             if (event.shiftKey && prevLine !== undefined) {
                 var prevLine = parseInt(prevLine);
                 var nextLine = parseInt(lineNo);
                 var pos = [prevLine, nextLine].sort(sortNumber);
                 var anchor = '#L{0}-{1}'.format(pos[0], pos[1]);
 
             // single click
             } else {
                 var nextLine = parseInt(lineNo);
                 var pos = [nextLine, nextLine];
                 var anchor = '#L{0}'.format(pos[0]);
 
             }
             // highlight
             var range = [];
             for (var i = pos[0]; i <= pos[1]; i++) {
                 range.push(i);
             }
             // clear old selected lines
             $('.cb-line-selected').removeClass('cb-line-selected');
 
             $.each(range, function (i, lineNo) {
                 var line_td = $('td.cb-lineno#L' + lineNo);
 
                 if (line_td.length) {
                     line_td.addClass('cb-line-selected'); // line number td
                     line_td.prev().addClass('cb-line-selected'); // line data
                     line_td.next().addClass('cb-line-selected'); // line content
                 }
             });
 
         } else if (lineName !== undefined) { // lineName only occurs in diffs
             // clear old selected lines
             $('td.cb-line-selected').removeClass('cb-line-selected');
             var anchor = '#{0}'.format(lineName);
             var diffmode = templateContext.session_attrs.diffmode || "sideside";
 
             if (diffmode === "unified") {
                 $(this).closest('tr').find('td').addClass('cb-line-selected');
             } else {
                 var activeTd = $(this).closest('td');
                 activeTd.addClass('cb-line-selected');
                 activeTd.next('td').addClass('cb-line-selected');
             }
 
         }
 
         // Replace URL without jumping to it if browser supports.
         // Default otherwise
         if (history.pushState && anchor !== undefined) {
             var new_location = location.href.rstrip('#');
             if (location.hash) {
                 // location without hash
                 new_location = new_location.replace(location.hash, "");
             }
 
             // Make new anchor url
             new_location = new_location + anchor;
             history.pushState(true, document.title, new_location);
 
             return false;
         }
 
     });
 
     $('.collapse_file').on('click', function(e) {
         e.stopPropagation();
         if ($(e.target).is('a')) { return; }
         var node = $(e.delegateTarget).first();
         var icon = $($(node.children().first()).children().first());
         var id = node.attr('fid');
         var target = $('#'+id);
         var tr = $('#tr_'+id);
         var diff = $('#diff_'+id);
         if(node.hasClass('expand_file')){
             node.removeClass('expand_file');
             icon.removeClass('expand_file_icon');
             node.addClass('collapse_file');
             icon.addClass('collapse_file_icon');
             diff.show();
             tr.show();
             target.show();
         } else {
             node.removeClass('collapse_file');
             icon.removeClass('collapse_file_icon');
             node.addClass('expand_file');
             icon.addClass('expand_file_icon');
             diff.hide();
             tr.hide();
             target.hide();
         }
     });
 
     $('#expand_all_files').click(function() {
         $('.expand_file').each(function() {
             var node = $(this);
             var icon = $($(node.children().first()).children().first());
             var id = $(this).attr('fid');
             var target = $('#'+id);
             var tr = $('#tr_'+id);
             var diff = $('#diff_'+id);
             node.removeClass('expand_file');
             icon.removeClass('expand_file_icon');
             node.addClass('collapse_file');
             icon.addClass('collapse_file_icon');
             diff.show();
             tr.show();
             target.show();
         });
     });
 
     $('#collapse_all_files').click(function() {
         $('.collapse_file').each(function() {
             var node = $(this);
             var icon = $($(node.children().first()).children().first());
             var id = $(this).attr('fid');
             var target = $('#'+id);
             var tr = $('#tr_'+id);
             var diff = $('#diff_'+id);
             node.removeClass('collapse_file');
             icon.removeClass('collapse_file_icon');
             node.addClass('expand_file');
             icon.addClass('expand_file_icon');
             diff.hide();
             tr.hide();
             target.hide();
         });
     });
 
     // Mouse over behavior for comments and line selection
 
     // Select the line that comes from the url anchor
     // At the time of development, Chrome didn't seem to support jquery's :target
     // element, so I had to scroll manually
 
     if (location.hash) {
         var result = splitDelimitedHash(location.hash);
 
         var loc = result.loc;
 
         if (loc.length > 1) {
 
             var highlightable_line_tds = [];
 
             // source code line format
             var page_highlights = loc.substring(loc.indexOf('#') + 1).split('L');
 
             // multi-line HL, for files
             if (page_highlights.length > 1) {
                 var highlight_ranges = page_highlights[1].split(",");
                 var h_lines = [];
                 for (var pos in highlight_ranges) {
                     var _range = highlight_ranges[pos].split('-');
                     if (_range.length === 2) {
                         var start = parseInt(_range[0]);
                         var end = parseInt(_range[1]);
                         if (start < end) {
                             for (var i = start; i <= end; i++) {
                                 h_lines.push(i);
                             }
                         }
                     } else {
                         h_lines.push(parseInt(highlight_ranges[pos]));
                     }
                 }
                 for (pos in h_lines) {
                     var line_td = $('td.cb-lineno#L' + h_lines[pos]);
                     if (line_td.length) {
                         highlightable_line_tds.push(line_td);
                     }
                 }
             }
 
             // now check a direct id reference of line in diff / pull-request page)
             if ($(loc).length > 0 && $(loc).hasClass('cb-lineno')) {
                 highlightable_line_tds.push($(loc));
             }
 
             // mark diff lines as selected
             $.each(highlightable_line_tds, function (i, $td) {
                 $td.addClass('cb-line-selected'); // line number td
                 $td.prev().addClass('cb-line-selected'); // line data
                 $td.next().addClass('cb-line-selected'); // line content
             });
 
             if (highlightable_line_tds.length > 0) {
                 var $first_line_td = highlightable_line_tds[0];
                 scrollToElement($first_line_td);
                 $.Topic('/ui/plugins/code/anchor_focus').prepareOrPublish({
                     td: $first_line_td,
                     remainder: result.remainder
                 });
             } else {
                 // case for direct anchor to comments
                 var $line = $(loc);
 
                 if ($line.hasClass('comment-general')) {
                     $line.show();
                 } else if ($line.hasClass('comment-inline')) {
                     $line.show();
                     var $cb = $line.closest('.cb');
                     $cb.removeClass('cb-collapsed')
                 }
                 if ($line.length > 0) {
                     $line.addClass('comment-selected-hl');
                     offsetScroll($line, 70);
                 }
                 if (!$line.hasClass('comment-outdated') && result.remainder === '/ReplyToComment') {
                     $line.nextAll('.cb-comment-add-button').trigger('click');
                 }
             }
 
         }
     }
     collapsableContent();
 });
 
 var feedLifetimeOptions = function(query, initialData){
     var data = {results: []};
     var isQuery = typeof query.term !== 'undefined';
 
     var section = _gettext('Lifetime');
     var children = [];
 
     //filter results
     $.each(initialData.results, function(idx, value) {
 
         if (!isQuery || query.term.length === 0 || value.text.toUpperCase().indexOf(query.term.toUpperCase()) >= 0) {
             children.push({
                 'id': this.id,
                 'text': this.text
             })
         }
 
     });
     data.results.push({
         'text': section,
         'children': children
     });
 
     if (isQuery) {
 
         var now = moment.utc();
 
         var parseQuery = function(entry, now){
             var fmt = 'DD/MM/YYYY H:mm';
             var parsed = moment.utc(entry, fmt);
             var diffInMin = parsed.diff(now, 'minutes');
 
             if (diffInMin > 0){
                 return {
                     id: diffInMin,
                     text: parsed.format(fmt)
                 }
             } else {
                 return {
                     id: undefined,
                     text: parsed.format('DD/MM/YYYY') + ' ' + _gettext('date not in future')
                 }
             }
 
 
         };
 
         data.results.push({
             'text': _gettext('Specified expiration date'),
             'children': [{
                 'id': parseQuery(query.term, now).id,
                 'text': parseQuery(query.term, now).text
             }]
         });
     }
 
     query.callback(data);
 };
 
 /*
 * Retrievew via  templateContext.session_attrs.key
 * */
 var storeUserSessionAttr = function (key, val) {
 
     var postData = {
         'key': key,
         'val': val,
         'csrf_token': CSRF_TOKEN
     };
 
     var success = function(o) {
         return true
     };
 
     ajaxPOST(pyroutes.url('store_user_session_value'), postData, success);
     return false;
 };

rhodecode/templates/base/sidebar.mako

@@ -1,134 +1,140 b''
 ## snippet for sidebar elements
 ## usage:
 ##    <%namespace name="sidebar" file="/base/sidebar.mako"/>
 ##    ${sidebar.comments_table()}
 <%namespace name="base" file="/base/base.mako"/>
 
 <%def name="comments_table(comments, counter_num, todo_comments=False, existing_ids=None, is_pr=True)">
     <%
         if todo_comments:
             cls_ = 'todos-content-table'
             def sorter(entry):
                 user_id = entry.author.user_id
                 resolved = '1' if entry.resolved else '0'
                 if user_id == c.rhodecode_user.user_id:
                     # own comments first
                     user_id = 0
                 return '{}'.format(str(entry.comment_id).zfill(10000))
         else:
             cls_ = 'comments-content-table'
             def sorter(entry):
                 user_id = entry.author.user_id
                 return '{}'.format(str(entry.comment_id).zfill(10000))
 
         existing_ids = existing_ids or []
 
     %>
 
     <table class="todo-table ${cls_}" data-total-count="${len(comments)}" data-counter="${counter_num}">
 
      % for loop_obj, comment_obj in h.looper(reversed(sorted(comments, key=sorter))):
          <%
             display = ''
             _cls = ''
          %>
 
          <%
              comment_ver_index = comment_obj.get_index_version(getattr(c, 'versions', []))
              prev_comment_ver_index = 0
              if loop_obj.previous:
                 prev_comment_ver_index = loop_obj.previous.get_index_version(getattr(c, 'versions', []))
 
              ver_info = None
              if getattr(c, 'versions', []):
                 ver_info = c.versions[comment_ver_index-1] if comment_ver_index else None
          %>
          <% hidden_at_ver = comment_obj.outdated_at_version_js(c.at_version_num) %>
          <% is_from_old_ver = comment_obj.older_than_version_js(c.at_version_num) %>
          <%
          if (prev_comment_ver_index > comment_ver_index):
            comments_ver_divider = comment_ver_index
          else:
             comments_ver_divider = None
          %>
 
           % if todo_comments:
               % if comment_obj.resolved:
                   <% _cls = 'resolved-todo' %>
                   <% display = 'none' %>
               % endif
           % else:
               ## SKIP TODOs we display them in other area
               % if comment_obj.is_todo:
                   <% display = 'none' %>
               % endif
               ## Skip outdated comments
               % if comment_obj.outdated:
                   <% display = 'none' %>
                   <% _cls = 'hidden-comment' %>
               % endif
           % endif
 
           % if not todo_comments and comments_ver_divider:
           <tr class="old-comments-marker">
               <td colspan="3">
                   % if ver_info:
                     <code>v${comments_ver_divider} ${h.age_component(ver_info.created_on, time_is_local=True, tooltip=False)}</code>
                   % else:
                     <code>v${comments_ver_divider}</code>
                   % endif
               </td>
           </tr>
 
           % endif
 
           <tr class="${_cls}" style="display: ${display};" data-sidebar-comment-id="${comment_obj.comment_id}">
               <td class="td-todo-number">
-
-                  <a class="${('todo-resolved' if comment_obj.resolved else '')} permalink"
-                     href="#comment-${comment_obj.comment_id}"
-                     onclick="return Rhodecode.comments.scrollToComment($('#comment-${comment_obj.comment_id}'), 0, ${hidden_at_ver})">
-
                   <%
                     version_info = ''
                     if is_pr:
                         version_info = (' made in older version (v{})'.format(comment_ver_index) if is_from_old_ver == 'true' else ' made in this version')
                   %>
+                  <script type="text/javascript">
+                      // closure function helper
+                      var sidebarComment${comment_obj.comment_id} = function() {
+                        return renderTemplate('sideBarCommentHovercard', {
+                            version_info: "${version_info}",
+                            file_name: "${comment_obj.f_path}",
+                            line_no: "${comment_obj.line_no}",
+                            outdated: ${h.json.dumps(comment_obj.outdated)},
+                            inline: ${h.json.dumps(comment_obj.is_inline)},
+                            is_todo: ${h.json.dumps(comment_obj.is_todo)},
+                            created_on: "${h.format_date(comment_obj.created_on)}",
+                            datetime: "${comment_obj.created_on}${h.get_timezone(comment_obj.created_on, time_is_local=True)}",
+                        })
+                      }
+                  </script>
 
-                  % if todo_comments:
-                    % if comment_obj.is_inline:
-                      <i class="tooltip icon-code" title="Inline TODO comment${version_info}."></i>
-                    % else:
-                      <i class="tooltip icon-comment" title="General TODO comment${version_info}."></i>
-                    % endif
+                  % if comment_obj.outdated:
+                    <i class="icon-comment-toggle tooltip-hovercard" data-hovercard-url="javascript:sidebarComment${comment_obj.comment_id}()"></i>
+                  % elif comment_obj.is_inline:
+                    <i class="icon-code tooltip-hovercard" data-hovercard-url="javascript:sidebarComment${comment_obj.comment_id}()"></i>
                   % else:
-                    % if comment_obj.outdated:
-                      <i class="tooltip icon-comment-toggle" title="Inline Outdated made in v${comment_ver_index}."></i>
-                    % elif comment_obj.is_inline:
-                      <i class="tooltip icon-code" title="Inline comment${version_info}."></i>
-                    % else:
-                      <i class="tooltip icon-comment" title="General comment${version_info}."></i>
-                    % endif
+                    <i class="icon-comment tooltip-hovercard" data-hovercard-url="javascript:sidebarComment${comment_obj.comment_id}()"></i>
                   % endif
 
-                  </a>
                   ## NEW, since refresh
                   % if existing_ids and comment_obj.comment_id not in existing_ids:
                       <span class="tag">NEW</span>
                   % endif
               </td>
 
               <td class="td-todo-gravatar">
                   ${base.gravatar(comment_obj.author.email, 16, user=comment_obj.author, tooltip=True, extra_class=['no-margin'])}
               </td>
               <td class="todo-comment-text-wrapper">
-                  <div class="tooltip todo-comment-text timeago ${('todo-resolved' if comment_obj.resolved else '')} " title="${h.format_date(comment_obj.created_on)}" datetime="${comment_obj.created_on}${h.get_timezone(comment_obj.created_on, time_is_local=True)}">
-                    <code>${h.chop_at_smart(comment_obj.text, '\n', suffix_if_chopped='...')}</code>
+                  <div class="todo-comment-text ${('todo-resolved' if comment_obj.resolved else '')}">
+                      <a class="${('todo-resolved' if comment_obj.resolved else '')} permalink"
+                         href="#comment-${comment_obj.comment_id}"
+                         onclick="return Rhodecode.comments.scrollToComment($('#comment-${comment_obj.comment_id}'), 0, ${hidden_at_ver})">
+
+                         ${h.chop_at_smart(comment_obj.text, '\n', suffix_if_chopped='...')}
+                      </a>
                   </div>
               </td>
           </tr>
      % endfor
 
     </table>
 
 </%def>
  No newline at end of file

rhodecode/templates/ejs_templates/templates.html

@@ -1,193 +1,236 b''
 <%text>
 <div style="display: none">
 
 <script>
 var CG = new ColorGenerator();
 </script>
 
 <script id="ejs_gravatarWithUser" type="text/template" class="ejsTemplate">
 
 <%
 if (size > 16) {
     var gravatar_class = 'gravatar gravatar-large';
 } else {
     var gravatar_class = 'gravatar';
 }
 
 if (tooltip) {
     var gravatar_class = gravatar_class + ' tooltip-hovercard';
 }
 
 var data_hovercard_alt = username;
 
 %>
 
 <%
 if (show_disabled) {
     var user_cls = 'user user-disabled';
 } else {
     var user_cls = 'user';
 }
 var data_hovercard_url = pyroutes.url('hovercard_user', {"user_id": user_id})
 %>
 
 <div class="rc-user">
     <img class="<%= gravatar_class %>" height="<%= size %>" width="<%= size %>" data-hovercard-url="<%= data_hovercard_url %>" data-hovercard-alt="<%= data_hovercard_alt %>" src="<%- gravatar_url -%>">
     <span class="<%= user_cls %>"> <%- user_link -%> </span>
 </div>
 
 </script>
 
 <script id="ejs_reviewMemberEntry" type="text/template" class="ejsTemplate">
     <%
         if (create) {
             var edit_visibility = 'visible';
         } else {
             var edit_visibility = 'hidden';
         }
 
         if (member.user_group && member.user_group.vote_rule) {
             var reviewGroup = '<i class="icon-user-group"></i>';
             var reviewGroupColor = CG.asRGB(CG.getColor(member.user_group.vote_rule));
         } else {
             var reviewGroup = null;
             var reviewGroupColor = 'transparent';
         }
         var rule_show = rule_show || false;
 
         if (rule_show) {
             var rule_visibility = 'table-cell';
         } else {
             var rule_visibility = 'none';
         }
 
     %>
 
 <tr id="reviewer_<%= member.user_id %>" class="reviewer_entry" tooltip="Review Group" data-reviewer-user-id="<%= member.user_id %>">
 
     <td style="width: 20px">
         <div class="reviewer_status tooltip" title="<%= review_status_label %>">
           <i class="icon-circle review-status-<%= review_status %>"></i>
         </div>
     </td>
 
     <td>
       <div id="reviewer_<%= member.user_id %>_name" class="reviewer_name">
         <%-
           renderTemplate('gravatarWithUser', {
             'size': 16,
             'show_disabled': false,
             'tooltip': true,
             'username': member.username,
             'user_id': member.user_id,
             'user_link': member.user_link,
             'gravatar_url':  member.gravatar_link
             })
         %>
         <span class="tooltip presence-state" style="display: none" title="This users is currently at this page">
           <i class="icon-eye" style="color: #0ac878"></i>
         </span>
       </div>
     </td>
 
     <td style="width: 10px">
     <% if (reviewGroup !== null) { %>
         <span class="tooltip" title="Member of review group from rule: `<%= member.user_group.name %>`" style="color: <%= reviewGroupColor %>">
         <%- reviewGroup %>
         </span>
     <% } %>
     </td>
 
     <% if (mandatory) { %>
     <td style="text-align: right;width: 10px;">
         <div class="reviewer_member_mandatory tooltip" title="Mandatory reviewer">
             <i class="icon-lock"></i>
         </div>
     </td>
 
     <% } else { %>
     <td style="text-align: right;width: 10px;">
         <% if (allowed_to_update) { %>
           <div class="reviewer_member_remove" onclick="reviewersController.removeReviewMember(<%= member.user_id %>, true)" style="visibility: <%= edit_visibility %>;">
               <i class="icon-remove"></i>
           </div>
         <% } %>
     </td>
     <% } %>
 
 </tr>
 
 <tr>
     <td colspan="4" style="display: <%= rule_visibility %>" class="pr-user-rule-container">
       <input type="hidden" name="__start__" value="reviewer:mapping">
 
         <%if (member.user_group && member.user_group.vote_rule) { %>
             <div class="reviewer_reason">
 
               <%if (member.user_group.vote_rule == -1) {%>
                - group votes required: ALL
               <%} else {%>
                - group votes required: <%= member.user_group.vote_rule %>
               <%}%>
             </div>
         <%} %>
 
         <input type="hidden" name="__start__" value="reasons:sequence">
           <% for (var i = 0; i < reasons.length; i++) { %>
               <% var reason = reasons[i] %>
               <div class="reviewer_reason">- <%= reason %></div>
               <input type="hidden" name="reason" value="<%= reason %>">
           <% } %>
           <input type="hidden" name="__end__" value="reasons:sequence">
 
           <input type="hidden" name="__start__" value="rules:sequence">
           <% for (var i = 0; i < member.rules.length; i++) { %>
               <% var rule = member.rules[i] %>
               <input type="hidden" name="rule_id" value="<%= rule %>">
           <% } %>
           <input type="hidden" name="__end__" value="rules:sequence">
 
           <input id="reviewer_<%= member.user_id %>_input" type="hidden" value="<%= member.user_id %>" name="user_id" />
           <input type="hidden" name="mandatory" value="<%= mandatory %>"/>
 
       <input type="hidden" name="__end__" value="reviewer:mapping">
     </td>
 </tr>
 
 </script>
 
 <script id="ejs_commentVersion" type="text/template" class="ejsTemplate">
 
 <%
 if (size > 16) {
     var gravatar_class = 'gravatar gravatar-large';
 } else {
     var gravatar_class = 'gravatar';
 }
 
 %>
 
 <%
 if (show_disabled) {
     var user_cls = 'user user-disabled';
 } else {
     var user_cls = 'user';
 }
 
 %>
 
 <div style='line-height: 20px'>
     <img style="margin: -3px 0" class="<%= gravatar_class %>" height="<%= size %>" width="<%= size %>" src="<%- gravatar_url -%>">
     <strong><%- user_name -%></strong>, <code>v<%- version -%></code> edited <%- timeago_component -%>
 </div>
 
 </script>
 
+
+<script id="ejs_sideBarCommentHovercard" type="text/template" class="ejsTemplate">
+
+<div>
+    <% if (is_todo) { %>
+        <% if (inline) { %>
+            <strong>Inline</strong> TODO on line: <%= line_no %>
+            <% if (version_info) { %>
+                <%= version_info %>
+            <% } %>
+            <br/>
+            File: <code><%- file_name -%></code>
+        <% } else { %>
+            <strong>General</strong> TODO
+            <% if (version_info) { %>
+                <%= version_info %>
+            <% } %>
+        <% } %>
+    <% } else { %>
+        <% if (inline) { %>
+            <strong>Inline</strong> comment on line: <%= line_no %>
+            <% if (version_info) { %>
+                <%= version_info %>
+            <% } %>
+            <br/>
+            File: <code><%- file_name -%></code>
+        <% } else { %>
+            <strong>General</strong> comment
+            <% if (version_info) { %>
+                <%= version_info %>
+            <% } %>
+        <% } %>
+    <% } %>
+    <br/>
+    Created:
+    <time class="timeago" title="<%= created_on %>" datetime="<%= datetime %>"><%= $.timeago(datetime) %></time>
+
 </div>
 
+</script>
+
+##// END OF EJS Templates
+</div>
+
+
 <script>
     // registers the templates into global cache
     registerTemplates();
 </script>
 
 </%text>