pullrequest: disable pr on commits that dont share ancestor

rhodecode/controllers/compare.py

@@ -1,265 +1,267 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Compare controller for showing differences between two commits/refs/tags etc.
 """
 
 import logging
 
 from webob.exc import HTTPBadRequest
 from pylons import request, tmpl_context as c, url
 from pylons.controllers.util import redirect
 from pylons.i18n.translation import _
 
 from rhodecode.controllers.utils import parse_path_ref, get_commit_from_ref_name
 from rhodecode.lib import helpers as h
 from rhodecode.lib import diffs
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.utils import safe_str
 from rhodecode.lib.utils2 import safe_unicode, str2bool
 from rhodecode.lib.vcs.exceptions import (
     EmptyRepositoryError, RepositoryError, RepositoryRequirementError)
 from rhodecode.model.db import Repository, ChangesetStatus
 
 log = logging.getLogger(__name__)
 
 
 class CompareController(BaseRepoController):
 
     def __before__(self):
         super(CompareController, self).__before__()
 
     def _get_commit_or_redirect(
             self, ref, ref_type, repo, redirect_after=True, partial=False):
         """
         This is a safe way to get a commit. If an error occurs it
         redirects to a commit with a proper message. If partial is set
         then it does not do redirect raise and throws an exception instead.
         """
         try:
             return get_commit_from_ref_name(repo, safe_str(ref), ref_type)
         except EmptyRepositoryError:
             if not redirect_after:
                 return repo.scm_instance().EMPTY_COMMIT
             h.flash(h.literal(_('There are no commits yet')),
                     category='warning')
             redirect(url('summary_home', repo_name=repo.repo_name))
 
         except RepositoryError as e:
             msg = safe_str(e)
             log.exception(msg)
             h.flash(msg, category='warning')
             if not partial:
                 redirect(h.url('summary_home', repo_name=repo.repo_name))
             raise HTTPBadRequest()
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def index(self, repo_name):
         c.compare_home = True
         c.commit_ranges = []
         c.files = []
         c.limited_diff = False
         source_repo = c.rhodecode_db_repo.repo_name
         target_repo = request.GET.get('target_repo', source_repo)
         c.source_repo = Repository.get_by_repo_name(source_repo)
         c.target_repo = Repository.get_by_repo_name(target_repo)
         c.source_ref = c.target_ref = _('Select commit')
         c.source_ref_type = ""
         c.target_ref_type = ""
         c.commit_statuses = ChangesetStatus.STATUSES
         c.preview_mode = False
         return render('compare/compare_diff.html')
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def compare(self, repo_name, source_ref_type, source_ref,
                                  target_ref_type, target_ref):
         # source_ref will be evaluated in source_repo
         source_repo_name = c.rhodecode_db_repo.repo_name
         source_path, source_id = parse_path_ref(source_ref)
 
         # target_ref will be evaluated in target_repo
         target_repo_name = request.GET.get('target_repo', source_repo_name)
         target_path, target_id = parse_path_ref(target_ref)
 
         c.commit_statuses = ChangesetStatus.STATUSES
 
         # if merge is True
         #   Show what changes since the shared ancestor commit of target/source
         #   the source would get if it was merged with target. Only commits
         #   which are in target but not in source will be shown.
         merge = str2bool(request.GET.get('merge'))
         # if merge is False
         #   Show a raw diff of source/target refs even if no ancestor exists
 
 
         # c.fulldiff disables cut_off_limit
         c.fulldiff = str2bool(request.GET.get('fulldiff'))
 
         # if partial, returns just compare_commits.html (commits log)
         partial = request.is_xhr
 
         # swap url for compare_diff page
         c.swap_url = h.url(
             'compare_url',
             repo_name=target_repo_name,
             source_ref_type=target_ref_type,
             source_ref=target_ref,
             target_repo=source_repo_name,
             target_ref_type=source_ref_type,
             target_ref=source_ref,
             merge=merge and '1' or '')
 
         source_repo = Repository.get_by_repo_name(source_repo_name)
         target_repo = Repository.get_by_repo_name(target_repo_name)
 
         if source_repo is None:
             msg = _('Could not find the original repo: %(repo)s') % {
                 'repo': source_repo}
 
             log.error(msg)
             h.flash(msg, category='error')
             return redirect(url('compare_home', repo_name=c.repo_name))
 
         if target_repo is None:
             msg = _('Could not find the other repo: %(repo)s') % {
                 'repo': target_repo_name}
             log.error(msg)
             h.flash(msg, category='error')
             return redirect(url('compare_home', repo_name=c.repo_name))
 
         source_alias = source_repo.scm_instance().alias
         target_alias = target_repo.scm_instance().alias
         if source_alias != target_alias:
             msg = _('The comparison of two different kinds of remote repos '
                     'is not available')
             log.error(msg)
             h.flash(msg, category='error')
             return redirect(url('compare_home', repo_name=c.repo_name))
 
         source_commit = self._get_commit_or_redirect(
             ref=source_id, ref_type=source_ref_type, repo=source_repo,
             partial=partial)
         target_commit = self._get_commit_or_redirect(
             ref=target_id, ref_type=target_ref_type, repo=target_repo,
             partial=partial)
 
         c.compare_home = False
         c.source_repo = source_repo
         c.target_repo = target_repo
         c.source_ref = source_ref
         c.target_ref = target_ref
         c.source_ref_type = source_ref_type
         c.target_ref_type = target_ref_type
 
         source_scm = source_repo.scm_instance()
         target_scm = target_repo.scm_instance()
 
         pre_load = ["author", "branch", "date", "message"]
         c.ancestor = None
         try:
             c.commit_ranges = source_scm.compare(
                 source_commit.raw_id, target_commit.raw_id,
                 target_scm, merge, pre_load=pre_load)
             if merge:
                 c.ancestor = source_scm.get_common_ancestor(
                     source_commit.raw_id, target_commit.raw_id, target_scm)
         except RepositoryRequirementError:
             msg = _('Could not compare repos with different '
                     'large file settings')
             log.error(msg)
             if partial:
                 return msg
             h.flash(msg, category='error')
             return redirect(url('compare_home', repo_name=c.repo_name))
 
         c.statuses = c.rhodecode_db_repo.statuses(
             [x.raw_id for x in c.commit_ranges])
 
-        if partial:
+        if partial: # for PR ajax commits loader
+            if not c.ancestor:
+                return '' # cannot merge if there is no ancestor
             return render('compare/compare_commits.html')
 
         if c.ancestor:
             # case we want a simple diff without incoming commits,
             # previewing what will be merged.
             # Make the diff on target repo (which is known to have target_ref)
             log.debug('Using ancestor %s as source_ref instead of %s'
                       % (c.ancestor, source_ref))
             source_repo = target_repo
             source_commit = target_repo.get_commit(commit_id=c.ancestor)
 
         # diff_limit will cut off the whole diff if the limit is applied
         # otherwise it will just hide the big files from the front-end
         diff_limit = self.cut_off_limit_diff
         file_limit = self.cut_off_limit_file
 
         log.debug('calculating diff between '
                   'source_ref:%s and target_ref:%s for repo `%s`',
                   source_commit, target_commit,
                   safe_unicode(source_repo.scm_instance().path))
 
         if source_commit.repository != target_commit.repository:
             msg = _(
                 "Repositories unrelated. "
                 "Cannot compare commit %(commit1)s from repository %(repo1)s "
                 "with commit %(commit2)s from repository %(repo2)s.") % {
                     'commit1': h.show_id(source_commit),
                     'repo1': source_repo.repo_name,
                     'commit2': h.show_id(target_commit),
                     'repo2': target_repo.repo_name,
                 }
             h.flash(msg, category='error')
             raise HTTPBadRequest()
 
         txtdiff = source_repo.scm_instance().get_diff(
             commit1=source_commit, commit2=target_commit,
             path1=source_path, path=target_path)
         diff_processor = diffs.DiffProcessor(
             txtdiff, format='gitdiff', diff_limit=diff_limit,
             file_limit=file_limit, show_full_diff=c.fulldiff)
         _parsed = diff_processor.prepare()
 
         c.limited_diff = False
         if isinstance(_parsed, diffs.LimitedDiffContainer):
             c.limited_diff = True
 
         c.files = []
         c.changes = {}
         c.lines_added = 0
         c.lines_deleted = 0
         for f in _parsed:
             st = f['stats']
             if not st['binary']:
                 c.lines_added += st['added']
                 c.lines_deleted += st['deleted']
             fid = h.FID('', f['filename'])
             c.files.append([fid, f['operation'], f['filename'], f['stats'], f])
             htmldiff = diff_processor.as_html(
                 enable_comments=False, parsed_lines=[f])
             c.changes[fid] = [f['operation'], f['filename'], htmldiff, f]
 
         c.preview_mode = merge
 
         return render('compare/compare_diff.html')