Multiple changes for compare system

- count number of changed lines and files
- add combined compare button into the old per changeset compare
- fixed some logic for remote & bundle compare system
- added few tests for git compare

rhodecode/controllers/compare.py

@@ -1,161 +1,167
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.compare
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     compare controller for pylons showoing 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.utils2 import str2bool
 from rhodecode.lib.diffs import LimitedDiffContainer
 
 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('repo', org_repo)
-        bundle_compare = str2bool(request.GET.get('bundle', True))
+        remote_compare = str2bool(request.GET.get('bundle', True))
         c.fulldiff = fulldiff = request.GET.get('fulldiff')
 
         c.swap_url = h.url('compare_url', repo_name=other_repo,
               org_ref_type=other_ref[0], org_ref=other_ref[1],
               other_ref_type=org_ref[0], other_ref=org_ref[1],
               repo=org_repo, as_form=request.GET.get('as_form'),
-              bundle=bundle_compare)
+              bundle=remote_compare)
 
         c.org_repo = org_repo = Repository.get_by_repo_name(org_repo)
         c.other_repo = other_repo = Repository.get_by_repo_name(other_repo)
 
         if c.org_repo is None or c.other_repo is None:
             log.error('Could not found repo %s or %s' % (org_repo, other_repo))
             raise HTTPNotFound
 
         if c.org_repo != c.other_repo and h.is_git(c.rhodecode_repo):
             log.error('compare of two remote repos not available for GIT REPOS')
             raise HTTPNotFound
 
         if c.org_repo.scm_instance.alias != c.other_repo.scm_instance.alias:
             log.error('compare of two different kind of remote repos not available')
             raise HTTPNotFound
 
         partial = request.environ.get('HTTP_X_PARTIAL_XHR')
         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)
 
         c.cs_ranges, discovery_data = 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])
         c.target_repo = c.repo_name
         # 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 not bundle_compare and c.cs_ranges:
+        c.org_ref = org_ref[1]
+        c.other_ref = other_ref[1]
+
+        if not remote_compare and c.cs_ranges:
             # case we want a simple diff without incoming changesets, just
             # for review purposes. Make the diff on the forked repo, with
             # revision that is common ancestor
             other_ref = ('rev', c.cs_ranges[-1].parents[0].raw_id)
             other_repo = org_repo
 
-        c.org_ref = org_ref[1]
-        c.other_ref = other_ref[1]
+        diff_limit = self.cut_off_limit if not fulldiff else None
+        _diff = diffs.differ(org_repo, org_ref, other_repo, other_ref,
+                             discovery_data, remote_compare=remote_compare)
 
