|
|
# -*- coding: utf-8 -*-
|
|
|
|
|
|
# Copyright (C) 2012-2017 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.httpexceptions import HTTPBadRequest, HTTPNotFound, HTTPFound
|
|
|
from pyramid.view import view_config
|
|
|
from pyramid.renderers import render
|
|
|
from pyramid.response import Response
|
|
|
|
|
|
from rhodecode.apps._base import RepoAppView
|
|
|
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, codeblocks
|
|
|
from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
|
|
|
from rhodecode.lib.utils import safe_str
|
|
|
from rhodecode.lib.utils2 import safe_unicode, str2bool
|
|
|
from rhodecode.lib.vcs.exceptions import (
|
|
|
EmptyRepositoryError, RepositoryError, RepositoryRequirementError,
|
|
|
NodeDoesNotExistError)
|
|
|
from rhodecode.model.db import Repository, ChangesetStatus
|
|
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
|
|
|
class RepoCompareView(RepoAppView):
|
|
|
def load_default_context(self):
|
|
|
c = self._get_local_tmpl_context(include_app_defaults=True)
|
|
|
|
|
|
c.rhodecode_repo = self.rhodecode_vcs_repo
|
|
|
|
|
|
|
|
|
return c
|
|
|
|
|
|
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.
|
|
|
"""
|
|
|
_ = self.request.translate
|
|
|
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')
|
|
|
if not partial:
|
|
|
raise HTTPFound(
|
|
|
h.route_path('repo_summary', repo_name=repo.repo_name))
|
|
|
raise HTTPBadRequest()
|
|
|
|
|
|
except RepositoryError as e:
|
|
|
log.exception(safe_str(e))
|
|
|
h.flash(safe_str(h.escape(e)), category='warning')
|
|
|
if not partial:
|
|
|
raise HTTPFound(
|
|
|
h.route_path('repo_summary', repo_name=repo.repo_name))
|
|
|
raise HTTPBadRequest()
|
|
|
|
|
|
@LoginRequired()
|
|
|
@HasRepoPermissionAnyDecorator(
|
|
|
'repository.read', 'repository.write', 'repository.admin')
|
|
|
@view_config(
|
|
|
route_name='repo_compare_select', request_method='GET',
|
|
|
renderer='rhodecode:templates/compare/compare_diff.mako')
|
|
|
def compare_select(self):
|
|
|
_ = self.request.translate
|
|
|
c = self.load_default_context()
|
|
|
|
|
|
source_repo = self.db_repo_name
|
|
|
target_repo = self.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)
|
|
|
|
|
|
if c.source_repo is None or c.target_repo is None:
|
|
|
raise HTTPNotFound()
|
|
|
|
|
|
c.compare_home = True
|
|
|
c.commit_ranges = []
|
|
|
c.collapse_all_commits = False
|
|
|
c.diffset = None
|
|
|
c.limited_diff = False
|
|
|
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
|
|
|
c.file_path = None
|
|
|
|
|
|
return self._get_template_context(c)
|
|
|
|
|
|
@LoginRequired()
|
|
|
@HasRepoPermissionAnyDecorator(
|
|
|
'repository.read', 'repository.write', 'repository.admin')
|
|
|
@view_config(
|
|
|
route_name='repo_compare', request_method='GET',
|
|
|
renderer=None)
|
|
|
def compare(self):
|
|
|
_ = self.request.translate
|
|
|
c = self.load_default_context()
|
|
|
|
|
|
source_ref_type = self.request.matchdict['source_ref_type']
|
|
|
source_ref = self.request.matchdict['source_ref']
|
|
|
target_ref_type = self.request.matchdict['target_ref_type']
|
|
|
target_ref = self.request.matchdict['target_ref']
|
|
|
|
|
|
# source_ref will be evaluated in source_repo
|
|
|
source_repo_name = self.db_repo_name
|
|
|
source_path, source_id = parse_path_ref(source_ref)
|
|
|
|
|
|
# target_ref will be evaluated in target_repo
|
|
|
target_repo_name = self.request.GET.get('target_repo', source_repo_name)
|
|
|
target_path, target_id = parse_path_ref(
|
|
|
target_ref, default_path=self.request.GET.get('f_path', ''))
|
|
|
|
|
|
# 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(self.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(self.request.GET.get('fulldiff'))
|
|
|
|
|
|
c.file_path = target_path
|
|
|
c.commit_statuses = ChangesetStatus.STATUSES
|
|
|
|
|
|
# if partial, returns just compare_commits.html (commits log)
|
|
|
partial = self.request.is_xhr
|
|
|
|
|
|
# swap url for compare_diff page
|
|
|
c.swap_url = h.route_path(
|
|
|
'repo_compare',
|
|
|
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,
|
|
|
_query=dict(merge=merge and '1' or '', f_path=target_path))
|
|
|
|
|
|
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:
|
|
|
log.error('Could not find the source repo: {}'
|
|
|
.format(source_repo_name))
|
|
|
h.flash(_('Could not find the source repo: `{}`')
|
|
|
.format(h.escape(source_repo_name)), category='error')
|
|
|
raise HTTPFound(
|
|
|
h.route_path('repo_compare_select', repo_name=self.db_repo_name))
|
|
|
|
|
|
if target_repo is None:
|
|
|
log.error('Could not find the target repo: {}'
|
|
|
.format(source_repo_name))
|
|
|
h.flash(_('Could not find the target repo: `{}`')
|
|
|
.format(h.escape(target_repo_name)), category='error')
|
|
|
raise HTTPFound(
|
|
|
h.route_path('repo_compare_select', repo_name=self.db_repo_name))
|
|
|
|
|
|
source_scm = source_repo.scm_instance()
|
|
|
target_scm = target_repo.scm_instance()
|
|
|
|
|
|
source_alias = source_scm.alias
|
|
|
target_alias = target_scm.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')
|
|
|
raise HTTPFound(
|
|
|
h.route_path('repo_compare_select', repo_name=self.db_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
|
|
|
|
|
|
pre_load = ["author", "branch", "date", "message"]
|
|
|
c.ancestor = None
|
|
|
|
|
|
if c.file_path:
|
|
|
if source_commit == target_commit:
|
|
|
c.commit_ranges = []
|
|
|
else:
|
|
|
c.commit_ranges = [target_commit]
|
|
|
else:
|
|
|
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 Response(msg)
|
|
|
h.flash(msg, category='error')
|
|
|
raise HTTPFound(
|
|
|
h.route_path('repo_compare_select',
|
|
|
repo_name=self.db_repo_name))
|
|
|
|
|
|
c.statuses = self.db_repo.statuses(
|
|
|
[x.raw_id for x in c.commit_ranges])
|
|
|
|
|
|
# auto collapse if we have more than limit
|
|
|
collapse_limit = diffs.DiffProcessor._collapse_commits_over
|
|
|
c.collapse_all_commits = len(c.commit_ranges) > collapse_limit
|
|
|
|
|
|
if partial: # for PR ajax commits loader
|
|
|
if not c.ancestor:
|
|
|
return Response('') # cannot merge if there is no ancestor
|
|
|
|
|
|
html = render(
|
|
|
'rhodecode:templates/compare/compare_commits.mako',
|
|
|
self._get_template_context(c), self.request)
|
|
|
return Response(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 = c.visual.cut_off_limit_diff
|
|
|
file_limit = c.visual.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 HTTPFound(
|
|
|
h.route_path('repo_compare_select',
|
|
|
repo_name=self.db_repo_name))
|
|
|
|
|
|
txt_diff = source_repo.scm_instance().get_diff(
|
|
|
commit1=source_commit, commit2=target_commit,
|
|
|
path=target_path, path1=source_path)
|
|
|
|
|
|
diff_processor = diffs.DiffProcessor(
|
|
|
txt_diff, format='newdiff', diff_limit=diff_limit,
|
|
|
file_limit=file_limit, show_full_diff=c.fulldiff)
|
|
|
_parsed = diff_processor.prepare()
|
|
|
|
|
|
def _node_getter(commit):
|
|
|
""" Returns a function that returns a node for a commit or None """
|
|
|
def get_node(fname):
|
|
|
try:
|
|
|
return commit.get_node(fname)
|
|
|
except NodeDoesNotExistError:
|
|
|
return None
|
|
|
return get_node
|
|
|
|
|
|
diffset = codeblocks.DiffSet(
|
|
|
repo_name=source_repo.repo_name,
|
|
|
source_node_getter=_node_getter(source_commit),
|
|
|
target_node_getter=_node_getter(target_commit),
|
|
|
)
|
|
|
c.diffset = diffset.render_patchset(
|
|
|
_parsed, source_ref, target_ref)
|
|
|
|
|
|
c.preview_mode = merge
|
|
|
c.source_commit = source_commit
|
|
|
c.target_commit = target_commit
|
|
|
|
|
|
html = render(
|
|
|
'rhodecode:templates/compare/compare_diff.mako',
|
|
|
self._get_template_context(c), self.request)
|
|
|
return Response(html)
|
