default-reviewers: handle no common ancestor case.

rhodecode/apps/repository/views/repo_review_rules.py

@@ -1,82 +1,89 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2020 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 
 from pyramid.view import view_config
 
 from rhodecode.apps._base import RepoAppView
 from rhodecode.apps.repository.utils import get_default_reviewers_data
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.vcs.backends.base import Reference
 from rhodecode.model.db import Repository
 
 log = logging.getLogger(__name__)
 
 
 class RepoReviewRulesView(RepoAppView):
     def load_default_context(self):
         c = self._get_local_tmpl_context()
         return c
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.admin')
     @view_config(
         route_name='repo_reviewers', request_method='GET',
         renderer='rhodecode:templates/admin/repos/repo_edit.mako')
     def repo_review_rules(self):
         c = self.load_default_context()
         c.active = 'reviewers'
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator(
         'repository.read', 'repository.write', 'repository.admin')
     @view_config(
         route_name='repo_default_reviewers_data', request_method='GET',
         renderer='json_ext')
     def repo_default_reviewers_data(self):
         self.load_default_context()
 
         request = self.request
         source_repo = self.db_repo
         source_repo_name = source_repo.repo_name
         target_repo_name = request.GET.get('target_repo', source_repo_name)
         target_repo = Repository.get_by_repo_name(target_repo_name)
 
         current_user = request.user.get_instance()
 
         source_commit_id = request.GET['source_ref']
         source_type = request.GET['source_ref_type']
         source_name = request.GET['source_ref_name']
 
         target_commit_id = request.GET['target_ref']
         target_type = request.GET['target_ref_type']
         target_name = request.GET['target_ref_name']
 
+        try:
         review_data = get_default_reviewers_data(
             current_user,
             source_repo,
             Reference(source_type, source_name, source_commit_id),
             target_repo,
             Reference(target_type, target_name, target_commit_id)
         )
+        except ValueError:
+            # No common ancestor
+            msg = "No Common ancestor found between target and source reference"
+            log.exception(msg)
+            return {'diff_info': {'error': msg}}
+
         return review_data

rhodecode/public/js/src/rhodecode/pullrequests.js