-        _diff = diffs.differ(other_repo, other_ref, org_repo, org_ref,
-                             discovery_data, bundle_compare=bundle_compare)
-        diff_limit = self.cut_off_limit if not fulldiff else None
-        diff_processor = diffs.DiffProcessor(_diff, format='gitdiff',
+        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,446 +1,449
 # -*- 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 pylons.decorators import jsonify
 
 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
 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
 from rhodecode.lib.vcs.exceptions import EmptyRepositoryError
+from rhodecode.lib.vcs.backends.base import EmptyChangeset
 
 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()], _("Tags"))
 
         hist_l.append(bookmarks_group)
         hist_l.append(branches_group)
         hist_l.append(tags_group)
 
         return hist_l
 
     def _get_default_rev(self, repo):
         """
         Get's default revision to do compare on pull request
 
         :param repo:
         """
         repo = repo.scm_instance
         if 'default' in repo.branches:
             return 'default'
         else:
             #if repo doesn't have default branch return first found
             return repo.branches.keys()[0]
 
     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_refs = self._get_repo_refs(c.rhodecode_repo)
         c.org_repos = []
         c.other_repos = []
         c.org_repos.append((org_repo.repo_name, '%s/%s' % (
                                 org_repo.user.username, c.repo_name))
                            )
 
         # add org repo to other so we can open pull request agains itself
         c.other_repos.extend(c.org_repos)
 
         c.default_pull_request = org_repo.repo_name  # repo name pre-selected
         c.default_pull_request_rev = self._get_default_rev(org_repo)  # revision pre-selected
         c.default_revs = self._get_repo_refs(org_repo.scm_instance)
         #add orginal repo
         other_repos_info[org_repo.repo_name] = {
             'gravatar': h.gravatar_url(org_repo.user.email, 24),
             'description': org_repo.description,
             'revs': h.select('other_ref', '', c.default_revs, class_='refs')
         }
 
         #gather forks and add to this list
         for fork in org_repo.forks:
             c.other_repos.append((fork.repo_name, '%s/%s' % (
                                     fork.user.username, fork.repo_name))
                                  )
             other_repos_info[fork.repo_name] = {
                 'gravatar': h.gravatar_url(fork.user.email, 24),
                 'description': fork.description,
                 'revs': h.select('other_ref', '',
                                  self._get_repo_refs(fork.scm_instance),
                                  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_pull_request = org_repo.parent.repo_name
             c.default_pull_request_rev = self._get_default_rev(org_repo.parent)
             c.default_revs = self._get_repo_refs(org_repo.parent.scm_instance)
             c.other_repos.append((org_repo.parent.repo_name, '%s/%s' % (
                                         org_repo.parent.user.username,
                                         org_repo.parent.repo_name))
                                      )
             other_repos_info[org_repo.parent.repo_name] = {
                 'gravatar': h.gravatar_url(org_repo.parent.user.email, 24),
                 'description': org_repo.parent.description,
                 'revs': h.select('other_ref', '',
                                  self._get_repo_refs(org_repo.parent.scm_instance),
                                  class_='refs')
             }
 
         c.other_repos_info = json.dumps(other_repos_info)
         c.review_members = [org_repo.user]
         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']
 
         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'))
         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:
         """
 
         org_repo = pull_request.org_repo
         (org_ref_type,
          org_ref_name,
          org_ref_rev) = pull_request.org_ref.split(':')
 
         other_repo = pull_request.other_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.cs_ranges, discovery_data = PullRequestModel().get_compare_data(
                                        org_repo, org_ref, other_repo, other_ref
                                       )
         if c.cs_ranges:
             # case we want a simple diff without incoming changesets, just
             # for review purposes. Make the diff on the forked repo, with
             # revision that is common ancestor
-            other_ref = ('rev', c.cs_ranges[-1].parents[0].raw_id)
+            other_ref = ('rev', getattr(c.cs_ranges[-1].parents[0]
+                                        if c.cs_ranges[-1].parents
+                                        else EmptyChangeset(), 'raw_id'))
             other_repo = org_repo
 
         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.other_ref = other_ref[1]
-        # diff needs to have swapped org with other to generate proper diff
-        _diff = diffs.differ(other_repo, other_ref, org_repo, org_ref,
+        _diff = diffs.differ(org_repo, org_ref, other_repo, other_ref,
                              discovery_data)
+
         diff_processor = diffs.DiffProcessor(_diff, format='gitdiff')
         _parsed = diff_processor.prepare()
 
         c.files = []
         c.changes = {}
 
         for f in _parsed:
             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.target_repo = c.pull_request.org_repo.repo_name
 
         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
 
         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')
         if status and change_status:
             text = text or (_('Status change -> %s')
                             % ChangesetStatus.get_status_lbl(status))
         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 else None)
         )
 
         # 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
             )
         action_logger(self.rhodecode_user,
                       'user_commented_pull_request:%s' % pull_request_id,
                       c.rhodecode_db_repo, self.ip_addr, self.sa)
 
         if request.POST.get('save_close'):
             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)
 
         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 = lambda: 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/lib/diffs.py

@@ -1,771 +1,768
 # -*- coding: utf-8 -*-
 """
     rhodecode.lib.diffs
     ~~~~~~~~~~~~~~~~~~~
 
     Set of diffing helpers, previously part of vcs
 
 
     :created_on: Dec 4, 2011
     :author: marcink
     :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :original copyright: 2007-2008 by Armin Ronacher
     :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 re
 import difflib
 import logging
 import traceback
 
 from itertools import tee, imap
 
 from mercurial import patch
 from mercurial.mdiff import diffopts
 from mercurial.bundlerepo import bundlerepository
 
 from pylons.i18n.translation import _
 
 from rhodecode.lib.compat import BytesIO
 from rhodecode.lib.vcs.utils.hgcompat import localrepo
 from rhodecode.lib.vcs.exceptions import VCSError
 from rhodecode.lib.vcs.nodes import FileNode, SubModuleNode
 from rhodecode.lib.vcs.backends.base import EmptyChangeset
 from rhodecode.lib.helpers import escape
 from rhodecode.lib.utils import make_ui
 from rhodecode.lib.utils2 import safe_unicode
 
 log = logging.getLogger(__name__)
 
 
 def wrap_to_table(str_):
     return '''<table class="code-difftable">
                 <tr class="line no-comment">
                 <td class="lineno new"></td>
                 <td class="code no-comment"><pre>%s</pre></td>
                 </tr>
               </table>''' % str_
 
 
 def wrapped_diff(filenode_old, filenode_new, cut_off_limit=None,
                 ignore_whitespace=True, line_context=3,
                 enable_comments=False):
     """
     returns a wrapped diff into a table, checks for cut_off_limit and presents
     proper message
     """
 
     if filenode_old is None:
         filenode_old = FileNode(filenode_new.path, '', EmptyChangeset())
 
     if filenode_old.is_binary or filenode_new.is_binary:
         diff = wrap_to_table(_('binary file'))
         stats = (0, 0)
         size = 0
 
     elif cut_off_limit != -1 and (cut_off_limit is None or
     (filenode_old.size < cut_off_limit and filenode_new.size < cut_off_limit)):
 
         f_gitdiff = get_gitdiff(filenode_old, filenode_new,
                                 ignore_whitespace=ignore_whitespace,
                                 context=line_context)
         diff_processor = DiffProcessor(f_gitdiff, format='gitdiff')
 
         diff = diff_processor.as_html(enable_comments=enable_comments)
         stats = diff_processor.stat()
         size = len(diff or '')
     else:
         diff = wrap_to_table(_('Changeset was too big and was cut off, use '
                                'diff menu to display this diff'))
         stats = (0, 0)
         size = 0
     if not diff:
         submodules = filter(lambda o: isinstance(o, SubModuleNode),
                             [filenode_new, filenode_old])
         if submodules:
             diff = wrap_to_table(escape('Submodule %r' % submodules[0]))
         else:
             diff = wrap_to_table(_('No changes detected'))
 
     cs1 = filenode_old.changeset.raw_id
     cs2 = filenode_new.changeset.raw_id
 
     return size, cs1, cs2, diff, stats
 
 
 def get_gitdiff(filenode_old, filenode_new, ignore_whitespace=True, context=3):
     """
     Returns git style diff between given ``filenode_old`` and ``filenode_new``.
 
     :param ignore_whitespace: ignore whitespaces in diff
     """
     # make sure we pass in default context
     context = context or 3
     submodules = filter(lambda o: isinstance(o, SubModuleNode),
                         [filenode_new, filenode_old])
     if submodules:
         return ''
 
     for filenode in (filenode_old, filenode_new):
         if not isinstance(filenode, FileNode):
             raise VCSError("Given object should be FileNode object, not %s"
                 % filenode.__class__)
 
     repo = filenode_new.changeset.repository
     old_raw_id = getattr(filenode_old.changeset, 'raw_id', repo.EMPTY_CHANGESET)
     new_raw_id = getattr(filenode_new.changeset, 'raw_id', repo.EMPTY_CHANGESET)
 
     vcs_gitdiff = repo.get_diff(old_raw_id, new_raw_id, filenode_new.path,
                                 ignore_whitespace, context)
     return vcs_gitdiff
 
 NEW_FILENODE = 1
 DEL_FILENODE = 2
 MOD_FILENODE = 3
 RENAMED_FILENODE = 4
 CHMOD_FILENODE = 5
 
 
 class DiffLimitExceeded(Exception):
     pass
 
 
 class LimitedDiffContainer(object):
 
     def __init__(self, diff_limit, cur_diff_size, diff):
         self.diff = diff
         self.diff_limit = diff_limit
         self.cur_diff_size = cur_diff_size
 
     def __iter__(self):
         for l in self.diff:
             yield l
 
 
 class DiffProcessor(object):
     """
     Give it a unified or git diff and it returns a list of the files that were
     mentioned in the diff together with a dict of meta information that
     can be used to render it in a HTML template.
     """
     _chunk_re = re.compile(r'@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)')
     _newline_marker = '\\ No newline at end of file\n'
     _git_header_re = re.compile(r"""
         #^diff[ ]--git
             [ ]a/(?P<a_path>.+?)[ ]b/(?P<b_path>.+?)\n
         (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%\n
            ^rename[ ]from[ ](?P<rename_from>\S+)\n
            ^rename[ ]to[ ](?P<rename_to>\S+)(?:\n|$))?
         (?:^old[ ]mode[ ](?P<old_mode>\d+)\n
            ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?
         (?:^new[ ]file[ ]mode[ ](?P<new_file_mode>.+)(?:\n|$))?
         (?:^deleted[ ]file[ ]mode[ ](?P<deleted_file_mode>.+)(?:\n|$))?
         (?:^index[ ](?P<a_blob_id>[0-9A-Fa-f]+)
             \.\.(?P<b_blob_id>[0-9A-Fa-f]+)[ ]?(?P<b_mode>.+)?(?:\n|$))?
         (?:^---[ ](a/(?P<a_file>.+)|/dev/null)(?:\n|$))?
         (?:^\+\+\+[ ](b/(?P<b_file>.+)|/dev/null)(?:\n|$))?
     """, re.VERBOSE | re.MULTILINE)
     _hg_header_re = re.compile(r"""
         #^diff[ ]--git
             [ ]a/(?P<a_path>.+?)[ ]b/(?P<b_path>.+?)\n
         (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%(?:\n|$))?
         (?:^rename[ ]from[ ](?P<rename_from>\S+)\n
            ^rename[ ]to[ ](?P<rename_to>\S+)(?:\n|$))?
         (?:^old[ ]mode[ ](?P<old_mode>\d+)\n
            ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?
         (?:^new[ ]file[ ]mode[ ](?P<new_file_mode>.+)(?:\n|$))?
         (?:^deleted[ ]file[ ]mode[ ](?P<deleted_file_mode>.+)(?:\n|$))?
         (?:^index[ ](?P<a_blob_id>[0-9A-Fa-f]+)
             \.\.(?P<b_blob_id>[0-9A-Fa-f]+)[ ]?(?P<b_mode>.+)?(?:\n|$))?
         (?:^---[ ](a/(?P<a_file>.+)|/dev/null)(?:\n|$))?
         (?:^\+\+\+[ ](b/(?P<b_file>.+)|/dev/null)(?:\n|$))?
     """, re.VERBOSE | re.MULTILINE)
 
     def __init__(self, diff, vcs='hg', format='gitdiff', diff_limit=None):
         """
         :param diff:   a text in diff format
         :param vcs: type of version controll hg or git
         :param format: format of diff passed, `udiff` or `gitdiff`
         :param diff_limit: define the size of diff that is considered "big"
             based on that parameter cut off will be triggered, set to None
             to show full diff
         """
         if not isinstance(diff, basestring):
             raise Exception('Diff must be a basestring got %s instead' % type(diff))
 
         self._diff = diff
         self._format = format
         self.adds = 0
         self.removes = 0
         # calculate diff size
         self.diff_size = len(diff)
         self.diff_limit = diff_limit
         self.cur_diff_size = 0
         self.parsed = False
         self.parsed_diff = []
         self.vcs = vcs
 
         if format == 'gitdiff':
             self.differ = self._highlight_line_difflib
             self._parser = self._parse_gitdiff
         else:
             self.differ = self._highlight_line_udiff
             self._parser = self._parse_udiff
 
     def _copy_iterator(self):
         """
         make a fresh copy of generator, we should not iterate thru
         an original as it's needed for repeating operations on
         this instance of DiffProcessor
         """
         self.__udiff, iterator_copy = tee(self.__udiff)
         return iterator_copy
 
     def _escaper(self, string):
         """
         Escaper for diff escapes special chars and checks the diff limit
 
         :param string:
         :type string:
         """
 
         self.cur_diff_size += len(string)
 
         # escaper get's iterated on each .next() call and it checks if each
         # parsed line doesn't exceed the diff limit
         if self.diff_limit is not None and self.cur_diff_size > self.diff_limit:
             raise DiffLimitExceeded('Diff Limit Exceeded')
 
         return safe_unicode(string).replace('&', '&amp;')\
                 .replace('<', '&lt;')\
                 .replace('>', '&gt;')
 
     def _line_counter(self, l):
         """
         Checks each line and bumps total adds/removes for this diff
 
         :param l:
         """
         if l.startswith('+') and not l.startswith('+++'):
             self.adds += 1
         elif l.startswith('-') and not l.startswith('---'):
             self.removes += 1
         return safe_unicode(l)
 
     def _highlight_line_difflib(self, line, next_):
         """
         Highlight inline changes in both lines.
         """
 
         if line['action'] == 'del':
             old, new = line, next_
         else:
             old, new = next_, line
 
         oldwords = re.split(r'(\W)', old['line'])
         newwords = re.split(r'(\W)', new['line'])
 
         sequence = difflib.SequenceMatcher(None, oldwords, newwords)
 
         oldfragments, newfragments = [], []
         for tag, i1, i2, j1, j2 in sequence.get_opcodes():
             oldfrag = ''.join(oldwords[i1:i2])
             newfrag = ''.join(newwords[j1:j2])
             if tag != 'equal':
                 if oldfrag:
                     oldfrag = '<del>%s</del>' % oldfrag
                 if newfrag:
                     newfrag = '<ins>%s</ins>' % newfrag
             oldfragments.append(oldfrag)
             newfragments.append(newfrag)
 
         old['line'] = "".join(oldfragments)
         new['line'] = "".join(newfragments)
 
     def _highlight_line_udiff(self, line, next_):
         """
         Highlight inline changes in both lines.
         """
         start = 0
         limit = min(len(line['line']), len(next_['line']))
         while start < limit and line['line'][start] == next_['line'][start]:
             start += 1
         end = -1
         limit -= start
         while -end <= limit and line['line'][end] == next_['line'][end]:
             end -= 1
         end += 1
         if start or end:
             def do(l):
                 last = end + len(l['line'])
                 if l['action'] == 'add':
                     tag = 'ins'
                 else:
                     tag = 'del'
                 l['line'] = '%s<%s>%s</%s>%s' % (
                     l['line'][:start],
                     tag,
                     l['line'][start:last],
                     tag,
                     l['line'][last:]
                 )
             do(line)
             do(next_)
 
     def _get_header(self, diff_chunk):
         """
         parses the diff header, and returns parts, and leftover diff
         parts consists of 14 elements::
 
             a_path, b_path, similarity_index, rename_from, rename_to,
             old_mode, new_mode, new_file_mode, deleted_file_mode,
             a_blob_id, b_blob_id, b_mode, a_file, b_file
 
         :param diff_chunk:
         :type diff_chunk:
         """
 
         if self.vcs == 'git':
             match = self._git_header_re.match(diff_chunk)
             diff = diff_chunk[match.end():]
             return match.groupdict(), imap(self._escaper, diff.splitlines(1))
         elif self.vcs == 'hg':
             match = self._hg_header_re.match(diff_chunk)
             diff = diff_chunk[match.end():]
             return match.groupdict(), imap(self._escaper, diff.splitlines(1))
         else:
             raise Exception('VCS type %s is not supported' % self.vcs)
 
     def _parse_gitdiff(self, inline_diff=True):
         _files = []
         diff_container = lambda arg: arg
 
         ##split the diff in chunks of separate --git a/file b/file chunks
         for raw_diff in ('\n' + self._diff).split('\ndiff --git')[1:]:
             binary = False
             binary_msg = 'unknown binary'
             head, diff = self._get_header(raw_diff)
 
             if not head['a_file'] and head['b_file']:
                 op = 'A'
             elif head['a_file'] and head['b_file']:
                 op = 'M'
             elif head['a_file'] and not head['b_file']:
                 op = 'D'
             else:
                 #probably we're dealing with a binary file 1
                 binary = True
                 if head['deleted_file_mode']:
                     op = 'D'
                     stats = ['b', DEL_FILENODE]
                     binary_msg = 'deleted binary file'
                 elif head['new_file_mode']:
                     op = 'A'
                     stats = ['b', NEW_FILENODE]
                     binary_msg = 'new binary file %s' % head['new_file_mode']
                 else:
                     if head['new_mode'] and head['old_mode']:
                         stats = ['b', CHMOD_FILENODE]
                         op = 'M'
                         binary_msg = ('modified binary file chmod %s => %s'
                                       % (head['old_mode'], head['new_mode']))
                     elif (head['rename_from'] and head['rename_to']
                           and head['rename_from'] != head['rename_to']):
                         stats = ['b', RENAMED_FILENODE]
                         op = 'M'
                         binary_msg = ('file renamed from %s to %s'
                                       % (head['rename_from'], head['rename_to']))
                     else:
                         stats = ['b', MOD_FILENODE]
                         op = 'M'
                         binary_msg = 'modified binary file'
 
             if not binary:
                 try:
                     chunks, stats = self._parse_lines(diff)
                 except DiffLimitExceeded:
                     diff_container = lambda _diff: LimitedDiffContainer(
                                                 self.diff_limit,
                                                 self.cur_diff_size,
                                                 _diff)
                     break
             else:
                 chunks = []
                 chunks.append([{
                     'old_lineno': '',
                     'new_lineno': '',
                     'action':     'binary',
                     'line':       binary_msg,
                 }])
 
             _files.append({
                 'filename':         head['b_path'],
                 'old_revision':     head['a_blob_id'],
                 'new_revision':     head['b_blob_id'],
                 'chunks':           chunks,
                 'operation':        op,
                 'stats':            stats,
             })
 
         sorter = lambda info: {'A': 0, 'M': 1, 'D': 2}.get(info['operation'])
 
         if inline_diff is False:
             return diff_container(sorted(_files, key=sorter))
 
         # highlight inline changes
         for diff_data in _files:
             for chunk in diff_data['chunks']:
                 lineiter = iter(chunk)
                 try:
                     while 1:
                         line = lineiter.next()
                         if line['action'] not in ['unmod', 'context']:
                             nextline = lineiter.next()
                             if nextline['action'] in ['unmod', 'context'] or \
                                nextline['action'] == line['action']:
                                 continue
                             self.differ(line, nextline)
                 except StopIteration:
                     pass
 
         return diff_container(sorted(_files, key=sorter))
 
     def _parse_udiff(self, inline_diff=True):
         raise NotImplementedError()
 
     def _parse_lines(self, diff):
         """
         Parse the diff an return data for the template.
         """
 
         lineiter = iter(diff)
         stats = [0, 0]
 
         try:
             chunks = []
             line = lineiter.next()
 
             while line:
                 lines = []
                 chunks.append(lines)
 
                 match = self._chunk_re.match(line)
 
                 if not match:
                     break
 
                 gr = match.groups()
                 (old_line, old_end,
                  new_line, new_end) = [int(x or 1) for x in gr[:-1]]
                 old_line -= 1
                 new_line -= 1
 
                 context = len(gr) == 5
                 old_end += old_line
                 new_end += new_line
 
                 if context:
                     # skip context only if it's first line
                     if int(gr[0]) > 1:
                         lines.append({
                             'old_lineno': '...',
                             'new_lineno': '...',
                             'action':     'context',
                             'line':       line,
                         })
 
                 line = lineiter.next()
 
                 while old_line < old_end or new_line < new_end:
                     if line:
                         command = line[0]
                         if command in ['+', '-', ' ']:
                             #only modify the line if it's actually a diff
                             # thing
                             line = line[1:]
                     else:
                         command = ' '
 
                     affects_old = affects_new = False
 
                     # ignore those if we don't expect them
                     if command in '#@':
                         continue
                     elif command == '+':
                         affects_new = True
                         action = 'add'
                         stats[0] += 1
                     elif command == '-':
                         affects_old = True
                         action = 'del'
                         stats[1] += 1
                     else:
                         affects_old = affects_new = True
                         action = 'unmod'
 
                     if line != self._newline_marker:
                         old_line += affects_old
                         new_line += affects_new
                         lines.append({
                             'old_lineno':   affects_old and old_line or '',
                             'new_lineno':   affects_new and new_line or '',
                             'action':       action,
                             'line':         line
                         })
 
                     line = lineiter.next()
 
                     if line == self._newline_marker:
                         # we need to append to lines, since this is not
                         # counted in the line specs of diff
                         lines.append({
                             'old_lineno':   '...',
                             'new_lineno':   '...',
                             'action':       'context',
                             'line':         line
                         })
 
         except StopIteration:
             pass
         return chunks, stats
 
     def _safe_id(self, idstring):
         """Make a string safe for including in an id attribute.
 
         The HTML spec says that id attributes 'must begin with
         a letter ([A-Za-z]) and may be followed by any number
         of letters, digits ([0-9]), hyphens ("-"), underscores
         ("_"), colons (":"), and periods (".")'. These regexps
         are slightly over-zealous, in that they remove colons
         and periods unnecessarily.
 
         Whitespace is transformed into underscores, and then
         anything which is not a hyphen or a character that
         matches \w (alphanumerics and underscore) is removed.
 
         """
         # Transform all whitespace to underscore
         idstring = re.sub(r'\s', "_", '%s' % idstring)
         # Remove everything that is not a hyphen or a member of \w
         idstring = re.sub(r'(?!-)\W', "", idstring).lower()
         return idstring
 
     def prepare(self, inline_diff=True):
         """
         Prepare the passed udiff for HTML rendering. It'l return a list
         of dicts with diff information
         """
         parsed = self._parser(inline_diff=inline_diff)
         self.parsed = True
         self.parsed_diff = parsed
         return parsed
 
     def as_raw(self, diff_lines=None):
         """
         Returns raw string diff
         """
         return self._diff
         #return u''.join(imap(self._line_counter, self._diff.splitlines(1)))
 
     def as_html(self, table_class='code-difftable', line_class='line',
                 new_lineno_class='lineno old', old_lineno_class='lineno new',
                 code_class='code', enable_comments=False, parsed_lines=None):
         """
         Return given diff as html table with customized css classes
         """
         def _link_to_if(condition, label, url):
             """
             Generates a link if condition is meet or just the label if not.
             """
 
             if condition:
                 return '''<a href="%(url)s">%(label)s</a>''' % {
                     'url': url,
                     'label': label
                 }
             else:
                 return label
         if not self.parsed:
             self.prepare()
 
         diff_lines = self.parsed_diff
         if parsed_lines:
             diff_lines = parsed_lines
 
         _html_empty = True
         _html = []
         _html.append('''<table class="%(table_class)s">\n''' % {
             'table_class': table_class
         })
 
         for diff in diff_lines:
             for line in diff['chunks']:
                 _html_empty = False
                 for change in line:
                     _html.append('''<tr class="%(lc)s %(action)s">\n''' % {
                         'lc': line_class,
                         'action': change['action']
                     })
                     anchor_old_id = ''
                     anchor_new_id = ''
                     anchor_old = "%(filename)s_o%(oldline_no)s" % {
                         'filename': self._safe_id(diff['filename']),
                         'oldline_no': change['old_lineno']
                     }
                     anchor_new = "%(filename)s_n%(oldline_no)s" % {
                         'filename': self._safe_id(diff['filename']),
                         'oldline_no': change['new_lineno']
                     }
                     cond_old = (change['old_lineno'] != '...' and
                                 change['old_lineno'])
                     cond_new = (change['new_lineno'] != '...' and
                                 change['new_lineno'])
                     if cond_old:
                         anchor_old_id = 'id="%s"' % anchor_old
                     if cond_new:
                         anchor_new_id = 'id="%s"' % anchor_new
                     ###########################################################
                     # OLD LINE NUMBER
                     ###########################################################
                     _html.append('''\t<td %(a_id)s class="%(olc)s">''' % {
                         'a_id': anchor_old_id,
                         'olc': old_lineno_class
                     })
 
                     _html.append('''%(link)s''' % {
                         'link': _link_to_if(True, change['old_lineno'],
                                             '#%s' % anchor_old)
                     })
                     _html.append('''</td>\n''')
                     ###########################################################
                     # NEW LINE NUMBER
                     ###########################################################
 
                     _html.append('''\t<td %(a_id)s class="%(nlc)s">''' % {
                         'a_id': anchor_new_id,
                         'nlc': new_lineno_class
                     })
 
                     _html.append('''%(link)s''' % {
                         'link': _link_to_if(True, change['new_lineno'],
                                             '#%s' % anchor_new)
                     })
                     _html.append('''</td>\n''')
                     ###########################################################
                     # CODE
                     ###########################################################
                     comments = '' if enable_comments else 'no-comment'
                     _html.append('''\t<td class="%(cc)s %(inc)s">''' % {
                         'cc': code_class,
                         'inc': comments
                     })
                     _html.append('''\n\t\t<pre>%(code)s</pre>\n''' % {
                         'code': change['line']
                     })
 
                     _html.append('''\t</td>''')
                     _html.append('''\n</tr>\n''')
         _html.append('''</table>''')
         if _html_empty:
             return None
         return ''.join(_html)
 
     def stat(self):
         """
         Returns tuple of added, and removed lines for this instance
         """
         return self.adds, self.removes
 
 
 class InMemoryBundleRepo(bundlerepository):
     def __init__(self, ui, path, bundlestream):
         self._tempparent = None
         localrepo.localrepository.__init__(self, ui, path)
         self.ui.setconfig('phases', 'publish', False)
 
         self.bundle = bundlestream
 
         # dict with the mapping 'filename' -> position in the bundle
         self.bundlefilespos = {}
 
 
 def differ(org_repo, org_ref, other_repo, other_ref, discovery_data=None,
-           bundle_compare=False, context=3, ignore_whitespace=False):
+           remote_compare=False, context=3, ignore_whitespace=False):
     """
-    General differ between branches, bookmarks, revisions of two remote related
-    repositories
+    General differ between branches, bookmarks, revisions of two remote or
+    local but related repositories
 
     :param org_repo:
-    :type org_repo:
     :param org_ref:
-    :type org_ref:
     :param other_repo:
     :type other_repo:
-    :param other_ref:
     :type other_ref:
     """
 
-    bundlerepo = None
-    ignore_whitespace = ignore_whitespace
-    context = context
     org_repo_scm = org_repo.scm_instance
+    other_repo_scm = other_repo.scm_instance
+
     org_repo = org_repo_scm._repo
-    other_repo = other_repo.scm_instance._repo
-    opts = diffopts(git=True, ignorews=ignore_whitespace, context=context)
+    other_repo = other_repo_scm._repo
+
     org_ref = org_ref[1]
     other_ref = other_ref[1]
 
     if org_repo == other_repo:
         log.debug('running diff between %s@%s and %s@%s'
                   % (org_repo, org_ref, other_repo, other_ref))
-        _diff = org_repo_scm.get_diff(rev1=other_ref, rev2=org_ref,
+        _diff = org_repo_scm.get_diff(rev1=org_ref, rev2=other_ref,
             ignore_whitespace=ignore_whitespace, context=context)
         return _diff
 
-    elif bundle_compare:
-
+    elif remote_compare:
+        opts = diffopts(git=True, ignorews=ignore_whitespace, context=context)
         common, incoming, rheads = discovery_data
-        other_repo_peer = localrepo.locallegacypeer(other_repo.local())
+        org_repo_peer = localrepo.locallegacypeer(org_repo.local())
         # create a bundle (uncompressed if other repo is not local)
-        if other_repo_peer.capable('getbundle') and incoming:
+        if org_repo_peer.capable('getbundle'):
             # disable repo hooks here since it's just bundle !
             # patch and reset hooks section of UI config to not run any
             # hooks on fetching archives with subrepos
-            for k, _ in other_repo.ui.configitems('hooks'):
-                other_repo.ui.setconfig('hooks', k, None)
+            for k, _ in org_repo.ui.configitems('hooks'):
+                org_repo.ui.setconfig('hooks', k, None)
 
-            unbundle = other_repo.getbundle('incoming', common=common,
-                                            heads=None)
+            unbundle = org_repo.getbundle('incoming', common=common,
+                                          heads=None)
 
             buf = BytesIO()
             while True:
                 chunk = unbundle._stream.read(1024 * 4)
                 if not chunk:
                     break
                 buf.write(chunk)
 
             buf.seek(0)
             # replace chunked _stream with data that can do tell() and seek()
             unbundle._stream = buf
 
             ui = make_ui('db')
             bundlerepo = InMemoryBundleRepo(ui, path=org_repo.root,
                                             bundlestream=unbundle)
 
-        return ''.join(patch.diff(bundlerepo or org_repo,
-                                  node1=org_repo[org_ref].node(),
-                                  node2=other_repo[other_ref].node(),
-                                  opts=opts))
+            return ''.join(patch.diff(bundlerepo,
+                                      node1=other_repo[other_ref].node(),
+                                      node2=org_repo[org_ref].node(),
+                                      opts=opts))
 
+    return ''
  No newline at end of file

rhodecode/model/pull_request.py

@@ -1,277 +1,277
 # -*- coding: utf-8 -*-
 """
     rhodecode.model.pull_request
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     pull request model for RhodeCode
 
     :created_on: Jun 6, 2012
     :author: marcink
     :copyright: (C) 2012-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 binascii
 import datetime
 import re
 
 from pylons.i18n.translation import _
 
 from rhodecode.model.meta import Session
 from rhodecode.lib import helpers as h
 from rhodecode.model import BaseModel
 from rhodecode.model.db import PullRequest, PullRequestReviewers, Notification
 from rhodecode.model.notification import NotificationModel
 from rhodecode.lib.utils2 import safe_unicode
 
 from rhodecode.lib.vcs.utils.hgcompat import discovery, localrepo, scmutil, \
     findcommonoutgoing
 
 log = logging.getLogger(__name__)
 
 
 class PullRequestModel(BaseModel):
 
     cls = PullRequest
 
     def __get_pull_request(self, pull_request):
         return self._get_instance(PullRequest, pull_request)
 
     def get_all(self, repo):
         repo = self._get_repo(repo)
         return PullRequest.query().filter(PullRequest.other_repo == repo).all()
 
     def create(self, created_by, org_repo, org_ref, other_repo,
                other_ref, revisions, reviewers, title, description=None):
 
         created_by_user = self._get_user(created_by)
         org_repo = self._get_repo(org_repo)
         other_repo = self._get_repo(other_repo)
 
         new = PullRequest()
         new.org_repo = org_repo
         new.org_ref = org_ref
         new.other_repo = other_repo
         new.other_ref = other_ref
         new.revisions = revisions
         new.title = title
         new.description = description
         new.author = created_by_user
         self.sa.add(new)
         Session().flush()
         #members
         for member in reviewers:
             _usr = self._get_user(member)
             reviewer = PullRequestReviewers(_usr, new)
             self.sa.add(reviewer)
 
         #notification to reviewers
         notif = NotificationModel()
 
         pr_url = h.url('pullrequest_show', repo_name=other_repo.repo_name,
                        pull_request_id=new.pull_request_id,
                        qualified=True,
         )
         subject = safe_unicode(
             h.link_to(
               _('%(user)s wants you to review pull request #%(pr_id)s') % \
                 {'user': created_by_user.username,
                  'pr_id': new.pull_request_id},
                 pr_url
             )
         )
         body = description
         kwargs = {
             'pr_title': title,
             'pr_user_created': h.person(created_by_user.email),
             'pr_repo_url': h.url('summary_home', repo_name=other_repo.repo_name,
                                  qualified=True,),
             'pr_url': pr_url,
             'pr_revisions': revisions
         }
         notif.create(created_by=created_by_user, subject=subject, body=body,
                      recipients=reviewers,
                      type_=Notification.TYPE_PULL_REQUEST, email_kwargs=kwargs)
         return new
 
     def update_reviewers(self, pull_request, reviewers_ids):
         reviewers_ids = set(reviewers_ids)
         pull_request = self.__get_pull_request(pull_request)
         current_reviewers = PullRequestReviewers.query()\
                             .filter(PullRequestReviewers.pull_request==
                                    pull_request)\
                             .all()
         current_reviewers_ids = set([x.user.user_id for x in current_reviewers])
 
         to_add = reviewers_ids.difference(current_reviewers_ids)
         to_remove = current_reviewers_ids.difference(reviewers_ids)
 
         log.debug("Adding %s reviewers" % to_add)
         log.debug("Removing %s reviewers" % to_remove)
 
         for uid in to_add:
             _usr = self._get_user(uid)
             reviewer = PullRequestReviewers(_usr, pull_request)
             self.sa.add(reviewer)
 
         for uid in to_remove:
             reviewer = PullRequestReviewers.query()\
                     .filter(PullRequestReviewers.user_id==uid,
                             PullRequestReviewers.pull_request==pull_request)\
                     .scalar()
             if reviewer:
                 self.sa.delete(reviewer)
 
     def delete(self, pull_request):
         pull_request = self.__get_pull_request(pull_request)
         Session().delete(pull_request)
 
     def close_pull_request(self, pull_request):
         pull_request = self.__get_pull_request(pull_request)
         pull_request.status = PullRequest.STATUS_CLOSED
         pull_request.updated_on = datetime.datetime.now()
         self.sa.add(pull_request)
 
     def _get_changesets(self, alias, org_repo, org_ref, other_repo, other_ref,
                         discovery_data):
         """
         Returns a list of changesets that are incoming from org_repo@org_ref
         to other_repo@other_ref
 
         :param org_repo:
         :type org_repo:
         :param org_ref:
         :type org_ref:
         :param other_repo:
         :type other_repo:
         :param other_ref:
         :type other_ref:
         :param tmp:
         :type tmp:
         """
         changesets = []
         #case two independent repos
         common, incoming, rheads = discovery_data
         if org_repo != other_repo and incoming:
             obj = findcommonoutgoing(org_repo._repo,
                         localrepo.locallegacypeer(other_repo._repo.local()),
                         force=True)
             revs = obj.missing
 
             for cs in reversed(map(binascii.hexlify, revs)):
                 changesets.append(org_repo.get_changeset(cs))
         else:
             #no remote compare do it on the same repository
             if alias == 'hg':
                 _revset_predicates = {
                         'branch': 'branch',
                         'book': 'bookmark',
                         'tag': 'tag',
                         'rev': 'id',
                     }
 
                 revs = [
                     "ancestors(%s('%s')) and not ancestors(%s('%s'))" % (
+                        _revset_predicates[other_ref[0]], other_ref[1],
                         _revset_predicates[org_ref[0]], org_ref[1],
-                        _revset_predicates[other_ref[0]], other_ref[1]
                    )
                 ]
 
                 out = scmutil.revrange(org_repo._repo, revs)
-                for cs in reversed(out):
+                for cs in (out):
                     changesets.append(org_repo.get_changeset(cs))
             elif alias == 'git':
                 so, se = org_repo.run_git_command(
-                    'log --pretty="format: %%H" -s -p %s..%s' % (org_ref[1],
+                    'log --reverse --pretty="format: %%H" -s -p %s..%s' % (org_ref[1],
                                                                      other_ref[1])
                 )
                 ids = re.findall(r'[0-9a-fA-F]{40}', so)
-                for cs in reversed(ids):
+                for cs in (ids):
                     changesets.append(org_repo.get_changeset(cs))
 
         return changesets
 
     def _get_discovery(self, org_repo, org_ref, other_repo, other_ref):
         """
         Get's mercurial discovery data used to calculate difference between
         repos and refs
 
         :param org_repo:
         :type org_repo:
         :param org_ref:
         :type org_ref:
         :param other_repo:
         :type other_repo:
         :param other_ref:
         :type other_ref:
         """
 
         _org_repo = org_repo._repo
         org_rev_type, org_rev = org_ref
 
         _other_repo = other_repo._repo
         other_rev_type, other_rev = other_ref
 
         log.debug('Doing discovery for %s@%s vs %s@%s' % (
                         org_repo, org_ref, other_repo, other_ref)
         )
 
         #log.debug('Filter heads are %s[%s]' % ('', org_ref[1]))
         org_peer = localrepo.locallegacypeer(_org_repo.local())
         tmp = discovery.findcommonincoming(
                   repo=_other_repo,  # other_repo we check for incoming
                   remote=org_peer,  # org_repo source for incoming
                   heads=[_other_repo[other_rev].node(),
                          _org_repo[org_rev].node()],
                   force=True
         )
         return tmp
 
     def get_compare_data(self, org_repo, org_ref, other_repo, other_ref):
         """
         Returns a tuple of incomming changesets, and discoverydata cache for
         mercurial repositories
 
         :param org_repo:
         :type org_repo:
         :param org_ref:
         :type org_ref:
         :param other_repo:
         :type other_repo:
         :param other_ref:
         :type other_ref:
         """
 
         if len(org_ref) != 2 or not isinstance(org_ref, (list, tuple)):
             raise Exception('org_ref must be a two element list/tuple')
 
         if len(other_ref) != 2 or not isinstance(org_ref, (list, tuple)):
             raise Exception('other_ref must be a two element list/tuple')
 
         org_repo_scm = org_repo.scm_instance
         other_repo_scm = other_repo.scm_instance
 
         alias = org_repo.scm_instance.alias
         discovery_data = [None, None, None]
         if alias == 'hg':
             discovery_data = self._get_discovery(org_repo_scm, org_ref,
                                                other_repo_scm, other_ref)
         cs_ranges = self._get_changesets(alias,
                                          org_repo_scm, org_ref,
                                          other_repo_scm, other_ref,
                                          discovery_data)
 
         return cs_ranges, discovery_data

rhodecode/templates/changeset/changeset_range.html

@@ -1,122 +1,122
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('%s Changesets') % c.repo_name} - r${c.cs_ranges[0].revision}:${h.short_id(c.cs_ranges[0].raw_id)} -> r${c.cs_ranges[-1].revision}:${h.short_id(c.cs_ranges[-1].raw_id)} - ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_(u'Home'),h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_name,h.url('summary_home',repo_name=c.repo_name))}
     &raquo;
     ${_('Changesets')} - r${c.cs_ranges[0].revision}:${h.short_id(c.cs_ranges[0].raw_id)} -> r${c.cs_ranges[-1].revision}:${h.short_id(c.cs_ranges[-1].raw_id)}
 </%def>
 
 <%def name="page_nav()">
     ${self.menu('changelog')}
 </%def>
 
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <div class="table">
 		<div id="body" class="diffblock">
 			<div class="code-header cv">
-		        <h3 class="code-header-title">${_('Compare View')}</h3>
+		        <h3 class="code-header-title">${_('Compare View')} / ${h.link_to(_('Show combined compare'),h.url('compare_url',repo_name=c.repo_name,org_ref_type='rev',org_ref=getattr(c.cs_ranges[0].parents[0] if c.cs_ranges[0].parents else h.EmptyChangeset(),'raw_id'),other_ref_type='rev',other_ref=c.cs_ranges[-1].raw_id))}</h3>
                 <div>
 				${_('Changesets')} - r${c.cs_ranges[0].revision}:${h.short_id(c.cs_ranges[0].raw_id)} -> r${c.cs_ranges[-1].revision}:${h.short_id(c.cs_ranges[-1].raw_id)}
 				</div>
 			</div>
 		</div>
 	    <div id="changeset_compare_view_content">
 			<div class="container">
 			<table class="compare_view_commits noborder">
             %for cnt,cs in enumerate(c.cs_ranges):
                 <tr>
                 <td><div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(h.email_or_none(cs.author),14)}"/></div></td>
                 <td>${h.link_to('r%s:%s' % (cs.revision,h.short_id(cs.raw_id)),h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}</td>
                 <td><div class="author">${h.person(cs.author)}</div></td>
                 <td><span class="tooltip" title="${h.age(cs.date)}">${cs.date}</span></td>
                 <td>
                   %if c.statuses:
                     <div title="${h.tooltip(_('Changeset status'))}" class="changeset-status-ico"><img src="${h.url('/images/icons/flag_status_%s.png' % c.statuses[cnt])}" /></div>
                   %endif
                 </td>
                 <td><div class="message">${h.urlify_commit(h.wrap_paragraphs(cs.message),c.repo_name)}</div></td>
                 </tr>
             %endfor
             </table>
 	        </div>
 	        <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">${_('Files affected')}</div>
 	        <div class="cs_files">
 	               %for cs in c.cs_ranges:
 	                   <div class="cur_cs">${h.link_to('r%s:%s' % (cs.revision,h.short_id(cs.raw_id)),h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}</div>
 	                  %for FID, (cs1, cs2, change, path, diff, stats) in c.changes[cs.raw_id].iteritems():
 	                    <div class="cs_${change}">${h.link_to(h.safe_unicode(path),h.url.current(anchor=FID))}</div>
 	                  %endfor
 	               %endfor
 	        </div>
 	    </div>
 
     </div>
     <%namespace name="comment" file="/changeset/changeset_file_comment.html"/>
     <%namespace name="diff_block" file="/changeset/diff_block.html"/>
      %for cs in c.cs_ranges:
           ##${comment.comment_inline_form(cs)}
           ## diff block
           <div class="h3">
           <a class="tooltip" title="${h.tooltip(cs.message)}" href="${h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id)}">${'r%s:%s' % (cs.revision,h.short_id(cs.raw_id))}</a>
              <div class="gravatar">
                  <img alt="gravatar" src="${h.gravatar_url(h.email_or_none(cs.author),20)}"/>
              </div>
              <div class="right">
               <span class="logtags">
                 %if len(cs.parents)>1:
                 <span class="merge">${_('merge')}</span>
                 %endif
                 %if cs.branch:
                 <span class="branchtag" title="${'%s %s' % (_('branch'),cs.branch)}">
                    ${h.link_to(h.shorter(cs.branch),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}
                 </span>
                 %endif
                 %if h.is_hg(c.rhodecode_repo):
                   %for book in cs.bookmarks:
                   <span class="bookbook" title="${'%s %s' % (_('bookmark'),book)}">
                      ${h.link_to(h.shorter(book),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}
                   </span>
                   %endfor
                 %endif
                 %for tag in cs.tags:
                     <span class="tagtag"  title="${'%s %s' % (_('tag'),tag)}">
                     ${h.link_to(h.shorter(tag),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}</span>
                 %endfor
               </span>
             </div>
            </div>
           ${diff_block.diff_block(c.changes[cs.raw_id])}
           ##${comment.comments(cs)}
 
      %endfor
      <script type="text/javascript">
 
       YUE.onDOMReady(function(){
 
           YUE.on(YUQ('.diff-menu-activate'),'click',function(e){
               var act = e.currentTarget.nextElementSibling;
 
               if(YUD.hasClass(act,'active')){
                   YUD.removeClass(act,'active');
                   YUD.setStyle(act,'display','none');
               }else{
                   YUD.addClass(act,'active');
                   YUD.setStyle(act,'display','');
               }
           });
       })
     </script>
     </div>
 </%def>

rhodecode/templates/compare/compare_cs.html

@@ -1,28 +1,28
 ## Changesets table !
 <div class="container">
   <table class="compare_view_commits noborder">
   %if not c.cs_ranges:
-    <tr><td>${_('No changesets')}</td></tr>
+    <span class="empty_data">${_('No changesets')}</span>
   %else:
     %for cnt, cs in enumerate(c.cs_ranges):
         <tr>
         <td><div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(h.email_or_none(cs.author),14)}"/></div></td>
         <td>
           %if cs.raw_id in c.statuses:
             <div title="${c.statuses[cs.raw_id][1]}" class="changeset-status-ico"><img src="${h.url('/images/icons/flag_status_%s.png' % c.statuses[cs.raw_id][0])}" /></div>
           %endif
         </td>
         <td>${h.link_to('r%s:%s' % (cs.revision,h.short_id(cs.raw_id)),h.url('changeset_home',repo_name=c.target_repo,revision=cs.raw_id))}
         %if c.as_form:
           ${h.hidden('revisions',cs.raw_id)}
         %endif
         </td>
         <td><div class="author">${h.person(cs.author)}</div></td>
         <td><span class="tooltip" title="${h.tooltip(h.age(cs.date))}">${cs.date}</span></td>
         <td><div class="message tooltip" title="${h.tooltip(cs.message)}" style="white-space:normal">${h.urlify_commit(h.shorter(cs.message, 60),c.repo_name)}</div></td>
         </tr>
     %endfor
 
   %endif
   </table>
 </div>

rhodecode/templates/compare/compare_diff.html

@@ -1,82 +1,93
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${c.repo_name} ${_('Compare')} ${'%s@%s' % (c.org_repo.repo_name, c.org_ref)} -> ${'%s@%s' % (c.other_repo.repo_name, c.other_ref)}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_(u'Home'),h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_name,h.url('summary_home',repo_name=c.repo_name))}
     &raquo;
     ${_('Compare')}
 </%def>
 
 <%def name="page_nav()">
     ${self.menu('changelog')}
 </%def>
 
 <%def name="main()">
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <div class="table">
         <div id="body" class="diffblock">
             <div class="code-header cv">
                 <h3 class="code-header-title">${_('Compare View')}</h3>
                 <div>
                 ${'%s@%s' % (c.org_repo.repo_name, c.org_ref)} -> ${'%s@%s' % (c.other_repo.repo_name, c.other_ref)}  <a href="${c.swap_url}">[swap]</a>
                 </div>
             </div>
         </div>
         <div id="changeset_compare_view_content">
             ##CS
-            <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">${_('Outgoing changesets')}</div>
+            <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">${ungettext('Showing %s commit','Showing %s commits', len(c.cs_ranges)) % len(c.cs_ranges)}</div>
             <%include file="compare_cs.html" />
 
             ## FILES
-            <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">${_('Files affected')}</div>
+            <div style="font-size:1.1em;font-weight: bold;clear:both;padding-top:10px">
+            
+            % if c.limited_diff:
+                ${ungettext('%s file changed', '%s files changed', len(c.files)) % len(c.files)}
+            % else:
+                ${ungettext('%s file changed with %s insertions and %s deletions','%s files changed with %s insertions and %s deletions', len(c.files)) % (len(c.files),c.lines_added,c.lines_deleted)}:
+            %endif
+            
+            </div>
             <div class="cs_files">
+              %if not c.files:
+                 <span class="empty_data">${_('No files')}</span>
+              %endif
               %for fid, change, f, stat in c.files:
                   <div class="cs_${change}">
                     <div class="node">${h.link_to(h.safe_unicode(f),h.url.current(anchor=fid))}</div>
                     <div class="changes">${h.fancy_file_stats(stat)}</div>
                   </div>
               %endfor
             </div>
             % if c.limited_diff:
               <h5>${_('Changeset was too big and was cut off...')}</h5>
             % endif            
         </div>
     </div>
 
     ## diff block
     <%namespace name="diff_block" file="/changeset/diff_block.html"/>
     %for fid, change, f, stat in c.files:
       ${diff_block.diff_block_simple([c.changes[fid]])}
     %endfor
     % if c.limited_diff:
       <h4>${_('Changeset was too big and was cut off...')}</h4>
     % endif
      <script type="text/javascript">
 
       YUE.onDOMReady(function(){
 
           YUE.on(YUQ('.diff-menu-activate'),'click',function(e){
               var act = e.currentTarget.nextElementSibling;
 
               if(YUD.hasClass(act,'active')){
                   YUD.removeClass(act,'active');
                   YUD.setStyle(act,'display','none');
               }else{
                   YUD.addClass(act,'active');
                   YUD.setStyle(act,'display','');
               }
           });
       })
     </script>
     </div>
 </%def>

rhodecode/tests/functional/test_compare.py

@@ -1,403 +1,563
 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
 
 
 class TestCompareController(TestController):
 
-    def test_index_tag(self):
+    def test_compare_tag_hg(self):
         self.log_user()
-        tag1 = '0.1.3'
-        tag2 = '0.1.2'
+        tag1 = '0.1.2'
+        tag2 = '0.1.3'
         response = self.app.get(url(controller='compare', action='index',
                                     repo_name=HG_REPO,
                                     org_ref_type="tag",
                                     org_ref=tag1,
                                     other_ref_type="tag",
                                     other_ref=tag2,
                                     ))
         response.mustcontain('%s@%s -> %s@%s' % (HG_REPO, tag1, HG_REPO, tag2))
         ## outgoing changesets between tags
-        response.mustcontain('''<a href="/%s/changeset/17544fbfcd33ffb439e2b728b5d526b1ef30bfcf">r120:17544fbfcd33</a>''' % HG_REPO)
-        response.mustcontain('''<a href="/%s/changeset/36e0fc9d2808c5022a24f49d6658330383ed8666">r119:36e0fc9d2808</a>''' % HG_REPO)
-        response.mustcontain('''<a href="/%s/changeset/bb1a3ab98cc45cb934a77dcabf87a5a598b59e97">r118:bb1a3ab98cc4</a>''' % HG_REPO)
+        response.mustcontain('''<a href="/%s/changeset/c5ddebc06eaaba3010c2d66ea6ec9d074eb0f678">r112:c5ddebc06eaa</a>''' % HG_REPO)
+        response.mustcontain('''<a href="/%s/changeset/70d4cef8a37657ee4cf5aabb3bd9f68879769816">r115:70d4cef8a376</a>''' % HG_REPO)
+        response.mustcontain('''<a href="/%s/changeset/9749bfbfc0d2eba208d7947de266303b67c87cda">r116:9749bfbfc0d2</a>''' % HG_REPO)
         response.mustcontain('''<a href="/%s/changeset/41fda979f02fda216374bf8edac4e83f69e7581c">r117:41fda979f02f</a>''' % HG_REPO)
-        response.mustcontain('''<a href="/%s/changeset/9749bfbfc0d2eba208d7947de266303b67c87cda">r116:9749bfbfc0d2</a>''' % HG_REPO)
-        response.mustcontain('''<a href="/%s/changeset/70d4cef8a37657ee4cf5aabb3bd9f68879769816">r115:70d4cef8a376</a>''' % HG_REPO)
-        response.mustcontain('''<a href="/%s/changeset/c5ddebc06eaaba3010c2d66ea6ec9d074eb0f678">r112:c5ddebc06eaa</a>''' % HG_REPO)
+        response.mustcontain('''<a href="/%s/changeset/bb1a3ab98cc45cb934a77dcabf87a5a598b59e97">r118:bb1a3ab98cc4</a>''' % HG_REPO)
+        response.mustcontain('''<a href="/%s/changeset/36e0fc9d2808c5022a24f49d6658330383ed8666">r119:36e0fc9d2808</a>''' % HG_REPO)
+        response.mustcontain('''<a href="/%s/changeset/17544fbfcd33ffb439e2b728b5d526b1ef30bfcf">r120:17544fbfcd33</a>''' % HG_REPO)
 
         ## files diff
         response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--1c5cf9e91c12">docs/api/utils/index.rst</a></div>''' % (HG_REPO, tag1, tag2))
         response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--e3305437df55">test_and_report.sh</a></div>''' % (HG_REPO, tag1, tag2))
         response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--c8e92ef85cd1">.hgignore</a></div>''' % (HG_REPO, tag1, tag2))
         response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--6e08b694d687">.hgtags</a></div>''' % (HG_REPO, tag1, tag2))
         response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--2c14b00f3393">docs/api/index.rst</a></div>''' % (HG_REPO, tag1, tag2))
         response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--430ccbc82bdf">vcs/__init__.py</a></div>''' % (HG_REPO, tag1, tag2))
         response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--9c390eb52cd6">vcs/backends/hg.py</a></div>''' % (HG_REPO, tag1, tag2))
         response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--ebb592c595c0">vcs/utils/__init__.py</a></div>''' % (HG_REPO, tag1, tag2))
         response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--7abc741b5052">vcs/utils/annotate.py</a></div>''' % (HG_REPO, tag1, tag2))
         response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--2ef0ef106c56">vcs/utils/diffs.py</a></div>''' % (HG_REPO, tag1, tag2))
         response.mustcontain('''<div class="node"><a href="/%s/compare/tag@%s...tag@%s#C--3150cb87d4b7">vcs/utils/lazy.py</a></div>''' % (HG_REPO, tag1, tag2))
 
-    def test_index_branch(self):
+    def test_compare_tag_git(self):
+        self.log_user()
+        tag1 = 'v0.1.2'
+        tag2 = 'v0.1.3'
+        response = self.app.get(url(controller='compare', action='index',
+                                    repo_name=GIT_REPO,
+                                    org_ref_type="tag",
+                                    org_ref=tag1,
+                                    other_ref_type="tag",
+                                    other_ref=tag2,
+                                    bundle=False
+                                    ))
+        response.mustcontain('%s@%s -> %s@%s' % (GIT_REPO, tag1, GIT_REPO, tag2))
+
+        ## outgoing changesets between tags
+        response.mustcontain('''<a href="/%s/changeset/794bbdd31545c199f74912709ea350dedcd189a2">r113:794bbdd31545</a>''' % GIT_REPO)
+        response.mustcontain('''<a href="/%s/changeset/e36d8c5025329bdd4212bd53d4ed8a70ff44985f">r115:e36d8c502532</a>''' % GIT_REPO)
+        response.mustcontain('''<a href="/%s/changeset/5c9ff4f6d7508db0e72b1d2991c357d0d8e07af2">r116:5c9ff4f6d750</a>''' % GIT_REPO)
+        response.mustcontain('''<a href="/%s/changeset/b7187fa2b8c1d773ec35e9dee12f01f74808c879">r117:b7187fa2b8c1</a>''' % GIT_REPO)
+        response.mustcontain('''<a href="/%s/changeset/5f3b74262014a8de2dc7dade1152de9fd0c8efef">r118:5f3b74262014</a>''' % GIT_REPO)
+        response.mustcontain('''<a href="/%s/changeset/17438a11f72b93f56d0e08e7d1fa79a378578a82">r119:17438a11f72b</a>''' % GIT_REPO)
+        response.mustcontain('''<a href="/%s/changeset/5a3a8fb005554692b16e21dee62bf02667d8dc3e">r120:5a3a8fb00555</a>''' % GIT_REPO)
+
+        #files
+        response.mustcontain('''<a href="/%s/compare/tag@%s...tag@%s#C--1c5cf9e91c12">docs/api/utils/index.rst</a>''' % (GIT_REPO, tag1, tag2))
+        response.mustcontain('''<a href="/%s/compare/tag@%s...tag@%s#C--e3305437df55">test_and_report.sh</a>''' % (GIT_REPO, tag1, tag2))
+        response.mustcontain('''<a href="/%s/compare/tag@%s...tag@%s#C--c8e92ef85cd1">.hgignore</a>''' % (GIT_REPO, tag1, tag2))
+        response.mustcontain('''<a href="/%s/compare/tag@%s...tag@%s#C--6e08b694d687">.hgtags</a>''' % (GIT_REPO, tag1, tag2))
+        response.mustcontain('''<a href="/%s/compare/tag@%s...tag@%s#C--2c14b00f3393">docs/api/index.rst</a>''' % (GIT_REPO, tag1, tag2))
+        response.mustcontain('''<a href="/%s/compare/tag@%s...tag@%s#C--430ccbc82bdf">vcs/__init__.py</a>''' % (GIT_REPO, tag1, tag2))
+        response.mustcontain('''<a href="/%s/compare/tag@%s...tag@%s#C--9c390eb52cd6">vcs/backends/hg.py</a>''' % (GIT_REPO, tag1, tag2))
+        response.mustcontain('''<a href="/%s/compare/tag@%s...tag@%s#C--ebb592c595c0">vcs/utils/__init__.py</a>''' % (GIT_REPO, tag1, tag2))
+        response.mustcontain('''<a href="/%s/compare/tag@%s...tag@%s#C--7abc741b5052">vcs/utils/annotate.py</a>''' % (GIT_REPO, tag1, tag2))
+        response.mustcontain('''<a href="/%s/compare/tag@%s...tag@%s#C--2ef0ef106c56">vcs/utils/diffs.py</a>''' % (GIT_REPO, tag1, tag2))
+        response.mustcontain('''<a href="/%s/compare/tag@%s...tag@%s#C--3150cb87d4b7">vcs/utils/lazy.py</a>''' % (GIT_REPO, tag1, tag2))
+
+    def test_index_branch_hg(self):
         self.log_user()
         response = self.app.get(url(controller='compare', action='index',
                                     repo_name=HG_REPO,
                                     org_ref_type="branch",
                                     org_ref='default',
                                     other_ref_type="branch",
                                     other_ref='default',
                                     ))
 
         response.mustcontain('%s@default -> %s@default' % (HG_REPO, HG_REPO))
         # branch are equal
-        response.mustcontain('<tr><td>No changesets</td></tr>')
+        response.mustcontain('<span class="empty_data">No files</span>')
+        response.mustcontain('<span class="empty_data">No changesets</span>')
+
+    def test_index_branch_git(self):
+        self.log_user()
+        response = self.app.get(url(controller='compare', action='index',
+                                    repo_name=GIT_REPO,
+                                    org_ref_type="branch",
+                                    org_ref='master',
+                                    other_ref_type="branch",
+                                    other_ref='master',
+                                    ))
+
+        response.mustcontain('%s@master -> %s@master' % (GIT_REPO, GIT_REPO))
+        # branch are equal
+        response.mustcontain('<span class="empty_data">No files</span>')
+        response.mustcontain('<span class="empty_data">No changesets</span>')
 
     def test_compare_revisions(self):
         self.log_user()
-        rev1 = '3d8f361e72ab'
-        rev2 = 'b986218ba1c9'
+        rev1 = 'b986218ba1c9'
+        rev2 = '3d8f361e72ab'
+
         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,
                                     ))
         response.mustcontain('%s@%s -> %s@%s' % (HG_REPO, rev1, HG_REPO, rev2))
         ## outgoing changesets between those revisions
-        response.mustcontain("""<a href="/%s/changeset/3d8f361e72ab303da48d799ff1ac40d5ac37c67e">r1:%s</a>""" % (HG_REPO, rev1))
-
+        response.mustcontain("""<a href="/%s/changeset/3d8f361e72ab303da48d799ff1ac40d5ac37c67e">r1:%s</a>""" % (HG_REPO, rev2))
         ## files
         response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s#C--c8e92ef85cd1">.hgignore</a>""" % (HG_REPO, rev1, rev2))
 
     def test_compare_remote_repos(self):
         self.log_user()
 
         form_data = dict(
             repo_name=HG_FORK,
             repo_name_full=HG_FORK,
             repo_group=None,
             repo_type='hg',
             description='',
             private=False,
             copy_permissions=False,
             landing_rev='tip',
             update_after_clone=False,
             fork_parent_id=Repository.get_by_repo_name(HG_REPO),
         )
         RepoModel().create_fork(form_data, cur_user=TEST_USER_ADMIN_LOGIN)
 
         Session().commit()
 
-        rev1 = '7d4bc8ec6be5'
-        rev2 = '56349e29c2af'
+        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,
+                                    repo=HG_FORK,
+                                    ))
+
+        try:
+            response.mustcontain('%s@%s -> %s@%s' % (HG_REPO, rev1, HG_FORK, rev2))
+            ## outgoing changesets between those revisions
+
+            response.mustcontain("""<a href="/%s/changeset/2dda4e345facb0ccff1a191052dd1606dba6781d">r4:2dda4e345fac</a>""" % (HG_REPO))
+            response.mustcontain("""<a href="/%s/changeset/6fff84722075f1607a30f436523403845f84cd9e">r5:6fff84722075</a>""" % (HG_REPO))
+            response.mustcontain("""<a href="/%s/changeset/7d4bc8ec6be56c0f10425afb40b6fc315a4c25e7">r6:%s</a>""" % (HG_REPO, rev2))
+
+            ## files
+            response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s#C--9c390eb52cd6">vcs/backends/hg.py</a>""" % (HG_REPO, rev1, rev2))
+            response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s#C--41b41c1f2796">vcs/backends/__init__.py</a>""" % (HG_REPO, rev1, rev2))
+            response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s#C--2f574d260608">vcs/backends/base.py</a>""" % (HG_REPO, rev1, rev2))
+        finally:
+            RepoModel().delete(HG_FORK)
+
+    def test_compare_remote_repos_remote_flag_off(self):
+        self.log_user()
+
+        form_data = dict(
+            repo_name=HG_FORK,
+            repo_name_full=HG_FORK,
+            repo_group=None,
+            repo_type='hg',
+            description='',
+            private=False,
+            copy_permissions=False,
+            landing_rev='tip',
+            update_after_clone=False,
+            fork_parent_id=Repository.get_by_repo_name(HG_REPO),
+        )
+        RepoModel().create_fork(form_data, cur_user=TEST_USER_ADMIN_LOGIN)
+
+        Session().commit()
+
+        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,
-                                    repo=HG_FORK
+                                    repo=HG_FORK,
+                                    bundle=False,
                                     ))
 
         try:
             response.mustcontain('%s@%s -> %s@%s' % (HG_REPO, rev1, HG_FORK, rev2))
             ## outgoing changesets between those revisions
 
