compare: cleanup of as_form handling

as_form is only used when loaded 'partial' from pullrequest.html. Including it
in the 'Detailed compare view' url did thus not do any harm.

as_form is never used in pullrequest_show.html or compare_diff.html and it is
thus never used together with swap_url ... which is why the wrong
'as_form=None' or 'as_form=False' in urls didn't do any harm.

rhodecode/controllers/compare.py

@@ -1,192 +1,192 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.compare
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     compare controller for pylons showing differences between two
     repos, branches, bookmarks or tips
 
     :created_on: May 6, 2012
     :author: marcink
     :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import logging
 import traceback
 
 from webob.exc import HTTPNotFound
 from pylons import request, response, session, tmpl_context as c, url
 from pylons.controllers.util import abort, redirect
 from pylons.i18n.translation import _
 
 from rhodecode.lib.vcs.exceptions import EmptyRepositoryError, RepositoryError
 from rhodecode.lib import helpers as h
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib import diffs
 
 from rhodecode.model.db import Repository
 from rhodecode.model.pull_request import PullRequestModel
 from webob.exc import HTTPBadRequest
 from rhodecode.lib.diffs import LimitedDiffContainer
 from rhodecode.lib.vcs.backends.base import EmptyChangeset
 
 log = logging.getLogger(__name__)
 
 
 class CompareController(BaseRepoController):
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def __before__(self):
         super(CompareController, self).__before__()
 
     def __get_cs_or_redirect(self, rev, repo, redirect_after=True,
                              partial=False):
         """
         Safe way to get changeset if error occur it redirects to changeset with
         proper message. If partial is set then don't do redirect raise Exception
         instead
 
         :param rev: revision to fetch
         :param repo: repo instance
         """
 
         try:
             type_, rev = rev
             return repo.scm_instance.get_changeset(rev)
         except EmptyRepositoryError, e:
             if not redirect_after:
                 return None
             h.flash(h.literal(_('There are no changesets yet')),
                     category='warning')
             redirect(url('summary_home', repo_name=repo.repo_name))
 
         except RepositoryError, e:
             log.error(traceback.format_exc())
             h.flash(str(e), category='warning')
             if not partial:
                 redirect(h.url('summary_home', repo_name=repo.repo_name))
             raise HTTPBadRequest()
 
     def index(self, org_ref_type, org_ref, other_ref_type, other_ref):
 
         org_repo = c.rhodecode_db_repo.repo_name
         org_ref = (org_ref_type, org_ref)
         other_ref = (other_ref_type, other_ref)
         other_repo = request.GET.get('other_repo', org_repo)
         c.fulldiff = fulldiff = request.GET.get('fulldiff')
         rev_start = request.GET.get('rev_start')
         rev_end = request.GET.get('rev_end')