@@ -1,1188 +1,1191 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/
 
 
 var prButtonLockChecks = {
   'compare': false,
   'reviewers': false
 };
 
 /**
  * lock button until all checks and loads are made. E.g reviewer calculation
  * should prevent from submitting a PR
  * @param lockEnabled
  * @param msg
  * @param scope
  */
 var prButtonLock = function(lockEnabled, msg, scope) {
       scope = scope || 'all';
       if (scope == 'all'){
           prButtonLockChecks['compare'] = !lockEnabled;
           prButtonLockChecks['reviewers'] = !lockEnabled;
       } else if (scope == 'compare') {
           prButtonLockChecks['compare'] = !lockEnabled;
       } else if (scope == 'reviewers'){
           prButtonLockChecks['reviewers'] = !lockEnabled;
       }
       var checksMeet = prButtonLockChecks.compare && prButtonLockChecks.reviewers;
       if (lockEnabled) {
           $('#pr_submit').attr('disabled', 'disabled');
       }
       else if (checksMeet) {
           $('#pr_submit').removeAttr('disabled');
       }
 
       if (msg) {
           $('#pr_open_message').html(msg);
       }
 };
 
 
 /**
 Generate Title and Description for a PullRequest.
 In case of 1 commits, the title and description is that one commit
 in case of multiple commits, we iterate on them with max N number of commits,
 and build description in a form
 - commitN
 - commitN+1
 ...
 
 Title is then constructed from branch names, or other references,
 replacing '-' and '_' into spaces
 
 * @param sourceRef
 * @param elements
 * @param limit
 * @returns {*[]}
 */
 var getTitleAndDescription = function(sourceRefType, sourceRef, elements, limit) {
   var title = '';
   var desc = '';
 
   $.each($(elements).get().reverse().slice(0, limit), function(idx, value) {
       var rawMessage = value['message'];
       desc += '- ' + rawMessage.split('\n')[0].replace(/\n+$/, "") + '\n';
   });
   // only 1 commit, use commit message as title
   if (elements.length === 1) {
       var rawMessage = elements[0]['message'];
       title = rawMessage.split('\n')[0];
   }
   else {
       // use reference name
       var normalizedRef = sourceRef.replace(/-/g, ' ').replace(/_/g, ' ').capitalizeFirstLetter()
       var refType = sourceRefType;
       title = 'Changes from {0}: {1}'.format(refType, normalizedRef);
   }
 
   return [title, desc]
 };
 
 
 window.ReviewersController = function () {
     var self = this;
     this.$loadingIndicator = $('.calculate-reviewers');
     this.$reviewRulesContainer = $('#review_rules');
     this.$rulesList = this.$reviewRulesContainer.find('.pr-reviewer-rules');
     this.$userRule = $('.pr-user-rule-container');
     this.$reviewMembers = $('#review_members');
     this.$observerMembers = $('#observer_members');
 
     this.currentRequest = null;
     this.diffData = null;
     this.enabledRules = [];
     // sync with db.py entries
     this.ROLE_REVIEWER = 'reviewer';
     this.ROLE_OBSERVER = 'observer'
 
     //dummy handler, we might register our own later
     this.diffDataHandler = function (data) {};
 
     this.defaultForbidUsers = function () {
         return [
             {
                 'username': 'default',
                 'user_id': templateContext.default_user.user_id
             }
         ];
     };
 
     // init default forbidden users
     this.forbidUsers = this.defaultForbidUsers();
 
     this.hideReviewRules = function () {
         self.$reviewRulesContainer.hide();
         $(self.$userRule.selector).hide();
     };
 
     this.showReviewRules = function () {
         self.$reviewRulesContainer.show();
         $(self.$userRule.selector).show();
     };
 
     this.addRule = function (ruleText) {
         self.showReviewRules();
         self.enabledRules.push(ruleText);
         return '<div>- {0}</div>'.format(ruleText)
     };
 
     this.increaseCounter = function(role) {
         if (role === self.ROLE_REVIEWER) {
             var $elem = $('#reviewers-cnt')
             var cnt = parseInt($elem.data('count') || 0)
             cnt +=1
             $elem.html(cnt);
             $elem.data('count', cnt);
         }
         else if (role === self.ROLE_OBSERVER) {
             var $elem = $('#observers-cnt');
             var cnt = parseInt($elem.data('count') || 0)
             cnt +=1
             $elem.html(cnt);
             $elem.data('count', cnt);
         }
     }
 
     this.resetCounter = function () {
         var $elem = $('#reviewers-cnt');
 
         $elem.data('count', 0);
         $elem.html(0);
 
         var $elem = $('#observers-cnt');
 
         $elem.data('count', 0);
         $elem.html(0);
     }
 
     this.loadReviewRules = function (data) {
         self.diffData = data;
 
         // reset forbidden Users
         this.forbidUsers = self.defaultForbidUsers();
 
         // reset state of review rules
         self.$rulesList.html('');
 
         if (!data || data.rules === undefined || $.isEmptyObject(data.rules)) {
             // default rule, case for older repo that don't have any rules stored
             self.$rulesList.append(
                 self.addRule(
                     _gettext('All reviewers must vote.'))
             );
             return self.forbidUsers
         }
 
         if (data.rules.voting !== undefined) {
             if (data.rules.voting < 0) {
                 self.$rulesList.append(
                     self.addRule(
                         _gettext('All individual reviewers must vote.'))
                 )
             } else if (data.rules.voting === 1) {
                 self.$rulesList.append(
                     self.addRule(
                         _gettext('At least {0} reviewer must vote.').format(data.rules.voting))
                 )
 
             } else {
                 self.$rulesList.append(
                     self.addRule(
                         _gettext('At least {0} reviewers must vote.').format(data.rules.voting))
                 )
             }
         }
 
         if (data.rules.voting_groups !== undefined) {
             $.each(data.rules.voting_groups, function (index, rule_data) {
                 self.$rulesList.append(
                     self.addRule(rule_data.text)
                 )
             });
         }
 
         if (data.rules.use_code_authors_for_review) {
             self.$rulesList.append(
                 self.addRule(
                     _gettext('Reviewers picked from source code changes.'))
             )
         }
 
         if (data.rules.forbid_adding_reviewers) {
             $('#add_reviewer_input').remove();
             self.$rulesList.append(
                 self.addRule(
                     _gettext('Adding new reviewers is forbidden.'))
             )
         }
 
         if (data.rules.forbid_author_to_review) {
             self.forbidUsers.push(data.rules_data.pr_author);
             self.$rulesList.append(
                 self.addRule(
                     _gettext('Author is not allowed to be a reviewer.'))
             )
         }
 
         if (data.rules.forbid_commit_author_to_review) {
 
             if (data.rules_data.forbidden_users) {
                 $.each(data.rules_data.forbidden_users, function (index, member_data) {
                     self.forbidUsers.push(member_data)
                 });
             }
 
             self.$rulesList.append(
                 self.addRule(
                     _gettext('Commit Authors are not allowed to be a reviewer.'))
             )
         }
 
         // we don't have any rules set, so we inform users about it
         if (self.enabledRules.length === 0) {
             self.addRule(
                 _gettext('No review rules set.'))
         }
 
         return self.forbidUsers
     };
 
     this.emptyTables = function () {
         self.emptyReviewersTable();
         self.emptyObserversTable();
 
         // Also reset counters.
         self.resetCounter();
     }
 
     this.emptyReviewersTable = function (withText) {
         self.$reviewMembers.empty();
         if (withText !== undefined) {
             self.$reviewMembers.html(withText)
         }
     };
 
     this.emptyObserversTable = function (withText) {
         self.$observerMembers.empty();
         if (withText !== undefined) {
             self.$observerMembers.html(withText)
         }
     }
 
     this.loadDefaultReviewers = function (sourceRepo, sourceRef, targetRepo, targetRef) {
 
         if (self.currentRequest) {
             // make sure we cleanup old running requests before triggering this again
             self.currentRequest.abort();
         }
 
         self.$loadingIndicator.show();
 
         // reset reviewer/observe members
         self.emptyTables();
 
         prButtonLock(true, null, 'reviewers');
         $('#user').hide(); // hide user autocomplete before load
         $('#observer').hide(); //hide observer autocomplete before load
 
         // lock PR button, so we cannot send PR before it's calculated
         prButtonLock(true, _gettext('Loading diff ...'), 'compare');
 
         if (sourceRef.length !== 3 || targetRef.length !== 3) {
             // don't load defaults in case we're missing some refs...
             self.$loadingIndicator.hide();
             return
         }
 
         var url = pyroutes.url('repo_default_reviewers_data',
             {
                 'repo_name': templateContext.repo_name,
                 'source_repo': sourceRepo,
                 'source_ref_type': sourceRef[0],
                 'source_ref_name': sourceRef[1],
                 'source_ref': sourceRef[2],
                 'target_repo': targetRepo,
                 'target_ref': targetRef[2],
                 'target_ref_type': sourceRef[0],
                 'target_ref_name': sourceRef[1]
             });
 
         self.currentRequest = $.ajax({
             url: url,
             headers: {'X-PARTIAL-XHR': true},
             type: 'GET',
             success: function (data) {
 
                 self.currentRequest = null;
 
                 // review rules
                 self.loadReviewRules(data);
-                self.handleDiffData(data["diff_info"]);
+                var diffHandled = self.handleDiffData(data["diff_info"]);
+                if (diffHandled === false) {
+                    return
+                }
 
                 for (var i = 0; i < data.reviewers.length; i++) {
                     var reviewer = data.reviewers[i];
                     // load reviewer rules from the repo data
                     self.addMember(reviewer, reviewer.reasons, reviewer.mandatory, reviewer.role);
                 }
 
 
                 self.$loadingIndicator.hide();
                 prButtonLock(false, null, 'reviewers');
 
                 $('#user').show(); // show user autocomplete before load
                 $('#observer').show(); // show observer autocomplete before load
 
                 var commitElements = data["diff_info"]['commits'];
 
                 if (commitElements.length === 0) {
                     var noCommitsMsg = '<span class="alert-text-warning">{0}</span>'.format(
                         _gettext('There are no commits to merge.'));
                     prButtonLock(true, noCommitsMsg, 'all');
 
                 } else {
                     // un-lock PR button, so we cannot send PR before it's calculated
                     prButtonLock(false, null, 'compare');
                 }
 
             },
             error: function (jqXHR, textStatus, errorThrown) {
                 var prefix = "Loading diff and reviewers/observers failed\n"
                 var message = formatErrorMessage(jqXHR, textStatus, errorThrown, prefix);
                 ajaxErrorSwal(message);
             }
         });
 
     };
 
     // check those, refactor
     this.removeMember = function (reviewer_id, mark_delete) {
         var reviewer = $('#reviewer_{0}'.format(reviewer_id));
 
         if (typeof (mark_delete) === undefined) {
             mark_delete = false;
         }
 
         if (mark_delete === true) {
             if (reviewer) {
                 // now delete the input
                 $('#reviewer_{0} input'.format(reviewer_id)).remove();
                 $('#reviewer_{0}_rules input'.format(reviewer_id)).remove();
                 // mark as to-delete
                 var obj = $('#reviewer_{0}_name'.format(reviewer_id));
                 obj.addClass('to-delete');
                 obj.css({"text-decoration": "line-through", "opacity": 0.5});
             }
         } else {
             $('#reviewer_{0}'.format(reviewer_id)).remove();
         }
     };
 
     this.addMember = function (reviewer_obj, reasons, mandatory, role) {
 
         var id = reviewer_obj.user_id;
         var username = reviewer_obj.username;
 
         reasons = reasons || [];
         mandatory = mandatory || false;
         role = role || self.ROLE_REVIEWER
 
         // register current set IDS to check if we don't have this ID already in
         // and prevent duplicates
         var currentIds = [];
 
         $.each($('.reviewer_entry'), function (index, value) {
             currentIds.push($(value).data('reviewerUserId'))
         })
 
         var userAllowedReview = function (userId) {
             var allowed = true;
             $.each(self.forbidUsers, function (index, member_data) {
                 if (parseInt(userId) === member_data['user_id']) {
                     allowed = false;
                     return false // breaks the loop
                 }
             });
             return allowed
         };
 
         var userAllowed = userAllowedReview(id);
 
         if (!userAllowed) {
             alert(_gettext('User `{0}` not allowed to be a reviewer').format(username));
         } else {
             // only add if it's not there
             var alreadyReviewer = currentIds.indexOf(id) != -1;
 
             if (alreadyReviewer) {
                 alert(_gettext('User `{0}` already in reviewers/observers').format(username));
             } else {
 
                 var reviewerEntry = renderTemplate('reviewMemberEntry', {
                     'member': reviewer_obj,
                     'mandatory': mandatory,
                     'role': role,
                     'reasons': reasons,
                     'allowed_to_update': true,
                     'review_status': 'not_reviewed',
                     'review_status_label': _gettext('Not Reviewed'),
                     'user_group': reviewer_obj.user_group,
                     'create': true,
                     'rule_show': true,
                 })
 
                 if (role === self.ROLE_REVIEWER) {
                     $(self.$reviewMembers.selector).append(reviewerEntry);
                     self.increaseCounter(self.ROLE_REVIEWER);
                     $('#reviewer-empty-msg').remove()
                 }
                 else if (role === self.ROLE_OBSERVER) {
                     $(self.$observerMembers.selector).append(reviewerEntry);
                     self.increaseCounter(self.ROLE_OBSERVER);
                     $('#observer-empty-msg').remove();
                 }
 
                 tooltipActivate();
             }
         }
 
     };
 
     this.updateReviewers = function (repo_name, pull_request_id, role) {
         if (role === 'reviewer') {
             var postData = $('#reviewers input').serialize();
             _updatePullRequest(repo_name, pull_request_id, postData);
         } else if (role === 'observer') {
             var postData = $('#observers input').serialize();
             _updatePullRequest(repo_name, pull_request_id, postData);
         }
     };
 
     this.handleDiffData = function (data) {
-        self.diffDataHandler(data)
+        return self.diffDataHandler(data)
     }
 };
 
 
 var _updatePullRequest = function(repo_name, pull_request_id, postData) {
     var url = pyroutes.url(
         'pullrequest_update',
         {"repo_name": repo_name, "pull_request_id": pull_request_id});
     if (typeof postData === 'string' ) {
         postData += '&csrf_token=' + CSRF_TOKEN;
     } else {
         postData.csrf_token = CSRF_TOKEN;
     }
 
     var success = function(o) {
         var redirectUrl = o['redirect_url'];
         if (redirectUrl !== undefined && redirectUrl !== null && redirectUrl !== '') {
             window.location = redirectUrl;
         } else {
             window.location.reload();
         }
     };
 
     ajaxPOST(url, postData, success);
 };
 
 /**
  * PULL REQUEST update commits
  */
 var updateCommits = function(repo_name, pull_request_id, force) {
     var postData = {
         'update_commits': true
     };
     if (force !== undefined && force === true) {
         postData['force_refresh'] = true
     }
     _updatePullRequest(repo_name, pull_request_id, postData);
 };
 
 
 /**
  * PULL REQUEST edit info
  */
 var editPullRequest = function(repo_name, pull_request_id, title, description, renderer) {
     var url = pyroutes.url(
         'pullrequest_update',
         {"repo_name": repo_name, "pull_request_id": pull_request_id});
 
     var postData = {
         'title': title,
         'description': description,
         'description_renderer': renderer,
         'edit_pull_request': true,
         'csrf_token': CSRF_TOKEN
     };
     var success = function(o) {
         window.location.reload();
     };
     ajaxPOST(url, postData, success);
 };
 
 
 /**
  * autocomplete handler for reviewers/observers
  */
 var autoCompleteHandler = function (inputId, controller, role) {
 
     return function (element, data) {
         var mandatory = false;
         var reasons = [_gettext('added manually by "{0}"').format(
             templateContext.rhodecode_user.username)];
 
         // add whole user groups
         if (data.value_type == 'user_group') {
             reasons.push(_gettext('member of "{0}"').format(data.value_display));
 
             $.each(data.members, function (index, member_data) {
                 var reviewer = member_data;
                 reviewer['user_id'] = member_data['id'];
                 reviewer['gravatar_link'] = member_data['icon_link'];
                 reviewer['user_link'] = member_data['profile_link'];
                 reviewer['rules'] = [];
                 controller.addMember(reviewer, reasons, mandatory, role);
             })
         }
         // add single user
         else {
             var reviewer = data;
             reviewer['user_id'] = data['id'];
             reviewer['gravatar_link'] = data['icon_link'];
             reviewer['user_link'] = data['profile_link'];
             reviewer['rules'] = [];
             controller.addMember(reviewer, reasons, mandatory, role);
         }
 
         $(inputId).val('');
     }
 }
 
 /**
  * Reviewer autocomplete
  */
 var ReviewerAutoComplete = function (inputId, controller) {
     var self = this;
     self.controller = controller;
     self.inputId = inputId;
     var handler = autoCompleteHandler(inputId, controller, controller.ROLE_REVIEWER);
 
     $(inputId).autocomplete({
         serviceUrl: pyroutes.url('user_autocomplete_data'),
         minChars: 2,
         maxHeight: 400,
         deferRequestBy: 300, //miliseconds
         showNoSuggestionNotice: true,
         tabDisabled: true,
         autoSelectFirst: true,
         params: {
             user_id: templateContext.rhodecode_user.user_id,
             user_groups: true,
             user_groups_expand: true,
             skip_default_user: true
         },
         formatResult: autocompleteFormatResult,
         lookupFilter: autocompleteFilterResult,
         onSelect: handler
     });
 };
 
 /**
  * Observers autocomplete
  */
 var ObserverAutoComplete = function(inputId, controller) {
     var self = this;
     self.controller = controller;
     self.inputId = inputId;
     var handler = autoCompleteHandler(inputId, controller, controller.ROLE_OBSERVER);
 
     $(inputId).autocomplete({
         serviceUrl: pyroutes.url('user_autocomplete_data'),
         minChars: 2,
         maxHeight: 400,
         deferRequestBy: 300, //miliseconds
         showNoSuggestionNotice: true,
         tabDisabled: true,
         autoSelectFirst: true,
         params: {
             user_id: templateContext.rhodecode_user.user_id,
             user_groups: true,
             user_groups_expand: true,
             skip_default_user: true
         },
         formatResult: autocompleteFormatResult,
         lookupFilter: autocompleteFilterResult,
         onSelect: handler
     });
 }
 
 
 window.VersionController = function () {
     var self = this;
     this.$verSource = $('input[name=ver_source]');
     this.$verTarget = $('input[name=ver_target]');
     this.$showVersionDiff = $('#show-version-diff');
 
     this.adjustRadioSelectors = function (curNode) {
         var getVal = function (item) {
             if (item === 'latest') {
                 return Number.MAX_SAFE_INTEGER
             }
             else {
                 return parseInt(item)
             }
         };
 
         var curVal = getVal($(curNode).val());
         var cleared = false;
 
         $.each(self.$verSource, function (index, value) {
             var elVal = getVal($(value).val());
 
             if (elVal > curVal) {
                 if ($(value).is(':checked')) {
                     cleared = true;
                 }
                 $(value).attr('disabled', 'disabled');
                 $(value).removeAttr('checked');
                 $(value).css({'opacity': 0.1});
             }
             else {
                 $(value).css({'opacity': 1});
                 $(value).removeAttr('disabled');
             }
         });
 
         if (cleared) {
             // if we unchecked an active, set the next one to same loc.
             $(this.$verSource).filter('[value={0}]'.format(
                 curVal)).attr('checked', 'checked');
         }
 
         self.setLockAction(false,
             $(curNode).data('verPos'),
             $(this.$verSource).filter(':checked').data('verPos')
         );
     };
 
 
     this.attachVersionListener = function () {
         self.$verTarget.change(function (e) {
             self.adjustRadioSelectors(this)
         });
         self.$verSource.change(function (e) {
             self.adjustRadioSelectors(self.$verTarget.filter(':checked'))
         });
     };
 
     this.init = function () {
 
         var curNode = self.$verTarget.filter(':checked');
         self.adjustRadioSelectors(curNode);
         self.setLockAction(true);
         self.attachVersionListener();
 
     };
 
     this.setLockAction = function (state, selectedVersion, otherVersion) {
         var $showVersionDiff = this.$showVersionDiff;
 
         if (state) {
             $showVersionDiff.attr('disabled', 'disabled');
             $showVersionDiff.addClass('disabled');
             $showVersionDiff.html($showVersionDiff.data('labelTextLocked'));
         }
         else {
             $showVersionDiff.removeAttr('disabled');
             $showVersionDiff.removeClass('disabled');
 
             if (selectedVersion == otherVersion) {
                 $showVersionDiff.html($showVersionDiff.data('labelTextShow'));
             } else {
                 $showVersionDiff.html($showVersionDiff.data('labelTextDiff'));
             }
         }
 
     };
 
     this.showVersionDiff = function () {
         var target = self.$verTarget.filter(':checked');
         var source = self.$verSource.filter(':checked');
 
         if (target.val() && source.val()) {
             var params = {
                 'pull_request_id': templateContext.pull_request_data.pull_request_id,
                 'repo_name': templateContext.repo_name,
                 'version': target.val(),
                 'from_version': source.val()
             };
             window.location = pyroutes.url('pullrequest_show', params)
         }
 
         return false;
     };
 
     this.toggleVersionView = function (elem) {
 
         if (this.$showVersionDiff.is(':visible')) {
             $('.version-pr').hide();
             this.$showVersionDiff.hide();
             $(elem).html($(elem).data('toggleOn'))
         } else {
             $('.version-pr').show();
             this.$showVersionDiff.show();
             $(elem).html($(elem).data('toggleOff'))
         }
 
         return false
     };
 
 };
 
 
 window.UpdatePrController = function () {
     var self = this;
     this.$updateCommits = $('#update_commits');
     this.$updateCommitsSwitcher = $('#update_commits_switcher');
 
     this.lockUpdateButton = function (label) {
         self.$updateCommits.attr('disabled', 'disabled');
         self.$updateCommitsSwitcher.attr('disabled', 'disabled');
 
         self.$updateCommits.addClass('disabled');
         self.$updateCommitsSwitcher.addClass('disabled');
 
         self.$updateCommits.removeClass('btn-primary');
         self.$updateCommitsSwitcher.removeClass('btn-primary');
 
         self.$updateCommits.text(_gettext(label));
     };
 
     this.isUpdateLocked = function () {
         return self.$updateCommits.attr('disabled') !== undefined;
     };
 
     this.updateCommits = function (curNode) {
         if (self.isUpdateLocked()) {
             return
         }
         self.lockUpdateButton(_gettext('Updating...'));
         updateCommits(
             templateContext.repo_name,
             templateContext.pull_request_data.pull_request_id);
     };
 
     this.forceUpdateCommits = function () {
         if (self.isUpdateLocked()) {
             return
         }
         self.lockUpdateButton(_gettext('Force updating...'));
         var force = true;
         updateCommits(
             templateContext.repo_name,
             templateContext.pull_request_data.pull_request_id, force);
     };
 };
 
 
 /**
  * Reviewer display panel
  */
 window.ReviewersPanel = {
     editButton: null,
     closeButton: null,
     addButton: null,
     removeButtons: null,
     reviewRules: null,
     setReviewers: null,
     controller: null,
 
     setSelectors: function () {
         var self = this;
         self.editButton = $('#open_edit_reviewers');
         self.closeButton =$('#close_edit_reviewers');
         self.addButton = $('#add_reviewer');
         self.removeButtons = $('.reviewer_member_remove,.reviewer_member_mandatory_remove');
     },
 
     init: function (controller, reviewRules, setReviewers) {
         var self = this;
         self.setSelectors();
 
         self.controller = controller;
         self.reviewRules = reviewRules;
         self.setReviewers = setReviewers;
 
         self.editButton.on('click', function (e) {
             self.edit();
         });
         self.closeButton.on('click', function (e) {
             self.close();
             self.renderReviewers();
         });
 
         self.renderReviewers();
 
     },
 
     renderReviewers: function () {
         var self = this;
 
         if (self.setReviewers.reviewers === undefined) {
             return
         }
         if (self.setReviewers.reviewers.length === 0) {
             self.controller.emptyReviewersTable('<tr id="reviewer-empty-msg"><td colspan="6">No reviewers</td></tr>');
             return
         }
 
         self.controller.emptyReviewersTable();
 
         $.each(self.setReviewers.reviewers, function (key, val) {
 
             var member = val;
             if (member.role === self.controller.ROLE_REVIEWER) {
                 var entry = renderTemplate('reviewMemberEntry', {
                     'member': member,
                     'mandatory': member.mandatory,
                     'role': member.role,
                     'reasons': member.reasons,
                     'allowed_to_update': member.allowed_to_update,
                     'review_status': member.review_status,
                     'review_status_label': member.review_status_label,
                     'user_group': member.user_group,
                     'create': false
                 });
 
                 $(self.controller.$reviewMembers.selector).append(entry)
             }
         });
 
         tooltipActivate();
     },
 
     edit: function (event) {
         var self = this;
         self.editButton.hide();
         self.closeButton.show();
         self.addButton.show();
         $(self.removeButtons.selector).css('visibility', 'visible');
         // review rules
         self.controller.loadReviewRules(this.reviewRules);
     },
 
     close: function (event) {
         var self = this;
         this.editButton.show();
         this.closeButton.hide();
         this.addButton.hide();
         $(this.removeButtons.selector).css('visibility', 'hidden');
         // hide review rules
         self.controller.hideReviewRules();
     }
 };
 
 /**
  * Reviewer display panel
  */
 window.ObserversPanel = {
     editButton: null,
     closeButton: null,
     addButton: null,
     removeButtons: null,
     reviewRules: null,
     setReviewers: null,
     controller: null,
 
     setSelectors: function () {
         var self = this;
         self.editButton = $('#open_edit_observers');
         self.closeButton =$('#close_edit_observers');
         self.addButton = $('#add_observer');
         self.removeButtons = $('.observer_member_remove,.observer_member_mandatory_remove');
     },
 
     init: function (controller, reviewRules, setReviewers) {
         var self = this;
         self.setSelectors();
 
         self.controller = controller;
         self.reviewRules = reviewRules;
         self.setReviewers = setReviewers;
 
         self.editButton.on('click', function (e) {
             self.edit();
         });
         self.closeButton.on('click', function (e) {
             self.close();
             self.renderObservers();
         });
 
         self.renderObservers();
 
     },
 
     renderObservers: function () {
         var self = this;
         if (self.setReviewers.observers === undefined) {
             return
         }
         if (self.setReviewers.observers.length === 0) {
             self.controller.emptyObserversTable('<tr id="observer-empty-msg"><td colspan="6">No observers</td></tr>');
             return
         }
 
         self.controller.emptyObserversTable();
 
         $.each(self.setReviewers.observers, function (key, val) {
             var member = val;
             if (member.role === self.controller.ROLE_OBSERVER) {
                 var entry = renderTemplate('reviewMemberEntry', {
                     'member': member,
                     'mandatory': member.mandatory,
                     'role': member.role,
                     'reasons': member.reasons,
                     'allowed_to_update': member.allowed_to_update,
                     'review_status': member.review_status,
                     'review_status_label': member.review_status_label,
                     'user_group': member.user_group,
                     'create': false
                 });
 
                 $(self.controller.$observerMembers.selector).append(entry)
             }
         });
 
         tooltipActivate();
     },
 
     edit: function (event) {
         this.editButton.hide();
         this.closeButton.show();
         this.addButton.show();
         $(this.removeButtons.selector).css('visibility', 'visible');
     },
 
     close: function (event) {
         this.editButton.show();
         this.closeButton.hide();
         this.addButton.hide();
         $(this.removeButtons.selector).css('visibility', 'hidden');
     }
 
 };
 
 window.PRDetails = {
     editButton: null,
     closeButton: null,
     deleteButton: null,
     viewFields: null,
     editFields: null,
 
     setSelectors: function () {
         var self = this;
         self.editButton = $('#open_edit_pullrequest')
         self.closeButton = $('#close_edit_pullrequest')
         self.deleteButton = $('#delete_pullrequest')
         self.viewFields = $('#pr-desc, #pr-title')
         self.editFields = $('#pr-desc-edit, #pr-title-edit, .pr-save')
     },
 
     init: function () {
         var self = this;
         self.setSelectors();
         self.editButton.on('click', function (e) {
             self.edit();
         });
         self.closeButton.on('click', function (e) {
             self.view();
         });
     },
 
     edit: function (event) {
         var cmInstance = $('#pr-description-input').get(0).MarkupForm.cm;
         this.viewFields.hide();
         this.editButton.hide();
         this.deleteButton.hide();
         this.closeButton.show();
         this.editFields.show();
         cmInstance.refresh();
     },
 
     view: function (event) {
         this.editButton.show();
         this.deleteButton.show();
         this.editFields.hide();
         this.closeButton.hide();
         this.viewFields.show();
     }
 };
 
 /**
  * OnLine presence using channelstream
  */
 window.ReviewerPresenceController = function (channel) {
     var self = this;
     this.channel = channel;
     this.users = {};
 
     this.storeUsers = function (users) {
         self.users = {}
         $.each(users, function (index, value) {
             var userId = value.state.id;
             self.users[userId] = value.state;
         })
     }
 
     this.render = function () {
         $.each($('.reviewer_entry'), function (index, value) {
             var userData = $(value).data();
             if (self.users[userData.reviewerUserId] !== undefined) {
                 $(value).find('.presence-state').show();
             } else {
                 $(value).find('.presence-state').hide();
             }
         })
     };
 
     this.handlePresence = function (data) {
         if (data.type == 'presence' && data.channel === self.channel) {
             this.storeUsers(data.users);
             this.render()
         }
     };
 
     this.handleChannelUpdate = function (data) {
         if (data.channel === this.channel) {
             this.storeUsers(data.state.users);
             this.render()
         }
 
     };
 
     /* subscribe to the current presence */
     $.Topic('/connection_controller/presence').subscribe(this.handlePresence.bind(this));
     /* subscribe to updates e.g connect/disconnect */
     $.Topic('/connection_controller/channel_update').subscribe(this.handleChannelUpdate.bind(this));
 
 };
 
 window.refreshComments = function (version) {
     version = version || templateContext.pull_request_data.pull_request_version || '';
 
     // Pull request case
     if (templateContext.pull_request_data.pull_request_id !== null) {
         var params = {
             'pull_request_id': templateContext.pull_request_data.pull_request_id,
             'repo_name': templateContext.repo_name,
             'version': version,
         };
         var loadUrl = pyroutes.url('pullrequest_comments', params);
     } // commit case
     else {
         return
     }
 
     var currentIDs = []
     $.each($('.comment'), function (idx, element) {
         currentIDs.push($(element).data('commentId'));
     });
     var data = {"comments": currentIDs};
 
     var $targetElem = $('.comments-content-table');
     $targetElem.css('opacity', 0.3);
 
     var success = function (data) {
         var $counterElem = $('#comments-count');
         var newCount = $(data).data('counter');
         if (newCount !== undefined) {
             var callback = function () {
                 $counterElem.animate({'opacity': 1.00}, 200)
                 $counterElem.html(newCount);
             };
             $counterElem.animate({'opacity': 0.15}, 200, callback);
         }
 
         $targetElem.css('opacity', 1);
         $targetElem.html(data);
         tooltipActivate();
     }
 
     ajaxPOST(loadUrl, data, success, null, {})
 
 }
 
 window.refreshTODOs = function (version) {
     version = version || templateContext.pull_request_data.pull_request_version || '';
     // Pull request case
     if (templateContext.pull_request_data.pull_request_id !== null) {
         var params = {
             'pull_request_id': templateContext.pull_request_data.pull_request_id,
             'repo_name': templateContext.repo_name,
             'version': version,
         };
         var loadUrl = pyroutes.url('pullrequest_comments', params);
     } // commit case
     else {
         return
     }
 
     var currentIDs = []
     $.each($('.comment'), function (idx, element) {
         currentIDs.push($(element).data('commentId'));
     });
 
     var data = {"comments": currentIDs};
     var $targetElem = $('.todos-content-table');
     $targetElem.css('opacity', 0.3);
 
     var success = function (data) {
         var $counterElem = $('#todos-count')
         var newCount = $(data).data('counter');
         if (newCount !== undefined) {
             var callback = function () {
                 $counterElem.animate({'opacity': 1.00}, 200)
                 $counterElem.html(newCount);
             };
             $counterElem.animate({'opacity': 0.15}, 200, callback);
         }
 
         $targetElem.css('opacity', 1);
         $targetElem.html(data);
         tooltipActivate();
     }
 
     ajaxPOST(loadUrl, data, success, null, {})
 
 }
 
 window.refreshAllComments = function (version) {
     version = version || templateContext.pull_request_data.pull_request_version || '';
 
     refreshComments(version);
     refreshTODOs(version);
 };
 
 window.sidebarComment = function (commentId) {
     var jsonData = $('#commentHovercard{0}'.format(commentId)).data('commentJsonB64');
     if (!jsonData) {
         return 'Failed to load comment {0}'.format(commentId)
     }
     var funcData = JSON.parse(atob(jsonData));
     return renderTemplate('sideBarCommentHovercard', funcData)
 };