-            response.mustcontain("""<a href="/%s/changeset/7d4bc8ec6be56c0f10425afb40b6fc315a4c25e7">r6:%s</a>""" % (HG_REPO, rev1))
+            response.mustcontain("""<a href="/%s/changeset/2dda4e345facb0ccff1a191052dd1606dba6781d">r4:2dda4e345fac</a>""" % (HG_REPO))
             response.mustcontain("""<a href="/%s/changeset/6fff84722075f1607a30f436523403845f84cd9e">r5:6fff84722075</a>""" % (HG_REPO))
-            response.mustcontain("""<a href="/%s/changeset/2dda4e345facb0ccff1a191052dd1606dba6781d">r4:2dda4e345fac</a>""" % (HG_REPO))
+            response.mustcontain("""<a href="/%s/changeset/7d4bc8ec6be56c0f10425afb40b6fc315a4c25e7">r6:%s</a>""" % (HG_REPO, rev2))
 
             ## files
             response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s#C--9c390eb52cd6">vcs/backends/hg.py</a>""" % (HG_REPO, rev1, rev2))
             response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s#C--41b41c1f2796">vcs/backends/__init__.py</a>""" % (HG_REPO, rev1, rev2))
             response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s#C--2f574d260608">vcs/backends/base.py</a>""" % (HG_REPO, rev1, rev2))
         finally:
             RepoModel().delete(HG_FORK)
 