-
-        c.swap_url = h.url('compare_url', as_form=request.GET.get('as_form'),
+        # partial uses compare_cs.html template directly
+        partial = request.environ.get('HTTP_X_PARTIAL_XHR')
+        # as_form puts hidden input field with changeset revisions
+        c.as_form = partial and request.GET.get('as_form')
+        # swap url for compare_diff page - never partial and never as_form
+        c.swap_url = h.url('compare_url',
             repo_name=other_repo,
             org_ref_type=other_ref[0], org_ref=other_ref[1],
             other_repo=org_repo,
             other_ref_type=org_ref[0], other_ref=org_ref[1])
 
-        partial = request.environ.get('HTTP_X_PARTIAL_XHR')
-
         org_repo = Repository.get_by_repo_name(org_repo)
         other_repo = Repository.get_by_repo_name(other_repo)
 
         self.__get_cs_or_redirect(rev=org_ref, repo=org_repo, partial=partial)
         self.__get_cs_or_redirect(rev=other_ref, repo=other_repo, partial=partial)
 
         if org_repo is None:
             log.error('Could not find org repo %s' % org_repo)
             raise HTTPNotFound
         if other_repo is None:
             log.error('Could not find other repo %s' % other_repo)
             raise HTTPNotFound
 
         if org_repo != other_repo and h.is_git(org_repo):
             log.error('compare of two remote repos not available for GIT REPOS')
             raise HTTPNotFound
 
         if org_repo.scm_instance.alias != other_repo.scm_instance.alias:
             log.error('compare of two different kind of remote repos not available')
             raise HTTPNotFound
 
         c.org_repo = org_repo
         c.other_repo = other_repo
         c.org_ref = org_ref[1]
         c.other_ref = other_ref[1]
         c.org_ref_type = org_ref[0]
         c.other_ref_type = other_ref[0]
 
         if rev_start and rev_end:
             # swap revs with cherry picked ones, save them for display
             #org_ref = ('rev', rev_start)
             #other_ref = ('rev', rev_end)
             c.org_ref = rev_start[:12]
             c.other_ref = rev_end[:12]
             # get parent of
             # rev start to include it in the diff
             _cs = other_repo.scm_instance.get_changeset(rev_start)
             rev_start = _cs.parents[0].raw_id if _cs.parents else EmptyChangeset().raw_id
             org_ref = ('rev', rev_start)
             other_ref = ('rev', rev_end)
             #if we cherry pick it's not remote, make the other_repo org_repo
             org_repo = other_repo
 
         c.cs_ranges, ancestor = PullRequestModel().get_compare_data(
             org_repo, org_ref, other_repo, other_ref)
 
         c.statuses = c.rhodecode_db_repo.statuses([x.raw_id for x in
                                                    c.cs_ranges])
-        # defines that we need hidden inputs with changesets
-        c.as_form = request.GET.get('as_form', False)
         if partial:
             return render('compare/compare_cs.html')
 
         if ancestor and org_repo != other_repo:
             # case we want a simple diff without incoming changesets,
             # previewing what will be merged.
             # Make the diff on the forked repo, with
             # revision that is common ancestor
             log.debug('Using ancestor %s as org_ref instead of %s'
                       % (ancestor, org_ref))
             org_ref = ('rev', ancestor)
             org_repo = other_repo
 
         diff_limit = self.cut_off_limit if not fulldiff else None
 
         _diff = diffs.differ(org_repo, org_ref, other_repo, other_ref)
 
         diff_processor = diffs.DiffProcessor(_diff or '', format='gitdiff',
                                              diff_limit=diff_limit)
         _parsed = diff_processor.prepare()
 
         c.limited_diff = False
         if isinstance(_parsed, 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 st[0] != 'b':
                 c.lines_added += st[0]
                 c.lines_deleted += st[1]
             fid = h.FID('', f['filename'])
             c.files.append([fid, f['operation'], f['filename'], f['stats']])
             diff = diff_processor.as_html(enable_comments=False, parsed_lines=[f])
             c.changes[fid] = [f['operation'], f['filename'], diff]
 
         return render('compare/compare_diff.html')

rhodecode/controllers/pullrequests.py

@@ -1,485 +1,484 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.pullrequests
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     pull requests controller for rhodecode for initializing pull requests
 
     :created_on: May 7, 2012
     :author: marcink
     :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import logging
 import traceback
 import formencode
 
 from webob.exc import HTTPNotFound, HTTPForbidden
 from collections import defaultdict
 from itertools import groupby
 
 from pylons import request, response, session, tmpl_context as c, url
 from pylons.controllers.util import abort, redirect
 from pylons.i18n.translation import _
 
 from rhodecode.lib.compat import json
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator,\
     NotAnonymous
 from rhodecode.lib import helpers as h
 from rhodecode.lib import diffs
 from rhodecode.lib.utils import action_logger, jsonify
 from rhodecode.lib.vcs.exceptions import EmptyRepositoryError
 from rhodecode.lib.vcs.backends.base import EmptyChangeset
 from rhodecode.lib.diffs import LimitedDiffContainer
 from rhodecode.model.db import User, PullRequest, ChangesetStatus,\
     ChangesetComment
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.comment import ChangesetCommentsModel
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.forms import PullRequestForm
 
 log = logging.getLogger(__name__)
 
 
 class PullrequestsController(BaseRepoController):
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def __before__(self):
         super(PullrequestsController, self).__before__()
         repo_model = RepoModel()
         c.users_array = repo_model.get_users_js()
         c.users_groups_array = repo_model.get_users_groups_js()
 
     def _get_repo_refs(self, repo):
         hist_l = []
 
         branches_group = ([('branch:%s:%s' % (k, v), k) for
                          k, v in repo.branches.iteritems()], _("Branches"))
         bookmarks_group = ([('book:%s:%s' % (k, v), k) for
                          k, v in repo.bookmarks.iteritems()], _("Bookmarks"))
         tags_group = ([('tag:%s:%s' % (k, v), k) for
                          k, v in repo.tags.iteritems()
                          if k != 'tip'], _("Tags"))
 
         tip = repo.tags['tip']
         tipref = 'tag:tip:%s' % tip
         colontip = ':' + tip
         tips = [x[1] for x in branches_group[0] + bookmarks_group[0] + tags_group[0]
                 if x[0].endswith(colontip)]
         tags_group[0].append((tipref, 'tip (%s)' % ', '.join(tips)))
 
         hist_l.append(bookmarks_group)
         hist_l.append(branches_group)
         hist_l.append(tags_group)
 
         return hist_l, tipref
 
     def _get_is_allowed_change_status(self, pull_request):
         owner = self.rhodecode_user.user_id == pull_request.user_id
         reviewer = self.rhodecode_user.user_id in [x.user_id for x in
                                                    pull_request.reviewers]
         return (self.rhodecode_user.admin or owner or reviewer)
 
     def show_all(self, repo_name):
         c.pull_requests = PullRequestModel().get_all(repo_name)
         c.repo_name = repo_name
         return render('/pullrequests/pullrequest_show_all.html')
 
     @NotAnonymous()
     def index(self):
         org_repo = c.rhodecode_db_repo
 
         if org_repo.scm_instance.alias != 'hg':
             log.error('Review not available for GIT REPOS')
             raise HTTPNotFound
 
         try:
             org_repo.scm_instance.get_changeset()
         except EmptyRepositoryError, e:
             h.flash(h.literal(_('There are no changesets yet')),
                     category='warning')
             redirect(url('summary_home', repo_name=org_repo.repo_name))
 
         other_repos_info = {}
 
         c.org_repos = []
         c.org_repos.append((org_repo.repo_name, org_repo.repo_name))
         c.default_org_repo = org_repo.repo_name
         c.org_refs, c.default_org_ref = self._get_repo_refs(org_repo.scm_instance)
 
         c.other_repos = []
         # add org repo to other so we can open pull request against itself
         c.other_repos.extend(c.org_repos)
         c.default_other_repo = org_repo.repo_name
         c.default_other_refs, c.default_other_ref = self._get_repo_refs(org_repo.scm_instance)
         usr_data = lambda usr: dict(user_id=usr.user_id,
                                     username=usr.username,
                                     firstname=usr.firstname,
                                     lastname=usr.lastname,
                                     gravatar_link=h.gravatar_url(usr.email, 14))
         other_repos_info[org_repo.repo_name] = {
             'user': usr_data(org_repo.user),
             'description': org_repo.description,
             'revs': h.select('other_ref', c.default_other_ref,
                              c.default_other_refs, class_='refs')
         }
 
         # gather forks and add to this list ... even though it is rare to
         # request forks to pull their parent
         for fork in org_repo.forks:
             c.other_repos.append((fork.repo_name, fork.repo_name))
             refs, default_ref = self._get_repo_refs(fork.scm_instance)
             other_repos_info[fork.repo_name] = {
                 'user': usr_data(fork.user),
                 'description': fork.description,
                 'revs': h.select('other_ref', default_ref, refs, class_='refs')
             }
 
         # add parents of this fork also, but only if it's not empty
         if org_repo.parent and org_repo.parent.scm_instance.revisions:
             c.default_other_repo = org_repo.parent.repo_name
             c.default_other_refs, c.default_other_ref = self._get_repo_refs(org_repo.parent.scm_instance)
             c.other_repos.append((org_repo.parent.repo_name, org_repo.parent.repo_name))
             other_repos_info[org_repo.parent.repo_name] = {
                 'user': usr_data(org_repo.parent.user),
                 'description': org_repo.parent.description,
                 'revs': h.select('other_ref', c.default_other_ref,
                                  c.default_other_refs, class_='refs')
             }
 
         c.other_repos_info = json.dumps(other_repos_info)
         # other repo owner
         c.review_members = []
         return render('/pullrequests/pullrequest.html')
 
     @NotAnonymous()
     def create(self, repo_name):
         repo = RepoModel()._get_repo(repo_name)
         try:
             _form = PullRequestForm(repo.repo_id)().to_python(request.POST)
         except formencode.Invalid, errors:
             log.error(traceback.format_exc())
             if errors.error_dict.get('revisions'):
                 msg = 'Revisions: %s' % errors.error_dict['revisions']
             elif errors.error_dict.get('pullrequest_title'):
                 msg = _('Pull request requires a title with min. 3 chars')
             else:
                 msg = _('error during creation of pull request')
 
             h.flash(msg, 'error')
             return redirect(url('pullrequest_home', repo_name=repo_name))
 
         org_repo = _form['org_repo']
         org_ref = _form['org_ref']
         other_repo = _form['other_repo']
         other_ref = _form['other_ref']
         revisions = _form['revisions']
         reviewers = _form['review_members']
 
         # if we have cherry picked pull request we don't care what is in
         # org_ref/other_ref
         rev_start = request.POST.get('rev_start')
         rev_end = request.POST.get('rev_end')
 
         if rev_start and rev_end:
             # this is swapped to simulate that rev_end is a revision from
             # parent of the fork
             org_ref = 'rev:%s:%s' % (rev_end, rev_end)
             other_ref = 'rev:%s:%s' % (rev_start, rev_start)
 
         title = _form['pullrequest_title']
         description = _form['pullrequest_desc']
 
         try:
             pull_request = PullRequestModel().create(
                 self.rhodecode_user.user_id, org_repo, org_ref, other_repo,
                 other_ref, revisions, reviewers, title, description
             )
             Session().commit()
             h.flash(_('Successfully opened new pull request'),
                     category='success')
         except Exception:
             h.flash(_('Error occurred during sending pull request'),
                     category='error')
             log.error(traceback.format_exc())
             return redirect(url('pullrequest_home', repo_name=repo_name))
 
         return redirect(url('pullrequest_show', repo_name=other_repo,
                             pull_request_id=pull_request.pull_request_id))
 
     @NotAnonymous()
     @jsonify
     def update(self, repo_name, pull_request_id):
         pull_request = PullRequest.get_or_404(pull_request_id)
         if pull_request.is_closed():
             raise HTTPForbidden()
         #only owner or admin can update it
         owner = pull_request.author.user_id == c.rhodecode_user.user_id
         if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:
             reviewers_ids = map(int, filter(lambda v: v not in [None, ''],
                        request.POST.get('reviewers_ids', '').split(',')))
 
             PullRequestModel().update_reviewers(pull_request_id, reviewers_ids)
             Session().commit()
             return True
         raise HTTPForbidden()
 
     @NotAnonymous()
     @jsonify
     def delete(self, repo_name, pull_request_id):
         pull_request = PullRequest.get_or_404(pull_request_id)
         #only owner can delete it !
         if pull_request.author.user_id == c.rhodecode_user.user_id:
             PullRequestModel().delete(pull_request)
             Session().commit()
             h.flash(_('Successfully deleted pull request'),
                     category='success')
             return redirect(url('admin_settings_my_account', anchor='pullrequests'))
         raise HTTPForbidden()
 
     def _load_compare_data(self, pull_request, enable_comments=True):
         """
         Load context data needed for generating compare diff
 
         :param pull_request:
         :type pull_request:
         """
         rev_start = request.GET.get('rev_start')
         rev_end = request.GET.get('rev_end')
 
         org_repo = pull_request.org_repo
         (org_ref_type,
          org_ref_name,
          org_ref_rev) = pull_request.org_ref.split(':')
 
         other_repo = org_repo
         (other_ref_type,
          other_ref_name,
          other_ref_rev) = pull_request.other_ref.split(':')
 
         # despite opening revisions for bookmarks/branches/tags, we always
         # convert this to rev to prevent changes after book or branch change
         org_ref = ('rev', org_ref_rev)
         other_ref = ('rev', other_ref_rev)
 
         c.org_repo = org_repo
         c.other_repo = other_repo
 
         c.fulldiff = fulldiff = request.GET.get('fulldiff')
 
         c.cs_ranges = [org_repo.get_changeset(x) for x in pull_request.revisions]
 
         other_ref = ('rev', getattr(c.cs_ranges[0].parents[0]
                                   if c.cs_ranges[0].parents
                                   else EmptyChangeset(), 'raw_id'))
 
         c.statuses = org_repo.statuses([x.raw_id for x in c.cs_ranges])
-        # defines that we need hidden inputs with changesets
-        c.as_form = request.GET.get('as_form', False)
 
         c.org_ref = org_ref[1]
         c.org_ref_type = org_ref[0]
         c.other_ref = other_ref[1]
         c.other_ref_type = other_ref[0]
 
         diff_limit = self.cut_off_limit if not fulldiff else None
 
         #we swap org/other ref since we run a simple diff on one repo
         _diff = diffs.differ(org_repo, other_ref, other_repo, org_ref)
 
         diff_processor = diffs.DiffProcessor(_diff or '', format='gitdiff',
                                              diff_limit=diff_limit)
         _parsed = diff_processor.prepare()
 
         c.limited_diff = False
         if isinstance(_parsed, 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 st[0] != 'b':
                 c.lines_added += st[0]
                 c.lines_deleted += st[1]
             fid = h.FID('', f['filename'])
             c.files.append([fid, f['operation'], f['filename'], f['stats']])
             diff = diff_processor.as_html(enable_comments=enable_comments,
                                           parsed_lines=[f])
             c.changes[fid] = [f['operation'], f['filename'], diff]
 
     def show(self, repo_name, pull_request_id):
         repo_model = RepoModel()
         c.users_array = repo_model.get_users_js()
         c.users_groups_array = repo_model.get_users_groups_js()
         c.pull_request = PullRequest.get_or_404(pull_request_id)
         c.allowed_to_change_status = self._get_is_allowed_change_status(c.pull_request)
         cc_model = ChangesetCommentsModel()
         cs_model = ChangesetStatusModel()
         _cs_statuses = cs_model.get_statuses(c.pull_request.org_repo,
                                             pull_request=c.pull_request,
                                             with_revisions=True)
 
         cs_statuses = defaultdict(list)
         for st in _cs_statuses:
             cs_statuses[st.author.username] += [st]
 
         c.pull_request_reviewers = []
         c.pull_request_pending_reviewers = []
         for o in c.pull_request.reviewers:
             st = cs_statuses.get(o.user.username, None)
             if st:
                 sorter = lambda k: k.version
                 st = [(x, list(y)[0])
                       for x, y in (groupby(sorted(st, key=sorter), sorter))]
             else:
                 c.pull_request_pending_reviewers.append(o.user)
             c.pull_request_reviewers.append([o.user, st])
 
         # pull_requests repo_name we opened it against
         # ie. other_repo must match
         if repo_name != c.pull_request.other_repo.repo_name:
             raise HTTPNotFound
 
         # load compare data into template context
         enable_comments = not c.pull_request.is_closed()
         self._load_compare_data(c.pull_request, enable_comments=enable_comments)
 
         # inline comments
         c.inline_cnt = 0
         c.inline_comments = cc_model.get_inline_comments(
                                 c.rhodecode_db_repo.repo_id,
                                 pull_request=pull_request_id)
         # count inline comments
         for __, lines in c.inline_comments:
             for comments in lines.values():
                 c.inline_cnt += len(comments)
         # comments
         c.comments = cc_model.get_comments(c.rhodecode_db_repo.repo_id,
                                            pull_request=pull_request_id)
 
         try:
             cur_status = c.statuses[c.pull_request.revisions[0]][0]
         except:
             log.error(traceback.format_exc())
             cur_status = 'undefined'
         if c.pull_request.is_closed() and 0:
             c.current_changeset_status = cur_status
         else:
             # changeset(pull-request) status calulation based on reviewers
             c.current_changeset_status = cs_model.calculate_status(
                                             c.pull_request_reviewers,
                                          )
         c.changeset_statuses = ChangesetStatus.STATUSES
 
+        c.as_form = False
         return render('/pullrequests/pullrequest_show.html')
 
     @NotAnonymous()
     @jsonify
     def comment(self, repo_name, pull_request_id):
         pull_request = PullRequest.get_or_404(pull_request_id)
         if pull_request.is_closed():
             raise HTTPForbidden()
 
         status = request.POST.get('changeset_status')
         change_status = request.POST.get('change_changeset_status')
         text = request.POST.get('text')
         close_pr = request.POST.get('save_close')
 
         allowed_to_change_status = self._get_is_allowed_change_status(pull_request)
         if status and change_status and allowed_to_change_status:
             _def = (_('status change -> %s')
                             % ChangesetStatus.get_status_lbl(status))
             if close_pr:
                 _def = _('Closing with') + ' ' + _def
             text = text or _def
         comm = ChangesetCommentsModel().create(
             text=text,
             repo=c.rhodecode_db_repo.repo_id,
             user=c.rhodecode_user.user_id,
             pull_request=pull_request_id,
             f_path=request.POST.get('f_path'),
             line_no=request.POST.get('line'),
             status_change=(ChangesetStatus.get_status_lbl(status)
                            if status and change_status
                            and allowed_to_change_status else None),
             closing_pr=close_pr
         )
 
         action_logger(self.rhodecode_user,
                       'user_commented_pull_request:%s' % pull_request_id,
                       c.rhodecode_db_repo, self.ip_addr, self.sa)
 
         if allowed_to_change_status:
             # get status if set !
             if status and change_status:
                 ChangesetStatusModel().set_status(
                     c.rhodecode_db_repo.repo_id,
                     status,
                     c.rhodecode_user.user_id,
                     comm,
                     pull_request=pull_request_id
                 )
 
             if close_pr:
                 if status in ['rejected', 'approved']:
                     PullRequestModel().close_pull_request(pull_request_id)
                     action_logger(self.rhodecode_user,
                               'user_closed_pull_request:%s' % pull_request_id,
                               c.rhodecode_db_repo, self.ip_addr, self.sa)
                 else:
                     h.flash(_('Closing pull request on other statuses than '
                               'rejected or approved forbidden'),
                             category='warning')
 
         Session().commit()
 
         if not request.environ.get('HTTP_X_PARTIAL_XHR'):
             return redirect(h.url('pullrequest_show', repo_name=repo_name,
                                   pull_request_id=pull_request_id))
 
         data = {
            'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),
         }
         if comm:
             c.co = comm
             data.update(comm.get_dict())
             data.update({'rendered_text':
                          render('changeset/changeset_comment_block.html')})
 
         return data
 
     @NotAnonymous()
     @jsonify
     def delete_comment(self, repo_name, comment_id):
         co = ChangesetComment.get(comment_id)
         if co.pull_request.is_closed():
             #don't allow deleting comments on closed pull request
             raise HTTPForbidden()
 
         owner = co.author.user_id == c.rhodecode_user.user_id
         if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:
             ChangesetCommentsModel().delete(comment=co)
             Session().commit()
             return True
         else:
             raise HTTPForbidden()

rhodecode/tests/functional/test_compare.py

@@ -1,445 +1,445 b''
 from rhodecode.tests import *
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.meta import Session
 from rhodecode.model.db import Repository
 from rhodecode.model.scm import ScmModel
 from rhodecode.lib.vcs.backends.base import EmptyChangeset
 
 
 def _fork_repo(fork_name, vcs_type, parent=None):
     if vcs_type =='hg':
         _REPO = HG_REPO
     elif vcs_type == 'git':
         _REPO = GIT_REPO
 
     if parent:
         _REPO = parent
 
     form_data = dict(
         repo_name=fork_name,
         repo_name_full=fork_name,
         repo_group=None,
         repo_type=vcs_type,
         description='',
         private=False,
         copy_permissions=False,
         landing_rev='tip',
         update_after_clone=False,
         fork_parent_id=Repository.get_by_repo_name(_REPO),
     )
     RepoModel().create_fork(form_data, cur_user=TEST_USER_ADMIN_LOGIN)
 
     Session().commit()
     return Repository.get_by_repo_name(fork_name)
 
 
 def _commit_change(repo, filename, content, message, vcs_type, parent=None, newfile=False):
     repo = Repository.get_by_repo_name(repo)
     _cs = parent
     if not parent:
         _cs = EmptyChangeset(alias=vcs_type)
 
     if newfile:
         cs = ScmModel().create_node(
             repo=repo.scm_instance, repo_name=repo.repo_name,
             cs=_cs, user=TEST_USER_ADMIN_LOGIN,
             author=TEST_USER_ADMIN_LOGIN,
             message=message,
             content=content,
             f_path=filename
         )
     else:
         cs = ScmModel().commit_change(
             repo=repo.scm_instance, repo_name=repo.repo_name,
             cs=parent, user=TEST_USER_ADMIN_LOGIN,
             author=TEST_USER_ADMIN_LOGIN,
             message=message,
             content=content,
             f_path=filename
         )
     return cs
 
 
 class TestCompareController(TestController):
 
     def setUp(self):
         self.r1_id = None
         self.r2_id = None
 
     def tearDown(self):
         if self.r2_id:
             RepoModel().delete(self.r2_id)
         if self.r1_id:
             RepoModel().delete(self.r1_id)
         Session().commit()
         Session.remove()
 
     def test_compare_forks_on_branch_extra_commits_hg(self):
         self.log_user()
         repo1 = RepoModel().create_repo(repo_name='one', repo_type='hg',
                                         description='diff-test',
                                         owner=TEST_USER_ADMIN_LOGIN)
         Session().commit()
         self.r1_id = repo1.repo_id
         #commit something !
         cs0 = _commit_change(repo1.repo_name, filename='file1', content='line1\n',
                              message='commit1', vcs_type='hg', parent=None, newfile=True)
 
         #fork this repo
         repo2 = _fork_repo('one-fork', 'hg', parent='one')
         self.r2_id = repo2.repo_id
 
         #add two extra commit into fork
         cs1 = _commit_change(repo2.repo_name, filename='file1', content='line1\nline2\n',
                              message='commit2', vcs_type='hg', parent=cs0)
 
         cs2 = _commit_change(repo2.repo_name, filename='file1', content='line1\nline2\nline3\n',
                              message='commit3', vcs_type='hg', parent=cs1)
 
         rev1 = 'default'
         rev2 = 'default'
 
         response = self.app.get(url(controller='compare', action='index',
                                     repo_name=repo1.repo_name,
                                     org_ref_type="branch",
                                     org_ref=rev2,
                                     other_repo=repo2.repo_name,
                                     other_ref_type="branch",
                                     other_ref=rev1,
                                     ))
 
         response.mustcontain('%s@%s -> %s@%s' % (repo1.repo_name, rev2, repo2.repo_name, rev1))
         response.mustcontain("""Showing 2 commits""")
         response.mustcontain("""1 file changed with 2 insertions and 0 deletions""")
 
         response.mustcontain("""<div class="message tooltip" title="commit2" style="white-space:normal">commit2</div>""")
         response.mustcontain("""<div class="message tooltip" title="commit3" style="white-space:normal">commit3</div>""")
 
         response.mustcontain("""<a href="/%s/changeset/%s">r1:%s</a>""" % (repo2.repo_name, cs1.raw_id, cs1.short_id))
         response.mustcontain("""<a href="/%s/changeset/%s">r2:%s</a>""" % (repo2.repo_name, cs2.raw_id, cs2.short_id))
         ## files
         response.mustcontain("""<a href="/%s/compare/branch@%s...branch@%s?other_repo=%s#C--826e8142e6ba">file1</a>""" % (repo1.repo_name, rev2, rev1, repo2.repo_name))
         #swap
-        response.mustcontain("""<a href="/%s/compare/branch@%s...branch@%s?as_form=None&amp;other_repo=%s">[swap]</a>""" % (repo2.repo_name, rev1, rev2, repo1.repo_name))
+        response.mustcontain("""<a href="/%s/compare/branch@%s...branch@%s?other_repo=%s">[swap]</a>""" % (repo2.repo_name, rev1, rev2, repo1.repo_name))
 
     def test_compare_forks_on_branch_extra_commits_origin_has_incomming_hg(self):
         self.log_user()
 
         repo1 = RepoModel().create_repo(repo_name='one', repo_type='hg',
                                         description='diff-test',
                                         owner=TEST_USER_ADMIN_LOGIN)
         Session().commit()
         self.r1_id = repo1.repo_id
 
         #commit something !
         cs0 = _commit_change(repo1.repo_name, filename='file1', content='line1\n',
                              message='commit1', vcs_type='hg', parent=None, newfile=True)
 
         #fork this repo
         repo2 = _fork_repo('one-fork', 'hg', parent='one')
         self.r2_id = repo2.repo_id
 
         #now commit something to origin repo
         cs1_prim = _commit_change(repo1.repo_name, filename='file2', content='line1file2\n',
                                   message='commit2', vcs_type='hg', parent=cs0, newfile=True)
 
         #add two extra commit into fork
         cs1 = _commit_change(repo2.repo_name, filename='file1', content='line1\nline2\n',
                              message='commit2', vcs_type='hg', parent=cs0)
 
         cs2 = _commit_change(repo2.repo_name, filename='file1', content='line1\nline2\nline3\n',
                              message='commit3', vcs_type='hg', parent=cs1)
 
         rev1 = 'default'
         rev2 = 'default'
 
         response = self.app.get(url(controller='compare', action='index',
                                     repo_name=repo1.repo_name,
                                     org_ref_type="branch",
                                     org_ref=rev2,
                                     other_repo=repo2.repo_name,
                                     other_ref_type="branch",
                                     other_ref=rev1,
                                     ))
         response.mustcontain('%s@%s -&gt; %s@%s' % (repo1.repo_name, rev2, repo2.repo_name, rev1))
         response.mustcontain("""Showing 2 commits""")
         response.mustcontain("""1 file changed with 2 insertions and 0 deletions""")
 
         response.mustcontain("""<div class="message tooltip" title="commit2" style="white-space:normal">commit2</div>""")
         response.mustcontain("""<div class="message tooltip" title="commit3" style="white-space:normal">commit3</div>""")
 
         response.mustcontain("""<a href="/%s/changeset/%s">r1:%s</a>""" % (repo2.repo_name, cs1.raw_id, cs1.short_id))
         response.mustcontain("""<a href="/%s/changeset/%s">r2:%s</a>""" % (repo2.repo_name, cs2.raw_id, cs2.short_id))
         ## files
         response.mustcontain("""<a href="/%s/compare/branch@%s...branch@%s?other_repo=%s#C--826e8142e6ba">file1</a>""" % (repo1.repo_name, rev2, rev1, repo2.repo_name))
         #swap
-        response.mustcontain("""<a href="/%s/compare/branch@%s...branch@%s?as_form=None&amp;other_repo=%s">[swap]</a>""" % (repo2.repo_name, rev1, rev2, repo1.repo_name))
+        response.mustcontain("""<a href="/%s/compare/branch@%s...branch@%s?other_repo=%s">[swap]</a>""" % (repo2.repo_name, rev1, rev2, repo1.repo_name))
 
     def test_compare_cherry_pick_changesets_from_bottom(self):
 
 #        repo1:
 #            cs0:
 #            cs1:
 #        repo1-fork- in which we will cherry pick bottom changesets
 #            cs0:
 #            cs1:
 #            cs2: x
 #            cs3: x
 #            cs4: x
 #            cs5:
         #make repo1, and cs1+cs2
         self.log_user()
 
         repo1 = RepoModel().create_repo(repo_name='repo1', repo_type='hg',
                                         description='diff-test',
                                         owner=TEST_USER_ADMIN_LOGIN)
         Session().commit()
         self.r1_id = repo1.repo_id
 
         #commit something !
         cs0 = _commit_change(repo1.repo_name, filename='file1', content='line1\n',
                              message='commit1', vcs_type='hg', parent=None,
                              newfile=True)
         cs1 = _commit_change(repo1.repo_name, filename='file1', content='line1\nline2\n',
                              message='commit2', vcs_type='hg', parent=cs0)
         #fork this repo
         repo2 = _fork_repo('repo1-fork', 'hg', parent='repo1')
         self.r2_id = repo2.repo_id
         #now make cs3-6
         cs2 = _commit_change(repo1.repo_name, filename='file1', content='line1\nline2\nline3\n',
                              message='commit3', vcs_type='hg', parent=cs1)
         cs3 = _commit_change(repo1.repo_name, filename='file1', content='line1\nline2\nline3\nline4\n',
                              message='commit4', vcs_type='hg', parent=cs2)
         cs4 = _commit_change(repo1.repo_name, filename='file1', content='line1\nline2\nline3\nline4\nline5\n',
                              message='commit5', vcs_type='hg', parent=cs3)
         cs5 = _commit_change(repo1.repo_name, filename='file1', content='line1\nline2\nline3\nline4\nline5\nline6\n',
                              message='commit6', vcs_type='hg', parent=cs4)
 
         rev1 = 'tip'
         rev2 = 'tip'
 
         response = self.app.get(url(controller='compare', action='index',
                                     repo_name=repo2.repo_name,
                                     org_ref_type="tag",
                                     org_ref=rev1,
                                     other_repo=repo1.repo_name,
                                     other_ref_type="tag",
                                     other_ref=rev2,
                                     rev_start=cs2.raw_id,
                                     rev_end=cs4.raw_id,
                                     ))
         response.mustcontain('%s@%s -&gt; %s@%s' % (repo2.repo_name, cs2.short_id, repo1.repo_name, cs4.short_id))
         response.mustcontain("""Showing 3 commits""")
         response.mustcontain("""1 file changed with 3 insertions and 0 deletions""")
 
         response.mustcontain("""<div class="message tooltip" title="commit3" style="white-space:normal">commit3</div>""")
         response.mustcontain("""<div class="message tooltip" title="commit4" style="white-space:normal">commit4</div>""")
         response.mustcontain("""<div class="message tooltip" title="commit5" style="white-space:normal">commit5</div>""")
 
         response.mustcontain("""<a href="/%s/changeset/%s">r2:%s</a>""" % (repo1.repo_name, cs2.raw_id, cs2.short_id))
         response.mustcontain("""<a href="/%s/changeset/%s">r3:%s</a>""" % (repo1.repo_name, cs3.raw_id, cs3.short_id))
         response.mustcontain("""<a href="/%s/changeset/%s">r4:%s</a>""" % (repo1.repo_name, cs4.raw_id, cs4.short_id))
         ## files
         response.mustcontain("""#C--826e8142e6ba">file1</a>""")
 
     def test_compare_cherry_pick_changesets_from_top(self):
 #        repo1:
 #            cs0:
 #            cs1:
 #        repo1-fork- in which we will cherry pick bottom changesets
 #            cs0:
 #            cs1:
 #            cs2:
 #            cs3: x
 #            cs4: x
 #            cs5: x
 #
         #make repo1, and cs1+cs2
         self.log_user()
         repo1 = RepoModel().create_repo(repo_name='repo1', repo_type='hg',
                                         description='diff-test',
                                         owner=TEST_USER_ADMIN_LOGIN)
         Session().commit()
         self.r1_id = repo1.repo_id
 
         #commit something !
         cs0 = _commit_change(repo1.repo_name, filename='file1', content='line1\n',
                              message='commit1', vcs_type='hg', parent=None,
                              newfile=True)
         cs1 = _commit_change(repo1.repo_name, filename='file1', content='line1\nline2\n',
                              message='commit2', vcs_type='hg', parent=cs0)
         #fork this repo
         repo2 = _fork_repo('repo1-fork', 'hg', parent='repo1')
         self.r2_id = repo2.repo_id
         #now make cs3-6
         cs2 = _commit_change(repo1.repo_name, filename='file1', content='line1\nline2\nline3\n',
                              message='commit3', vcs_type='hg', parent=cs1)
         cs3 = _commit_change(repo1.repo_name, filename='file1', content='line1\nline2\nline3\nline4\n',
                              message='commit4', vcs_type='hg', parent=cs2)
         cs4 = _commit_change(repo1.repo_name, filename='file1', content='line1\nline2\nline3\nline4\nline5\n',
                              message='commit5', vcs_type='hg', parent=cs3)
         cs5 = _commit_change(repo1.repo_name, filename='file1', content='line1\nline2\nline3\nline4\nline5\nline6\n',
                              message='commit6', vcs_type='hg', parent=cs4)
         rev1 = 'tip'
         rev2 = 'tip'
 
         response = self.app.get(url(controller='compare', action='index',
                                     repo_name=repo2.repo_name,
                                     org_ref_type="tag",
                                     org_ref=rev1,
                                     other_repo=repo1.repo_name,
                                     other_ref_type="tag",
                                     other_ref=rev2,
                                     rev_start=cs3.raw_id,
                                     rev_end=cs5.raw_id,
                                     ))
 
         response.mustcontain('%s@%s -&gt; %s@%s' % (repo2.repo_name, cs3.short_id, repo1.repo_name, cs5.short_id))
         response.mustcontain("""Showing 3 commits""")
         response.mustcontain("""1 file changed with 3 insertions and 0 deletions""")
 
         response.mustcontain("""<div class="message tooltip" title="commit4" style="white-space:normal">commit4</div>""")
         response.mustcontain("""<div class="message tooltip" title="commit5" style="white-space:normal">commit5</div>""")
         response.mustcontain("""<div class="message tooltip" title="commit6" style="white-space:normal">commit6</div>""")
 
         response.mustcontain("""<a href="/%s/changeset/%s">r3:%s</a>""" % (repo1.repo_name, cs3.raw_id, cs3.short_id))
         response.mustcontain("""<a href="/%s/changeset/%s">r4:%s</a>""" % (repo1.repo_name, cs4.raw_id, cs4.short_id))
         response.mustcontain("""<a href="/%s/changeset/%s">r5:%s</a>""" % (repo1.repo_name, cs5.raw_id, cs5.short_id))
         ## files
         response.mustcontain("""#C--826e8142e6ba">file1</a>""")
 
     def test_compare_cherry_pick_changeset_mixed_branches(self):
         """
 
         """
         pass
         #TODO write this tastecase
 
     def test_compare_remote_branches_hg(self):
         self.log_user()
 
         repo2 = _fork_repo(HG_FORK, 'hg')
         self.r2_id = repo2.repo_id
         rev1 = '56349e29c2af'
         rev2 = '7d4bc8ec6be5'
 
         response = self.app.get(url(controller='compare', action='index',
                                     repo_name=HG_REPO,
                                     org_ref_type="rev",
                                     org_ref=rev1,
                                     other_ref_type="rev",
                                     other_ref=rev2,
                                     other_repo=HG_FORK,
                                     ))
         response.mustcontain('%s@%s -&gt; %s@%s' % (HG_REPO, rev1, HG_FORK, rev2))
         ## outgoing changesets between those revisions
 
         response.mustcontain("""<a href="/%s/changeset/2dda4e345facb0ccff1a191052dd1606dba6781d">r4:2dda4e345fac</a>""" % (HG_FORK))
         response.mustcontain("""<a href="/%s/changeset/6fff84722075f1607a30f436523403845f84cd9e">r5:6fff84722075</a>""" % (HG_FORK))
         response.mustcontain("""<a href="/%s/changeset/7d4bc8ec6be56c0f10425afb40b6fc315a4c25e7">r6:%s</a>""" % (HG_FORK, rev2))
 
         ## files
         response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s?other_repo=%s#C--9c390eb52cd6">vcs/backends/hg.py</a>""" % (HG_REPO, rev1, rev2, HG_FORK))
         response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s?other_repo=%s#C--41b41c1f2796">vcs/backends/__init__.py</a>""" % (HG_REPO, rev1, rev2, HG_FORK))
         response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s?other_repo=%s#C--2f574d260608">vcs/backends/base.py</a>""" % (HG_REPO, rev1, rev2, HG_FORK))
 
     def test_org_repo_new_commits_after_forking_simple_diff(self):
         self.log_user()
 
         repo1 = RepoModel().create_repo(repo_name='one', repo_type='hg',
                                         description='diff-test',
                                         owner=TEST_USER_ADMIN_LOGIN)
 
         Session().commit()
         self.r1_id = repo1.repo_id
         r1_name = repo1.repo_name
 
         #commit something initially !
         cs0 = ScmModel().create_node(
             repo=repo1.scm_instance, repo_name=r1_name,
             cs=EmptyChangeset(alias='hg'), user=TEST_USER_ADMIN_LOGIN,
             author=TEST_USER_ADMIN_LOGIN,
             message='commit1',
             content='line1',
             f_path='file1'
         )
         Session().commit()
         self.assertEqual(repo1.scm_instance.revisions, [cs0.raw_id])
         #fork the repo1
         repo2 = RepoModel().create_repo(repo_name='one-fork', repo_type='hg',
                                 description='compare-test',
                                 clone_uri=repo1.repo_full_path,
                                 owner=TEST_USER_ADMIN_LOGIN, fork_of='one')
         Session().commit()
         self.assertEqual(repo2.scm_instance.revisions, [cs0.raw_id])
         self.r2_id = repo2.repo_id
         r2_name = repo2.repo_name
 
         #make 3 new commits in fork
         cs1 = ScmModel().create_node(
             repo=repo2.scm_instance, repo_name=r2_name,
             cs=repo2.scm_instance[-1], user=TEST_USER_ADMIN_LOGIN,
             author=TEST_USER_ADMIN_LOGIN,
             message='commit1-fork',
             content='file1-line1-from-fork',
             f_path='file1-fork'
         )
         cs2 = ScmModel().create_node(
             repo=repo2.scm_instance, repo_name=r2_name,
             cs=cs1, user=TEST_USER_ADMIN_LOGIN,
             author=TEST_USER_ADMIN_LOGIN,
             message='commit2-fork',
             content='file2-line1-from-fork',
             f_path='file2-fork'
         )
         cs3 = ScmModel().create_node(
             repo=repo2.scm_instance, repo_name=r2_name,
             cs=cs2, user=TEST_USER_ADMIN_LOGIN,
             author=TEST_USER_ADMIN_LOGIN,
             message='commit3-fork',
             content='file3-line1-from-fork',
             f_path='file3-fork'
         )
 
         #compare !
         rev1 = 'default'
         rev2 = 'default'
 
         response = self.app.get(url(controller='compare', action='index',
                                     repo_name=r2_name,
                                     org_ref_type="branch",
                                     org_ref=rev1,
                                     other_ref_type="branch",
                                     other_ref=rev2,
                                     other_repo=r1_name,
                                     ))
         response.mustcontain('%s@%s -&gt; %s@%s' % (r2_name, rev1, r1_name, rev2))
         response.mustcontain('No files')
         response.mustcontain('No changesets')
 
         #add new commit into parent !
         cs0 = ScmModel().create_node(
             repo=repo1.scm_instance, repo_name=r1_name,
             cs=EmptyChangeset(alias='hg'), user=TEST_USER_ADMIN_LOGIN,
             author=TEST_USER_ADMIN_LOGIN,
             message='commit2-parent',
             content='line1-added-after-fork',
             f_path='file2'
         )
         #compare !
         rev1 = 'default'
         rev2 = 'default'
         response = self.app.get(url(controller='compare', action='index',
                                     repo_name=r2_name,
                                     org_ref_type="branch",
                                     org_ref=rev1,
                                     other_ref_type="branch",
                                     other_ref=rev2,
                                     other_repo=r1_name,
                                     ))
 
         response.mustcontain('%s@%s -&gt; %s@%s' % (r2_name, rev1, r1_name, rev2))
 
         response.mustcontain("""commit2-parent""")
         response.mustcontain("""1 file changed with 1 insertions and 0 deletions""")
         response.mustcontain("""line1-added-after-fork""")