rhodecode/templates/pullrequests/pullrequest.mako

@@ -1,642 +1,650 b''
 <%inherit file="/base/base.mako"/>
 <%namespace name="dt" file="/data_table/_dt_elements.mako"/>
 
 <%def name="title()">
     ${c.repo_name} ${_('New pull request')}
 </%def>
 
 <%def name="breadcrumbs_links()"></%def>
 
 <%def name="menu_bar_nav()">
     ${self.menu_items(active='repositories')}
 </%def>
 
 <%def name="menu_bar_subnav()">
     ${self.repo_menu(active='showpullrequest')}
 </%def>
 
 <%def name="main()">
 <div class="box">
     ${h.secure_form(h.route_path('pullrequest_create', repo_name=c.repo_name, _query=request.GET.mixed()), id='pull_request_form', request=request)}
 
         <div class="box">
 
             <div class="summary-details block-left">
 
                 <div class="form" style="padding-top: 10px">
 
                     <div class="fields" >
 
                         ## COMMIT FLOW
                         <div class="field">
                             <div class="label label-textarea">
                                 <label for="commit_flow">${_('Commit flow')}:</label>
                             </div>
 
                             <div class="content">
                                 <div class="flex-container">
                                     <div style="width: 45%;">
                                         <div class="panel panel-default source-panel">
                                             <div class="panel-heading">
                                                 <h3 class="panel-title">${_('Source repository')}</h3>
                                             </div>
                                             <div class="panel-body">
                                                 <div style="display:none">${c.rhodecode_db_repo.description}</div>
                                                 ${h.hidden('source_repo')}
                                                 ${h.hidden('source_ref')}
 
                                                 <div id="pr_open_message"></div>
                                             </div>
                                         </div>
                                     </div>
 
                                     <div style="width: 90px; text-align: center; padding-top: 30px">
                                     <div>
                                         <i class="icon-right" style="font-size: 2.2em"></i>
                                     </div>
                                     <div style="position: relative; top: 10px">
                                     <span class="tag tag">
                                         <span id="switch_base"></span>
                                     </span>
                                     </div>
 
                                 </div>
 
                                     <div style="width: 45%;">
 
                                     <div class="panel panel-default target-panel">
                                         <div class="panel-heading">
                                             <h3 class="panel-title">${_('Target repository')}</h3>
                                         </div>
                                         <div class="panel-body">
                                           <div style="display:none" id="target_repo_desc"></div>
                                           ${h.hidden('target_repo')}
                                           ${h.hidden('target_ref')}
                                           <span id="target_ref_loading" style="display: none">
                                               ${_('Loading refs...')}
                                           </span>
                                         </div>
                                     </div>
 
                                 </div>
                                 </div>
 
                             </div>
 
                         </div>
 
                         ## TITLE
                         <div class="field">
                             <div class="label">
                                 <label for="pullrequest_title">${_('Title')}:</label>
                             </div>
                             <div class="input">
                                 ${h.text('pullrequest_title', c.default_title, class_="medium autogenerated-title")}
                             </div>
                             <p class="help-block">
                                 Start the title with WIP: to prevent accidental merge of Work In Progress pull request before it's ready.
                             </p>
                         </div>
 
                         ## DESC
                         <div class="field">
                             <div class="label label-textarea">
                                 <label for="pullrequest_desc">${_('Description')}:</label>
                             </div>
                             <div class="textarea text-area">
                                 <input id="pr-renderer-input" type="hidden" name="description_renderer" value="${c.visual.default_renderer}">
                                 ${dt.markup_form('pullrequest_desc')}
                             </div>
                         </div>
 
                         ## REVIEWERS
                         <div class="field">
                             <div class="label label-textarea">
                                 <label for="pullrequest_reviewers">${_('Reviewers / Observers')}:</label>
                             </div>
                             <div class="content">
                                 ## REVIEW RULES
                                 <div id="review_rules" style="display: none" class="reviewers-title">
                                     <div class="pr-details-title">
                                         ${_('Reviewer rules')}
                                     </div>
                                     <div class="pr-reviewer-rules">
                                         ## review rules will be appended here, by default reviewers logic
                                     </div>
                                 </div>
 
                                 ## REVIEWERS / OBSERVERS
                                 <div class="reviewers-title">
 
                                     <ul class="nav-links clearfix">
 
                                         ## TAB1 MANDATORY REVIEWERS
                                         <li class="active">
                                             <a id="reviewers-btn" href="#showReviewers" tabindex="-1">
                                                 Reviewers
                                                 <span id="reviewers-cnt" data-count="0" class="menulink-counter">0</span>
                                             </a>
                                         </li>
 
                                         ## TAB2 OBSERVERS
                                         <li class="">
                                             <a id="observers-btn" href="#showObservers" tabindex="-1">
                                                 Observers
                                                 <span id="observers-cnt"  data-count="0" class="menulink-counter">0</span>
                                             </a>
                                         </li>
 
                                     </ul>
 
                                     ## TAB1 MANDATORY REVIEWERS
                                     <div id="reviewers-container">
                                         <span class="calculate-reviewers">
                                             <h4>${_('loading...')}</h4>
                                         </span>
 
                                         <div id="reviewers" class="pr-details-content reviewers">
                                             ## members goes here, filled via JS based on initial selection !
                                             <input type="hidden" name="__start__" value="review_members:sequence">
                                             <table id="review_members" class="group_members">
                                             ## This content is loaded via JS and ReviewersPanel, an sets reviewer_entry class on each element
                                             </table>
                                             <input type="hidden" name="__end__" value="review_members:sequence">
 
                                             <div id="add_reviewer_input" class='ac'>
                                                 <div class="reviewer_ac">
                                                     ${h.text('user', class_='ac-input', placeholder=_('Add reviewer or reviewer group'))}
                                                     <div id="reviewers_container"></div>
                                                 </div>
                                             </div>
 
                                         </div>
                                     </div>
 
                                     ## TAB2 OBSERVERS
                                     <div id="observers-container" style="display: none">
                                         <span class="calculate-reviewers">
                                             <h4>${_('loading...')}</h4>
                                         </span>
                                         % if c.rhodecode_edition_id == 'EE':
                                         <div id="observers" class="pr-details-content observers">
                                             ## members goes here, filled via JS based on initial selection !
                                             <input type="hidden" name="__start__" value="observer_members:sequence">
                                             <table id="observer_members" class="group_members">
                                             ## This content is loaded via JS and ReviewersPanel, an sets reviewer_entry class on each element
                                             </table>
                                             <input type="hidden" name="__end__" value="observer_members:sequence">
 
                                             <div id="add_observer_input" class='ac'>
                                                 <div class="observer_ac">
                                                     ${h.text('observer', class_='ac-input', placeholder=_('Add observer or observer group'))}
                                                     <div id="observers_container"></div>
                                                 </div>
                                             </div>
                                         </div>
                                         % else:
                                             <h4>${_('This feature is available in RhodeCode EE edition only. Contact {sales_email} to obtain a trial license.').format(sales_email='<a href="mailto:[e-mail]">[e-mail]</a>')|n}</h4>
                                             <p>
                                                 Pull request observers allows adding users who don't need to leave mandatory votes, but need to be aware about certain changes.
                                             </p>
                                         % endif
                                     </div>
 
                                 </div>
 
                             </div>
                         </div>
 
                         ## SUBMIT
                         <div class="field">
                             <div class="label label-textarea">
                                 <label for="pullrequest_submit"></label>
                             </div>
                             <div class="input">
                                 <div class="pr-submit-button">
                                     <input id="pr_submit" class="btn" name="save" type="submit" value="${_('Submit Pull Request')}">
                                 </div>
                             </div>
                         </div>
                     </div>
                 </div>
             </div>
 
         </div>
 
     ${h.end_form()}
 </div>
 
 <script type="text/javascript">
  $(function(){
    var defaultSourceRepo = '${c.default_repo_data['source_repo_name']}';
    var defaultSourceRepoData = ${c.default_repo_data['source_refs_json']|n};
    var defaultTargetRepo = '${c.default_repo_data['target_repo_name']}';
    var defaultTargetRepoData = ${c.default_repo_data['target_refs_json']|n};
 
    var $pullRequestForm = $('#pull_request_form');
    var $pullRequestSubmit = $('#pr_submit', $pullRequestForm);
    var $sourceRepo = $('#source_repo', $pullRequestForm);
    var $targetRepo = $('#target_repo', $pullRequestForm);
    var $sourceRef = $('#source_ref', $pullRequestForm);
    var $targetRef = $('#target_ref', $pullRequestForm);
 
    var sourceRepo = function() { return $sourceRepo.eq(0).val() };
    var sourceRef = function() { return $sourceRef.eq(0).val().split(':') };
 
    var targetRepo = function() { return $targetRepo.eq(0).val() };
    var targetRef = function() { return $targetRef.eq(0).val().split(':') };
 
    var calculateContainerWidth = function() {
        var maxWidth = 0;
        var repoSelect2Containers = ['#source_repo', '#target_repo'];
        $.each(repoSelect2Containers, function(idx, value) {
            $(value).select2('container').width('auto');
            var curWidth = $(value).select2('container').width();
            if (maxWidth <= curWidth) {
                maxWidth = curWidth;
            }
            $.each(repoSelect2Containers, function(idx, value) {
                $(value).select2('container').width(maxWidth + 10);
            });
        });
    };
 
    var initRefSelection = function(selectedRef) {
        return function(element, callback) {
            // translate our select2 id into a text, it's a mapping to show
            // simple label when selecting by internal ID.
            var id, refData;
            if (selectedRef === undefined || selectedRef === null) {
              id = element.val();
              refData = element.val().split(':');
 
              if (refData.length !== 3){
                  refData = ["", "", ""]
              }
            } else {
              id = selectedRef;
              refData = selectedRef.split(':');
            }
 
            var text = refData[1];
            if (refData[0] === 'rev') {
                text = text.substring(0, 12);
            }
 
            var data = {id: id, text: text};
            callback(data);
        };
    };
 
    var formatRefSelection = function(data, container, escapeMarkup) {
        var prefix = '';
        var refData = data.id.split(':');
        if (refData[0] === 'branch') {
            prefix = '<i class="icon-branch"></i>';
        }
        else if (refData[0] === 'book') {
            prefix = '<i class="icon-bookmark"></i>';
        }
        else if (refData[0] === 'tag') {
            prefix = '<i class="icon-tag"></i>';
        }
 
        var originalOption = data.element;
        return prefix + escapeMarkup(data.text);
    };
 
    // custom code mirror
    var codeMirrorInstance = $('#pullrequest_desc').get(0).MarkupForm.cm;
 
    var diffDataHandler = function(data) {
+       if (data['error'] !== undefined) {
+           var noCommitsMsg = '<span class="alert-text-error">{0}</span>'.format(data['error']);
+           prButtonLock(true, noCommitsMsg, 'compare');
+           //make both panels equal
+           $('.target-panel').height($('.source-panel').height())
+           return false
+       }
 
        var commitElements = data['commits'];
        var files = data['files'];
        var added = data['stats'][0]
        var deleted = data['stats'][1]
        var commonAncestorId = data['ancestor'];
        var _sourceRefType = sourceRef()[0];
        var _sourceRefName = sourceRef()[1];
        var prTitleAndDesc = getTitleAndDescription(_sourceRefType, _sourceRefName, commitElements, 5);
 
        var title = prTitleAndDesc[0];
        var proposedDescription = prTitleAndDesc[1];
 
        var useGeneratedTitle = (
             $('#pullrequest_title').hasClass('autogenerated-title') ||
             $('#pullrequest_title').val() === "");
 
        if (title && useGeneratedTitle) {
            // use generated title if we haven't specified our own
            $('#pullrequest_title').val(title);
            $('#pullrequest_title').addClass('autogenerated-title');
 
        }
 
        var useGeneratedDescription = (
            !codeMirrorInstance._userDefinedValue ||
             codeMirrorInstance.getValue() === "");
 
        if (proposedDescription && useGeneratedDescription) {
             // set proposed content, if we haven't defined our own,
             // or we don't have description written
             codeMirrorInstance._userDefinedValue = false; // reset state
             codeMirrorInstance.setValue(proposedDescription);
        }
 
        // refresh our codeMirror so events kicks in and it's change aware
        codeMirrorInstance.refresh();
 
        var url_data = {
            'repo_name': targetRepo(),
            'target_repo': sourceRepo(),
            'source_ref': targetRef()[2],
            'source_ref_type': 'rev',
            'target_ref': sourceRef()[2],
            'target_ref_type': 'rev',
            'merge': true,
            '_': Date.now() // bypass browser caching
        }; // gather the source/target ref and repo here
        var url = pyroutes.url('repo_compare', url_data);
 
        var msg = '<input id="common_ancestor" type="hidden" name="common_ancestor" value="{0}">'.format(commonAncestorId);
        msg += '<input type="hidden" name="__start__" value="revisions:sequence">'
 
 
        $.each(commitElements, function(idx, value) {
            var commit_id = value["commit_id"]
            msg += '<input type="hidden" name="revisions" value="{0}">'.format(commit_id);
        });
 
        msg += '<input type="hidden" name="__end__" value="revisions:sequence">'
        msg += _ngettext(
            'Compare summary: <strong>{0} commit</strong>',
            'Compare summary: <strong>{0} commits</strong>',
            commitElements.length).format(commitElements.length)
 
        msg += '';
        msg += _ngettext(
            '<strong>, and {0} file</strong> changed.',
            '<strong>, and {0} files</strong> changed.',
            files.length).format(files.length)
 
        msg += '\n Diff: <span class="op-added">{0} lines inserted</span>, <span class="op-deleted">{1} lines deleted </span>.'.format(added, deleted)
 
        msg += '\n <a class="" id="pull_request_overview_url" href="{0}" target="_blank">${_('Show detailed compare.')}</a>'.format(url);
 
        if (commitElements.length) {
            var commitsLink = '<a href="#pull_request_overview"><strong>{0}</strong></a>'.format(commitElements.length);
            prButtonLock(false, msg.replace('__COMMITS__', commitsLink), 'compare');
        }
        else {
            var noCommitsMsg = '<span class="alert-text-warning">{0}</span>'.format(
                _gettext('There are no commits to merge.'));
            prButtonLock(true, noCommitsMsg, 'compare');
        }
 
        //make both panels equal
-       $('.target-panel').height($('.source-panel').height())
+       $('.target-panel').height($('.source-panel').height());
+       return true
    };
 
    reviewersController = new ReviewersController();
    reviewersController.diffDataHandler = diffDataHandler;
 
    var queryTargetRepo = function(self, query) {
        // cache ALL results if query is empty
        var cacheKey = query.term || '__';
        var cachedData = self.cachedDataSource[cacheKey];
 
        if (cachedData) {
            query.callback({results: cachedData.results});
        } else {
            $.ajax({
                url: pyroutes.url('pullrequest_repo_targets', {'repo_name': templateContext.repo_name}),
                data: {query: query.term},
                dataType: 'json',
                type: 'GET',
                success: function(data) {
                    self.cachedDataSource[cacheKey] = data;
                    query.callback({results: data.results});
                },
                error: function(jqXHR, textStatus, errorThrown) {
                 var prefix = "Error while fetching entries.\n"
                 var message = formatErrorMessage(jqXHR, textStatus, errorThrown, prefix);
                 ajaxErrorSwal(message);
                }
            });
        }
    };
 
    var queryTargetRefs = function(initialData, query) {
        var data = {results: []};
        // filter initialData
        $.each(initialData, function() {
            var section = this.text;
            var children = [];
            $.each(this.children, function() {
                if (query.term.length === 0 ||
                    this.text.toUpperCase().indexOf(query.term.toUpperCase()) >= 0 ) {
                    children.push({'id': this.id, 'text': this.text})
                }
            });
            data.results.push({'text': section, 'children': children})
        });
        query.callback({results: data.results});
    };
 
    var Select2Box = function(element, overrides) {
      var globalDefaults = {
          dropdownAutoWidth: true,
          containerCssClass: "drop-menu",
          dropdownCssClass: "drop-menu-dropdown"
      };
 
      var initSelect2 = function(defaultOptions) {
        var options = jQuery.extend(globalDefaults, defaultOptions, overrides);
        element.select2(options);
      };
 
      return {
        initRef: function() {
          var defaultOptions = {
            minimumResultsForSearch: 5,
            formatSelection: formatRefSelection
          };
 
          initSelect2(defaultOptions);
        },
 
        initRepo: function(defaultValue, readOnly) {
          var defaultOptions = {
            initSelection : function (element, callback) {
              var data = {id: defaultValue, text: defaultValue};
              callback(data);
            }
          };
 
          initSelect2(defaultOptions);
 
          element.select2('val', defaultSourceRepo);
          if (readOnly === true) {
            element.select2('readonly', true);
          }
        }
      };
    };
 
    var initTargetRefs = function(refsData, selectedRef) {
 
      Select2Box($targetRef, {
          placeholder: "${_('Select commit reference')}",
        query: function(query) {
          queryTargetRefs(refsData, query);
        },
        initSelection : initRefSelection(selectedRef)
      }).initRef();
 
      if (!(selectedRef === undefined)) {
          $targetRef.select2('val', selectedRef);
      }
    };
 
    var targetRepoChanged = function(repoData) {
        // generate new DESC of target repo displayed next to select
 
        $('#target_repo_desc').html(repoData['description']);
 
        var prLink = pyroutes.url('pullrequest_new', {'repo_name': repoData['name']});
        var title = _gettext('Switch target repository with the source.')
        $('#switch_base').html("<a class=\"tooltip\" title=\"{0}\" href=\"{1}\">Switch sides</a>".format(title, prLink))
 
        // generate dynamic select2 for refs.
        initTargetRefs(repoData['refs']['select2_refs'],
                       repoData['refs']['selected_ref']);
 
    };
 
    var sourceRefSelect2 = Select2Box($sourceRef, {
        placeholder: "${_('Select commit reference')}",
        query: function(query) {
          var initialData = defaultSourceRepoData['refs']['select2_refs'];
          queryTargetRefs(initialData, query)
        },
        initSelection: initRefSelection()
    });
 
    var sourceRepoSelect2 = Select2Box($sourceRepo, {
      query: function(query) {}
    });
 
    var targetRepoSelect2 = Select2Box($targetRepo, {
      cachedDataSource: {},
      query: $.debounce(250, function(query) {
        queryTargetRepo(this, query);
      }),
      formatResult: formatRepoResult
    });
 
    sourceRefSelect2.initRef();
 
    sourceRepoSelect2.initRepo(defaultSourceRepo, true);
 
    targetRepoSelect2.initRepo(defaultTargetRepo, false);
 
    $sourceRef.on('change', function(e){
      reviewersController.loadDefaultReviewers(
          sourceRepo(), sourceRef(), targetRepo(), targetRef());
    });
 
    $targetRef.on('change', function(e){
      reviewersController.loadDefaultReviewers(
          sourceRepo(), sourceRef(), targetRepo(), targetRef());
    });
 
    $targetRepo.on('change', function(e){
        var repoName = $(this).val();
        calculateContainerWidth();
        $targetRef.select2('destroy');
        $('#target_ref_loading').show();
 
        $.ajax({
            url: pyroutes.url('pullrequest_repo_refs',
              {'repo_name': templateContext.repo_name, 'target_repo_name':repoName}),
            data: {},
            dataType: 'json',
            type: 'GET',
            success: function(data) {
                $('#target_ref_loading').hide();
                targetRepoChanged(data);
            },
            error: function(jqXHR, textStatus, errorThrown) {
                 var prefix = "Error while fetching entries.\n"
                 var message = formatErrorMessage(jqXHR, textStatus, errorThrown, prefix);
                 ajaxErrorSwal(message);
            }
        })
 
    });
 
    $pullRequestForm.on('submit', function(e){
        // Flush changes into textarea
        codeMirrorInstance.save();
        prButtonLock(true, null, 'all');
        $pullRequestSubmit.val(_gettext('Please wait creating pull request...'));
    });
 
    prButtonLock(true, "${_('Please select source and target')}", 'all');
 
    // auto-load on init, the target refs select2
    calculateContainerWidth();
    targetRepoChanged(defaultTargetRepoData);
 
    $('#pullrequest_title').on('keyup', function(e){
        $(this).removeClass('autogenerated-title');
    });
 
    % if c.default_source_ref:
    // in case we have a pre-selected value, use it now
    $sourceRef.select2('val', '${c.default_source_ref}');
 
 
    // default reviewers / observers
    reviewersController.loadDefaultReviewers(
        sourceRepo(), sourceRef(), targetRepo(), targetRef());
    % endif
 
    ReviewerAutoComplete('#user', reviewersController);
    ObserverAutoComplete('#observer', reviewersController);
 
    // TODO, move this to another handler
 
    var $reviewersBtn = $('#reviewers-btn');
    var $reviewersContainer = $('#reviewers-container');
 
    var $observersBtn = $('#observers-btn')
    var $observersContainer = $('#observers-container');
 
    $reviewersBtn.on('click', function (e) {
 
        $observersContainer.hide();
        $reviewersContainer.show();
 
        $observersBtn.parent().removeClass('active');
        $reviewersBtn.parent().addClass('active');
        e.preventDefault();
 
    })
 
    $observersBtn.on('click', function (e) {
 
        $reviewersContainer.hide();
        $observersContainer.show();
 
        $reviewersBtn.parent().removeClass('active');
        $observersBtn.parent().addClass('active');
        e.preventDefault();
 
    })
 
  });
 </script>
 
 </%def>