+#    def test_compare_origin_ahead_of_fork(self):
+#        self.log_user()
+#
+#        form_data = dict(
+#            repo_name=HG_FORK,
+#            repo_name_full=HG_FORK,
+#            repo_group=None,
+#            repo_type='hg',
+#            description='',
+#            private=False,
+#            copy_permissions=False,
+#            landing_rev='tip',
+#            update_after_clone=False,
+#            fork_parent_id=Repository.get_by_repo_name(HG_REPO),
+#        )
+#        RepoModel().create_fork(form_data, cur_user=TEST_USER_ADMIN_LOGIN)
+#
+#        Session().commit()
+#
+#        repo1 = Repository.get_by_repo_name(HG_REPO)
+#        r1_name = HG_REPO
+#
+#        #commit something !
+#        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='extra commit1',
+#            content='line1',
+#            f_path='file1'
+#        )
+#
+#
+#        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,
+#                                    repo=HG_FORK,
+#                                    bundle=False,
+#                                    ))
+#
+#        try:
+#            response.mustcontain('%s@%s -> %s@%s' % (HG_REPO, rev1, HG_REPO, rev2))
+#            ## outgoing changesets between those revisions
+#
+#            response.mustcontain("""<a href="/%s/changeset/2dda4e345facb0ccff1a191052dd1606dba6781d">r4:2dda4e345fac</a>""" % (HG_REPO))
+#            response.mustcontain("""<a href="/%s/changeset/6fff84722075f1607a30f436523403845f84cd9e">r5:6fff84722075</a>""" % (HG_REPO))
+#            response.mustcontain("""<a href="/%s/changeset/7d4bc8ec6be56c0f10425afb40b6fc315a4c25e7">r6:%s</a>""" % (HG_REPO, rev2))
+#
+#            ## files
+#            response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s#C--9c390eb52cd6">vcs/backends/hg.py</a>""" % (HG_REPO, rev1, rev2))
+#            response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s#C--41b41c1f2796">vcs/backends/__init__.py</a>""" % (HG_REPO, rev1, rev2))
+#            response.mustcontain("""<a href="/%s/compare/rev@%s...rev@%s#C--2f574d260608">vcs/backends/base.py</a>""" % (HG_REPO, rev1, rev2))
+#        finally:
+#            RepoModel().delete(HG_FORK)
+
     def test_compare_extra_commits(self):
         self.log_user()
 
         repo1 = RepoModel().create_repo(repo_name='one', repo_type='hg',
                                         description='diff-test',
                                         owner=TEST_USER_ADMIN_LOGIN)
 
         repo2 = RepoModel().create_repo(repo_name='one-fork', repo_type='hg',
                                         description='diff-test',
                                         owner=TEST_USER_ADMIN_LOGIN)
 
         Session().commit()
         r1_id = repo1.repo_id
         r1_name = repo1.repo_name
         r2_id = repo2.repo_id
         r2_name = repo2.repo_name
 
         #commit something !
         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'
         )
 
         cs0_prim = ScmModel().create_node(
             repo=repo2.scm_instance, repo_name=r2_name,
             cs=EmptyChangeset(alias='hg'), user=TEST_USER_ADMIN_LOGIN,
             author=TEST_USER_ADMIN_LOGIN,
             message='commit1',
             content='line1',
             f_path='file1'
         )
 
         cs1 = ScmModel().commit_change(
             repo=repo2.scm_instance, repo_name=r2_name,
             cs=cs0_prim, user=TEST_USER_ADMIN_LOGIN, author=TEST_USER_ADMIN_LOGIN,
             message='commit2',
             content='line1\nline2',
             f_path='file1'
         )
 
         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,
                                     repo=r1_name
                                     ))
 
         try:
             response.mustcontain('%s@%s -> %s@%s' % (r2_name, rev1, r1_name, rev2))
 
-            response.mustcontain("""<div class="message">commit2</div>""")
+            response.mustcontain("""<div class="message tooltip" title="commit2" style="white-space:normal">commit2</div>""")
             response.mustcontain("""<a href="/%s/changeset/%s">r1:%s</a>""" % (r2_name, cs1.raw_id, cs1.short_id))
             ## files
             response.mustcontain("""<a href="/%s/compare/branch@%s...branch@%s#C--826e8142e6ba">file1</a>""" % (r2_name, rev1, rev2))
 
         finally:
             RepoModel().delete(r1_id)
             RepoModel().delete(r2_id)
 
     def test_org_repo_new_commits_after_forking(self):
         self.log_user()
 
         repo1 = RepoModel().create_repo(repo_name='one', repo_type='hg',
                                         description='diff-test',
                                         owner=TEST_USER_ADMIN_LOGIN)
 
         Session().commit()
         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])
         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,
                                     repo=r1_name,
                                     bundle=True,
                                     ))
 
         try:
             response.mustcontain('%s@%s -> %s@%s' % (r2_name, rev1, r1_name, rev2))
             response.mustcontain("""file1-line1-from-fork""")
             response.mustcontain("""file2-line1-from-fork""")
             response.mustcontain("""file3-line1-from-fork""")
 
             #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',
                 content='line1-from-new-parent',
                 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,
                                         repo=r1_name,
                                         bundle=True,
                                         ))
 
             response.mustcontain('%s@%s -> %s@%s' % (r2_name, rev1, r1_name, rev2))
             response.mustcontain("""<a href="#">file2</a>""")  # new commit from parent
             response.mustcontain("""line1-from-new-parent""")
             response.mustcontain("""file1-line1-from-fork""")
             response.mustcontain("""file2-line1-from-fork""")
             response.mustcontain("""file3-line1-from-fork""")
         finally:
             RepoModel().delete(r2_id)
             RepoModel().delete(r1_id)
 
     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()
         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])
         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,
                                     repo=r1_name,
                                     bundle=False,
                                     ))
 
         try:
             #response.mustcontain('%s@%s -> %s@%s' % (r2_name, rev1, r1_name, rev2))
 
             #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',
                 content='line1',
                 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,
                                         repo=r1_name,
                                         bundle=False
                                         ))
-            rev2 = cs0.parents[0].raw_id
+
             response.mustcontain('%s@%s -> %s@%s' % (r2_name, rev1, r1_name, rev2))
             response.mustcontain("""file1-line1-from-fork""")
             response.mustcontain("""file2-line1-from-fork""")
             response.mustcontain("""file3-line1-from-fork""")
             self.assertFalse("""<a href="#">file2</a>""" in response.body)  # new commit from parent
             self.assertFalse("""line1-from-new-parent"""  in response.body)
         finally:
             RepoModel().delete(r2_id)
             RepoModel().delete(r1_id)