compare: swap org and other when they refer to different repos, ie are pull request style

Pull requests will have a different from/to description - but in a consistent
and slightly better way that can be improved later.

A pull request diff is empathic: "How will this look for the peer I'm proposing to" style.

rhodecode/config/routing.py

@@ -1,648 +1,648 b''
 """
 Routes configuration
 
 The more specific and detailed routes should be defined first so they
 may take precedent over the more generic routes. For more information
 refer to the routes manual at http://routes.groovie.org/docs/
 """
 from __future__ import with_statement
 from routes import Mapper
 
 # prefix for non repository related links needs to be prefixed with `/`
 ADMIN_PREFIX = '/_admin'
 
 
 def make_map(config):
     """Create, configure and return the routes Mapper"""
     rmap = Mapper(directory=config['pylons.paths']['controllers'],
                  always_scan=config['debug'])
     rmap.minimization = False
     rmap.explicit = False
 
     from rhodecode.lib.utils import is_valid_repo
     from rhodecode.lib.utils import is_valid_repos_group
 
     def check_repo(environ, match_dict):
         """
         check for valid repository for proper 404 handling
 
         :param environ:
         :param match_dict:
         """
         from rhodecode.model.db import Repository
         repo_name = match_dict.get('repo_name')
 
         if match_dict.get('f_path'):
             #fix for multiple initial slashes that causes errors
             match_dict['f_path'] = match_dict['f_path'].lstrip('/')
 
         try:
             by_id = repo_name.split('_')
             if len(by_id) == 2 and by_id[1].isdigit() and by_id[0] == '':
                 repo_name = Repository.get(by_id[1]).repo_name
                 match_dict['repo_name'] = repo_name
         except:
             pass
 
         return is_valid_repo(repo_name, config['base_path'])
 
     def check_group(environ, match_dict):
         """
         check for valid repositories group for proper 404 handling
 
         :param environ:
         :param match_dict:
         """
         repos_group_name = match_dict.get('group_name')
         return is_valid_repos_group(repos_group_name, config['base_path'])
 
     def check_int(environ, match_dict):
         return match_dict.get('id').isdigit()
 
     # The ErrorController route (handles 404/500 error pages); it should
     # likely stay at the top, ensuring it can always be resolved
     rmap.connect('/error/{action}', controller='error')
     rmap.connect('/error/{action}/{id}', controller='error')
 
     #==========================================================================
     # CUSTOM ROUTES HERE
     #==========================================================================
 
     #MAIN PAGE
     rmap.connect('home', '/', controller='home', action='index')
     rmap.connect('repo_switcher', '/repos', controller='home',
                  action='repo_switcher')
     rmap.connect('branch_tag_switcher', '/branches-tags/{repo_name:.*?}',
                  controller='home', action='branch_tag_switcher')
     rmap.connect('bugtracker',
                  "http://bitbucket.org/marcinkuzminski/rhodecode/issues",
                  _static=True)
     rmap.connect('rst_help',
                  "http://docutils.sourceforge.net/docs/user/rst/quickref.html",
                  _static=True)
     rmap.connect('rhodecode_official', "http://rhodecode.org", _static=True)
 
     #ADMIN REPOSITORY REST ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/repos') as m:
         m.connect("repos", "/repos",
              action="create", conditions=dict(method=["POST"]))
         m.connect("repos", "/repos",
              action="index", conditions=dict(method=["GET"]))
         m.connect("formatted_repos", "/repos.{format}",
              action="index",
             conditions=dict(method=["GET"]))
         m.connect("new_repo", "/repos/new",
              action="new", conditions=dict(method=["GET"]))
         m.connect("formatted_new_repo", "/repos/new.{format}",
              action="new", conditions=dict(method=["GET"]))
         m.connect("/repos/{repo_name:.*?}",
              action="update", conditions=dict(method=["PUT"],
                                               function=check_repo))
         m.connect("/repos/{repo_name:.*?}",
              action="delete", conditions=dict(method=["DELETE"],
                                               function=check_repo))
         # no longer used:
         m.connect("edit_repo_admin", "/repos/{repo_name:.*?}/edit",
              action="edit", conditions=dict(method=["GET"],
                                             function=check_repo))
         m.connect("formatted_edit_repo", "/repos/{repo_name:.*?}.{format}/edit",
              action="edit", conditions=dict(method=["GET"],
                                             function=check_repo))
         m.connect("repo", "/repos/{repo_name:.*?}",
              action="show", conditions=dict(method=["GET"],
                                             function=check_repo))
         m.connect("formatted_repo", "/repos/{repo_name:.*?}.{format}",
              action="show", conditions=dict(method=["GET"],
                                             function=check_repo))
         #ajax delete repo perm user
         m.connect('delete_repo_user', "/repos_delete_user/{repo_name:.*?}",
              action="delete_perm_user",
              conditions=dict(method=["DELETE"], function=check_repo))
 
         #ajax delete repo perm users_group
         m.connect('delete_repo_users_group',
                   "/repos_delete_users_group/{repo_name:.*?}",
                   action="delete_perm_users_group",
                   conditions=dict(method=["DELETE"], function=check_repo))
 
         #settings actions
         m.connect('repo_stats', "/repos_stats/{repo_name:.*?}",
                   action="repo_stats", conditions=dict(method=["DELETE"],
                                                        function=check_repo))
         m.connect('repo_cache', "/repos_cache/{repo_name:.*?}",
                   action="repo_cache", conditions=dict(method=["DELETE"],
                                                        function=check_repo))
         m.connect('repo_public_journal', "/repos_public_journal/{repo_name:.*?}",
                   action="repo_public_journal", conditions=dict(method=["PUT"],
                                                         function=check_repo))
         m.connect('repo_pull', "/repo_pull/{repo_name:.*?}",
                   action="repo_pull", conditions=dict(method=["PUT"],
                                                       function=check_repo))
         m.connect('repo_as_fork', "/repo_as_fork/{repo_name:.*?}",
                   action="repo_as_fork", conditions=dict(method=["PUT"],
                                                       function=check_repo))
         m.connect('repo_locking', "/repo_locking/{repo_name:.*?}",
                   action="repo_locking", conditions=dict(method=["PUT"],
                                                       function=check_repo))
         #repo fields
         m.connect('create_repo_fields', "/repo_fields/{repo_name:.*?}/new",
                   action="create_repo_field", conditions=dict(method=["PUT"],
                                                       function=check_repo))
 
         m.connect('delete_repo_fields', "/repo_fields/{repo_name:.*?}/{field_id}",
                   action="delete_repo_field", conditions=dict(method=["DELETE"],
                                                       function=check_repo))
 
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/repos_groups') as m:
         m.connect("repos_groups", "/repos_groups",
                   action="create", conditions=dict(method=["POST"]))
         m.connect("repos_groups", "/repos_groups",
                   action="index", conditions=dict(method=["GET"]))
         m.connect("formatted_repos_groups", "/repos_groups.{format}",
                   action="index", conditions=dict(method=["GET"]))
         m.connect("new_repos_group", "/repos_groups/new",
                   action="new", conditions=dict(method=["GET"]))
         m.connect("formatted_new_repos_group", "/repos_groups/new.{format}",
                   action="new", conditions=dict(method=["GET"]))
         m.connect("update_repos_group", "/repos_groups/{group_name:.*?}",
                   action="update", conditions=dict(method=["PUT"],
                                                    function=check_group))
         m.connect("delete_repos_group", "/repos_groups/{group_name:.*?}",
                   action="delete", conditions=dict(method=["DELETE"],
                                                    function=check_group))
         m.connect("edit_repos_group", "/repos_groups/{group_name:.*?}/edit",
                   action="edit", conditions=dict(method=["GET"],))
         m.connect("formatted_edit_repos_group",
                   "/repos_groups/{group_name:.*?}.{format}/edit",
                   action="edit", conditions=dict(method=["GET"],
                                                  function=check_group))
         m.connect("repos_group", "/repos_groups/{group_name:.*?}",
                   action="show", conditions=dict(method=["GET"],
                                                  function=check_group))
         m.connect("formatted_repos_group", "/repos_groups/{group_name:.*?}.{format}",
                   action="show", conditions=dict(method=["GET"],
                                                  function=check_group))
         # ajax delete repos group perm user
         m.connect('delete_repos_group_user_perm',
                   "/delete_repos_group_user_perm/{group_name:.*?}",
              action="delete_repos_group_user_perm",
              conditions=dict(method=["DELETE"], function=check_group))
 
         # ajax delete repos group perm users_group
         m.connect('delete_repos_group_users_group_perm',
                   "/delete_repos_group_users_group_perm/{group_name:.*?}",
                   action="delete_repos_group_users_group_perm",
                   conditions=dict(method=["DELETE"], function=check_group))
 
     #ADMIN USER REST ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/users') as m:
         m.connect("users", "/users",
                   action="create", conditions=dict(method=["POST"]))
         m.connect("users", "/users",
                   action="index", conditions=dict(method=["GET"]))
         m.connect("formatted_users", "/users.{format}",
                   action="index", conditions=dict(method=["GET"]))
         m.connect("new_user", "/users/new",
                   action="new", conditions=dict(method=["GET"]))
         m.connect("formatted_new_user", "/users/new.{format}",
                   action="new", conditions=dict(method=["GET"]))
         m.connect("update_user", "/users/{id}",
                   action="update", conditions=dict(method=["PUT"]))
         m.connect("delete_user", "/users/{id}",
                   action="delete", conditions=dict(method=["DELETE"]))
         m.connect("edit_user", "/users/{id}/edit",
                   action="edit", conditions=dict(method=["GET"]))
         m.connect("formatted_edit_user",
                   "/users/{id}.{format}/edit",
                   action="edit", conditions=dict(method=["GET"]))
         m.connect("user", "/users/{id}",
                   action="show", conditions=dict(method=["GET"]))
         m.connect("formatted_user", "/users/{id}.{format}",
                   action="show", conditions=dict(method=["GET"]))
 
         #EXTRAS USER ROUTES
         m.connect("user_perm", "/users_perm/{id}",
                   action="update_perm", conditions=dict(method=["PUT"]))
         m.connect("user_emails", "/users_emails/{id}",
                   action="add_email", conditions=dict(method=["PUT"]))
         m.connect("user_emails_delete", "/users_emails/{id}",
                   action="delete_email", conditions=dict(method=["DELETE"]))
         m.connect("user_ips", "/users_ips/{id}",
                   action="add_ip", conditions=dict(method=["PUT"]))
         m.connect("user_ips_delete", "/users_ips/{id}",
                   action="delete_ip", conditions=dict(method=["DELETE"]))
 
     #ADMIN USERS GROUPS REST ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/users_groups') as m:
         m.connect("users_groups", "/users_groups",
                   action="create", conditions=dict(method=["POST"]))
         m.connect("users_groups", "/users_groups",
                   action="index", conditions=dict(method=["GET"]))
         m.connect("formatted_users_groups", "/users_groups.{format}",
                   action="index", conditions=dict(method=["GET"]))
         m.connect("new_users_group", "/users_groups/new",
                   action="new", conditions=dict(method=["GET"]))
         m.connect("formatted_new_users_group", "/users_groups/new.{format}",
                   action="new", conditions=dict(method=["GET"]))
         m.connect("update_users_group", "/users_groups/{id}",
                   action="update", conditions=dict(method=["PUT"]))
         m.connect("delete_users_group", "/users_groups/{id}",
                   action="delete", conditions=dict(method=["DELETE"]))
         m.connect("edit_users_group", "/users_groups/{id}/edit",
                   action="edit", conditions=dict(method=["GET"]))
         m.connect("formatted_edit_users_group",
                   "/users_groups/{id}.{format}/edit",
                   action="edit", conditions=dict(method=["GET"]))
         m.connect("users_group", "/users_groups/{id}",
                   action="show", conditions=dict(method=["GET"]))
         m.connect("formatted_users_group", "/users_groups/{id}.{format}",
                   action="show", conditions=dict(method=["GET"]))
 
         #EXTRAS USER ROUTES
         m.connect("users_group_perm", "/users_groups_perm/{id}",
                   action="update_perm", conditions=dict(method=["PUT"]))
 
     #ADMIN GROUP REST ROUTES
     rmap.resource('group', 'groups',
                   controller='admin/groups', path_prefix=ADMIN_PREFIX)
 
     #ADMIN PERMISSIONS REST ROUTES
     rmap.resource('permission', 'permissions',
                   controller='admin/permissions', path_prefix=ADMIN_PREFIX)
 
     #ADMIN DEFAULTS REST ROUTES
     rmap.resource('default', 'defaults',
                   controller='admin/defaults', path_prefix=ADMIN_PREFIX)
 
     ##ADMIN LDAP SETTINGS
     rmap.connect('ldap_settings', '%s/ldap' % ADMIN_PREFIX,
                  controller='admin/ldap_settings', action='ldap_settings',
                  conditions=dict(method=["POST"]))
 
     rmap.connect('ldap_home', '%s/ldap' % ADMIN_PREFIX,
                  controller='admin/ldap_settings')
 
     #ADMIN SETTINGS REST ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/settings') as m:
         m.connect("admin_settings", "/settings",
                   action="create", conditions=dict(method=["POST"]))
         m.connect("admin_settings", "/settings",
                   action="index", conditions=dict(method=["GET"]))
         m.connect("formatted_admin_settings", "/settings.{format}",
                   action="index", conditions=dict(method=["GET"]))
         m.connect("admin_new_setting", "/settings/new",
                   action="new", conditions=dict(method=["GET"]))
         m.connect("formatted_admin_new_setting", "/settings/new.{format}",
                   action="new", conditions=dict(method=["GET"]))
         m.connect("/settings/{setting_id}",
                   action="update", conditions=dict(method=["PUT"]))
         m.connect("/settings/{setting_id}",
                   action="delete", conditions=dict(method=["DELETE"]))
         m.connect("admin_edit_setting", "/settings/{setting_id}/edit",
                   action="edit", conditions=dict(method=["GET"]))
         m.connect("formatted_admin_edit_setting",
                   "/settings/{setting_id}.{format}/edit",
                   action="edit", conditions=dict(method=["GET"]))
         m.connect("admin_setting", "/settings/{setting_id}",
                   action="show", conditions=dict(method=["GET"]))
         m.connect("formatted_admin_setting", "/settings/{setting_id}.{format}",
                   action="show", conditions=dict(method=["GET"]))
         m.connect("admin_settings_my_account", "/my_account",
                   action="my_account", conditions=dict(method=["GET"]))
         m.connect("admin_settings_my_account_update", "/my_account_update",
                   action="my_account_update", conditions=dict(method=["PUT"]))
         m.connect("admin_settings_create_repository", "/create_repository",
                   action="create_repository", conditions=dict(method=["GET"]))
         m.connect("admin_settings_my_repos", "/my_account/repos",
                   action="my_account_my_repos", conditions=dict(method=["GET"]))
         m.connect("admin_settings_my_pullrequests", "/my_account/pull_requests",
                   action="my_account_my_pullrequests", conditions=dict(method=["GET"]))
 
     #NOTIFICATION REST ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/notifications') as m:
         m.connect("notifications", "/notifications",
                   action="create", conditions=dict(method=["POST"]))
         m.connect("notifications", "/notifications",
                   action="index", conditions=dict(method=["GET"]))
         m.connect("notifications_mark_all_read", "/notifications/mark_all_read",
                   action="mark_all_read", conditions=dict(method=["GET"]))
         m.connect("formatted_notifications", "/notifications.{format}",
                   action="index", conditions=dict(method=["GET"]))
         m.connect("new_notification", "/notifications/new",
                   action="new", conditions=dict(method=["GET"]))
         m.connect("formatted_new_notification", "/notifications/new.{format}",
                   action="new", conditions=dict(method=["GET"]))
         m.connect("/notification/{notification_id}",
                   action="update", conditions=dict(method=["PUT"]))
         m.connect("/notification/{notification_id}",
                   action="delete", conditions=dict(method=["DELETE"]))
         m.connect("edit_notification", "/notification/{notification_id}/edit",
                   action="edit", conditions=dict(method=["GET"]))
         m.connect("formatted_edit_notification",
                   "/notification/{notification_id}.{format}/edit",
                   action="edit", conditions=dict(method=["GET"]))
         m.connect("notification", "/notification/{notification_id}",
                   action="show", conditions=dict(method=["GET"]))
         m.connect("formatted_notification", "/notifications/{notification_id}.{format}",
                   action="show", conditions=dict(method=["GET"]))
 
     #ADMIN MAIN PAGES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='admin/admin') as m:
         m.connect('admin_home', '', action='index')
         m.connect('admin_add_repo', '/add_repo/{new_repo:[a-z0-9\. _-]*}',
                   action='add_repo')
 
     #==========================================================================
     # API V2
     #==========================================================================
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='api/api') as m:
         m.connect('api', '/api')
 
     #USER JOURNAL
     rmap.connect('journal', '%s/journal' % ADMIN_PREFIX,
                  controller='journal', action='index')
     rmap.connect('journal_rss', '%s/journal/rss' % ADMIN_PREFIX,
                  controller='journal', action='journal_rss')
     rmap.connect('journal_atom', '%s/journal/atom' % ADMIN_PREFIX,
                  controller='journal', action='journal_atom')
 
     rmap.connect('public_journal', '%s/public_journal' % ADMIN_PREFIX,
                  controller='journal', action="public_journal")
 
     rmap.connect('public_journal_rss', '%s/public_journal/rss' % ADMIN_PREFIX,
                  controller='journal', action="public_journal_rss")
 
     rmap.connect('public_journal_rss_old', '%s/public_journal_rss' % ADMIN_PREFIX,
                  controller='journal', action="public_journal_rss")
 
     rmap.connect('public_journal_atom',
                  '%s/public_journal/atom' % ADMIN_PREFIX, controller='journal',
                  action="public_journal_atom")
 
     rmap.connect('public_journal_atom_old',
                  '%s/public_journal_atom' % ADMIN_PREFIX, controller='journal',
                  action="public_journal_atom")
 
     rmap.connect('toggle_following', '%s/toggle_following' % ADMIN_PREFIX,
                  controller='journal', action='toggle_following',
                  conditions=dict(method=["POST"]))
 
     #SEARCH
     rmap.connect('search', '%s/search' % ADMIN_PREFIX, controller='search',)
     rmap.connect('search_repo_admin', '%s/search/{repo_name:.*}' % ADMIN_PREFIX,
                  controller='search',
                  conditions=dict(function=check_repo))
     rmap.connect('search_repo', '/{repo_name:.*?}/search',
                  controller='search',
                  conditions=dict(function=check_repo),
                  )
 
     #LOGIN/LOGOUT/REGISTER/SIGN IN
     rmap.connect('login_home', '%s/login' % ADMIN_PREFIX, controller='login')
     rmap.connect('logout_home', '%s/logout' % ADMIN_PREFIX, controller='login',
                  action='logout')
 
     rmap.connect('register', '%s/register' % ADMIN_PREFIX, controller='login',
                  action='register')
 
     rmap.connect('reset_password', '%s/password_reset' % ADMIN_PREFIX,
                  controller='login', action='password_reset')
 
     rmap.connect('reset_password_confirmation',
                  '%s/password_reset_confirmation' % ADMIN_PREFIX,
                  controller='login', action='password_reset_confirmation')
 
     #FEEDS
     rmap.connect('rss_feed_home', '/{repo_name:.*?}/feed/rss',
                 controller='feed', action='rss',
                 conditions=dict(function=check_repo))
 
     rmap.connect('atom_feed_home', '/{repo_name:.*?}/feed/atom',
                 controller='feed', action='atom',
                 conditions=dict(function=check_repo))
 
     #==========================================================================
     # REPOSITORY ROUTES
     #==========================================================================
     rmap.connect('summary_home', '/{repo_name:.*?}',
                 controller='summary',
                 conditions=dict(function=check_repo))
 
     rmap.connect('repo_size', '/{repo_name:.*?}/repo_size',
                 controller='summary', action='repo_size',
                 conditions=dict(function=check_repo))
 
     rmap.connect('repos_group_home', '/{group_name:.*}',
                 controller='admin/repos_groups', action="show_by_name",
                 conditions=dict(function=check_group))
 
     rmap.connect('changeset_home', '/{repo_name:.*?}/changeset/{revision}',
                 controller='changeset', revision='tip',
                 conditions=dict(function=check_repo))
 
     rmap.connect("edit_repo", "/{repo_name:.*?}/edit",
                  controller='admin/repos', action="edit",
                  conditions=dict(method=["GET"], function=check_repo)
                  )
 
     #still working url for backward compat.
     rmap.connect('raw_changeset_home_depraced',
                  '/{repo_name:.*?}/raw-changeset/{revision}',
                  controller='changeset', action='changeset_raw',
                  revision='tip', conditions=dict(function=check_repo))
 
     ## new URLs
     rmap.connect('changeset_raw_home',
                  '/{repo_name:.*?}/changeset-diff/{revision}',
                  controller='changeset', action='changeset_raw',
                  revision='tip', conditions=dict(function=check_repo))
 
     rmap.connect('changeset_patch_home',
                  '/{repo_name:.*?}/changeset-patch/{revision}',
                  controller='changeset', action='changeset_patch',
                  revision='tip', conditions=dict(function=check_repo))
 
     rmap.connect('changeset_download_home',
                  '/{repo_name:.*?}/changeset-download/{revision}',
                  controller='changeset', action='changeset_download',
                  revision='tip', conditions=dict(function=check_repo))
 
     rmap.connect('changeset_comment',
                  '/{repo_name:.*?}/changeset/{revision}/comment',
                 controller='changeset', revision='tip', action='comment',
                 conditions=dict(function=check_repo))
 
     rmap.connect('changeset_comment_delete',
                  '/{repo_name:.*?}/changeset/comment/{comment_id}/delete',
                 controller='changeset', action='delete_comment',
                 conditions=dict(function=check_repo, method=["DELETE"]))
 
     rmap.connect('changeset_info', '/changeset_info/{repo_name:.*?}/{revision}',
                  controller='changeset', action='changeset_info')
 
     rmap.connect('compare_url',
                  '/{repo_name:.*?}/compare/{org_ref_type}@{org_ref:.*?}...{other_ref_type}@{other_ref:.*?}',
                  controller='compare', action='index',
                  conditions=dict(function=check_repo),
                  requirements=dict(
-                            org_ref_type='(branch|book|tag|rev|__org_ref_type__)',
-                            other_ref_type='(branch|book|tag|rev|__other_ref_type__)')
+                            org_ref_type='(branch|book|tag|rev|__other_ref_type__)',
+                            other_ref_type='(branch|book|tag|rev|__org_ref_type__)')
                  )
 
     rmap.connect('pullrequest_home',
                  '/{repo_name:.*?}/pull-request/new', controller='pullrequests',
                  action='index', conditions=dict(function=check_repo,
                                                  method=["GET"]))
 
     rmap.connect('pullrequest',
                  '/{repo_name:.*?}/pull-request/new', controller='pullrequests',
                  action='create', conditions=dict(function=check_repo,
                                                   method=["POST"]))
 
     rmap.connect('pullrequest_show',
                  '/{repo_name:.*?}/pull-request/{pull_request_id}',
                  controller='pullrequests',
                  action='show', conditions=dict(function=check_repo,
                                                 method=["GET"]))
     rmap.connect('pullrequest_update',
                  '/{repo_name:.*?}/pull-request/{pull_request_id}',
                  controller='pullrequests',
                  action='update', conditions=dict(function=check_repo,
                                                 method=["PUT"]))
     rmap.connect('pullrequest_delete',
                  '/{repo_name:.*?}/pull-request/{pull_request_id}',
                  controller='pullrequests',
                  action='delete', conditions=dict(function=check_repo,
                                                 method=["DELETE"]))
 
     rmap.connect('pullrequest_show_all',
                  '/{repo_name:.*?}/pull-request',
                  controller='pullrequests',
                  action='show_all', conditions=dict(function=check_repo,
                                                 method=["GET"]))
 
     rmap.connect('pullrequest_comment',
                  '/{repo_name:.*?}/pull-request-comment/{pull_request_id}',
                  controller='pullrequests',
                  action='comment', conditions=dict(function=check_repo,
                                                 method=["POST"]))
 
     rmap.connect('pullrequest_comment_delete',
                  '/{repo_name:.*?}/pull-request-comment/{comment_id}/delete',
                 controller='pullrequests', action='delete_comment',
                 conditions=dict(function=check_repo, method=["DELETE"]))
 
     rmap.connect('summary_home_summary', '/{repo_name:.*?}/summary',
                 controller='summary', conditions=dict(function=check_repo))
 
     rmap.connect('shortlog_home', '/{repo_name:.*?}/shortlog',
                 controller='shortlog', conditions=dict(function=check_repo))
 
     rmap.connect('shortlog_file_home', '/{repo_name:.*?}/shortlog/{revision}/{f_path:.*}',
                 controller='shortlog', f_path=None,
                 conditions=dict(function=check_repo))
 
     rmap.connect('branches_home', '/{repo_name:.*?}/branches',
                 controller='branches', conditions=dict(function=check_repo))
 
     rmap.connect('tags_home', '/{repo_name:.*?}/tags',
                 controller='tags', conditions=dict(function=check_repo))
 
     rmap.connect('bookmarks_home', '/{repo_name:.*?}/bookmarks',
                 controller='bookmarks', conditions=dict(function=check_repo))
 
     rmap.connect('changelog_home', '/{repo_name:.*?}/changelog',
                 controller='changelog', conditions=dict(function=check_repo))
 
     rmap.connect('changelog_details', '/{repo_name:.*?}/changelog_details/{cs}',
                 controller='changelog', action='changelog_details',
                 conditions=dict(function=check_repo))
 
     rmap.connect('files_home', '/{repo_name:.*?}/files/{revision}/{f_path:.*}',
                 controller='files', revision='tip', f_path='',
                 conditions=dict(function=check_repo))
 
     rmap.connect('files_history_home',
                  '/{repo_name:.*?}/history/{revision}/{f_path:.*}',
                  controller='files', action='history', revision='tip', f_path='',
                  conditions=dict(function=check_repo))
 
     rmap.connect('files_diff_home', '/{repo_name:.*?}/diff/{f_path:.*}',
                 controller='files', action='diff', revision='tip', f_path='',
                 conditions=dict(function=check_repo))
 
     rmap.connect('files_rawfile_home',
                  '/{repo_name:.*?}/rawfile/{revision}/{f_path:.*}',
                  controller='files', action='rawfile', revision='tip',
                  f_path='', conditions=dict(function=check_repo))
 
     rmap.connect('files_raw_home',
                  '/{repo_name:.*?}/raw/{revision}/{f_path:.*}',
                  controller='files', action='raw', revision='tip', f_path='',
                  conditions=dict(function=check_repo))
 
     rmap.connect('files_annotate_home',
                  '/{repo_name:.*?}/annotate/{revision}/{f_path:.*}',
                  controller='files', action='index', revision='tip',
                  f_path='', annotate=True, conditions=dict(function=check_repo))
 
     rmap.connect('files_edit_home',
                  '/{repo_name:.*?}/edit/{revision}/{f_path:.*}',
                  controller='files', action='edit', revision='tip',
                  f_path='', conditions=dict(function=check_repo))
 
     rmap.connect('files_add_home',
                  '/{repo_name:.*?}/add/{revision}/{f_path:.*}',
                  controller='files', action='add', revision='tip',
                  f_path='', conditions=dict(function=check_repo))
 
     rmap.connect('files_archive_home', '/{repo_name:.*?}/archive/{fname}',
                 controller='files', action='archivefile',
                 conditions=dict(function=check_repo))
 
     rmap.connect('files_nodelist_home',
                  '/{repo_name:.*?}/nodelist/{revision}/{f_path:.*}',
                 controller='files', action='nodelist',
                 conditions=dict(function=check_repo))
 
     rmap.connect('repo_settings_delete', '/{repo_name:.*?}/settings',
                 controller='settings', action="delete",
                 conditions=dict(method=["DELETE"], function=check_repo))
 
     rmap.connect('repo_settings_update', '/{repo_name:.*?}/settings',
                 controller='settings', action="update",
                 conditions=dict(method=["PUT"], function=check_repo))
 
     rmap.connect('repo_settings_home', '/{repo_name:.*?}/settings',
                 controller='settings', action='index',
                 conditions=dict(function=check_repo))
 
     rmap.connect('toggle_locking', "/{repo_name:.*?}/locking_toggle",
                  controller='settings', action="toggle_locking",
                  conditions=dict(method=["GET"], function=check_repo))
 
     rmap.connect('repo_fork_create_home', '/{repo_name:.*?}/fork',
                 controller='forks', action='fork_create',
                 conditions=dict(function=check_repo, method=["POST"]))
 
     rmap.connect('repo_fork_home', '/{repo_name:.*?}/fork',
                 controller='forks', action='fork',
                 conditions=dict(function=check_repo))
 
     rmap.connect('repo_forks_home', '/{repo_name:.*?}/forks',
                  controller='forks', action='forks',
                  conditions=dict(function=check_repo))
 
     rmap.connect('repo_followers_home', '/{repo_name:.*?}/followers',
                  controller='followers', action='followers',
                  conditions=dict(function=check_repo))
 
     return rmap

rhodecode/controllers/compare.py

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

rhodecode/model/pull_request.py

@@ -1,248 +1,248 b''
 # -*- 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 datetime
 import re
 
 from pylons.i18n.translation import _
 
 from rhodecode.model.meta import Session
 from rhodecode.lib import helpers as h, unionrepo
 from rhodecode.model import BaseModel
 from rhodecode.model.db import PullRequest, PullRequestReviewers, Notification,\
     ChangesetStatus
 from rhodecode.model.notification import NotificationModel
 from rhodecode.lib.utils2 import safe_unicode
 
 from rhodecode.lib.vcs.utils.hgcompat import scmutil
 from rhodecode.lib.vcs.utils import safe_str
 
 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)\
                 .order_by(PullRequest.created_on)\
                 .all()
 
     def create(self, created_by, org_repo, org_ref, other_repo, other_ref,
                revisions, reviewers, title, description=None):
         from rhodecode.model.changeset_status import ChangesetStatusModel
 
         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)
 
         #reset state to under-review
         ChangesetStatusModel().set_status(
             repo=org_repo,
             status=ChangesetStatus.STATUS_UNDER_REVIEW,
             user=created_by_user,
             pull_request=new
         )
 
         #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: %(pr_title)s') % \
                 {'user': created_by_user.username,
                  'pr_title': new.title,
                  '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):
         """
         Returns a list of changesets that are incoming from org_repo@org_ref
         to other_repo@other_ref
 
         :param org_repo:
         :param org_ref:
         :param other_repo:
         :param other_ref:
         :param tmp:
         """
 
         changesets = []
 
         if alias == 'hg':
             # lookup up the exact node id
             _revset_predicates = {
                     'branch': 'branch',
                     'book': 'bookmark',
                     'tag': 'tag',
                     'rev': 'id',
                 }
             org_rev_spec = "%s('%s')" % (_revset_predicates[org_ref[0]],
                                          safe_str(org_ref[1]))
             org_rev = scmutil.revsingle(org_repo._repo,
                                          org_rev_spec)
             other_rev_spec = "%s('%s')" % (_revset_predicates[other_ref[0]],
                                            safe_str(other_ref[1]))
             other_rev = scmutil.revsingle(other_repo._repo, other_rev_spec)
 
             #case two independent repos
             if org_repo != other_repo:
-                hgrepo = unionrepo.unionrepository(org_repo.baseui,
-                                                   org_repo.path,
-                                                   other_repo.path)
-                revs = ["ancestors(id('%s')) and not ancestors(id('%s'))" %
-                        (org_rev, other_rev)]
+                hgrepo = unionrepo.unionrepository(other_repo.baseui,
+                                                   other_repo.path,
+                                                   org_repo.path)
+                # all the changesets we are looking for will be in other_repo,
+                # so rev numbers from hgrepo can be used in other_repo
 
             #no remote compare do it on the same repository
             else:
-                hgrepo = org_repo._repo
-                revs = ["ancestors(id('%s')) and not ancestors(id('%s'))" %
-                        (other_rev, org_rev)]
+                hgrepo = other_repo._repo
 
+            revs = ["ancestors(id('%s')) and not ancestors(id('%s'))" %
+                    (other_rev, org_rev)]
             out = scmutil.revrange(hgrepo, revs)
             for cs in (out):
-                changesets.append(org_repo.get_changeset(cs))
+                changesets.append(other_repo.get_changeset(cs))
 
         elif alias == 'git':
             assert org_repo == other_repo, (org_repo, other_repo) # no git support for different repos
             so, se = org_repo.run_git_command(
                 '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 (ids):
                 changesets.append(org_repo.get_changeset(cs))
 
         return changesets
 
     def get_compare_data(self, org_repo, org_ref, other_repo, other_ref):
         """
         Returns incoming changesets 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
         cs_ranges = self._get_changesets(alias,
                                          org_repo_scm, org_ref,
                                          other_repo_scm, other_ref)
         return cs_ranges

rhodecode/templates/base/base.html

@@ -1,367 +1,367 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="root.html"/>
 
 <!-- HEADER -->
 <div id="header-dd"></div>
 <div id="header">
     <div id="header-inner" class="title">
         <div id="logo">
             <h1><a href="${h.url('home')}">${c.rhodecode_name}</a></h1>
         </div>
         <!-- MENU -->
         ${self.page_nav()}
         <!-- END MENU -->
         ${self.body()}
     </div>
 </div>
 <!-- END HEADER -->
 
 <!-- CONTENT -->
 <div id="content">
     <div class="flash_msg">
         <% messages = h.flash.pop_messages() %>
         % if messages:
         <ul id="flash-messages">
             % for message in messages:
             <li class="${message.category}_msg">${message}</li>
             % endfor
         </ul>
         % endif
     </div>
     <div id="main">
         ${next.main()}
     </div>
 </div>
 <!-- END CONTENT -->
 
 <!-- FOOTER -->
 <div id="footer">
    <div id="footer-inner" class="title">
        <div>
            <p class="footer-link">
                 <a href="${h.url('bugtracker')}">${_('Submit a bug')}</a>
            </p>
            <p class="footer-link-right">
                <a href="${h.url('rhodecode_official')}">RhodeCode${'-%s' % c.rhodecode_instanceid if c.rhodecode_instanceid else ''}</a>
                ${c.rhodecode_version} &copy; 2010-${h.datetime.today().year} by Marcin Kuzminski
            </p>
        </div>
    </div>
 </div>
 <!-- END FOOTER -->
 
 ### MAKO DEFS ###
 <%def name="page_nav()">
     ${self.menu()}
 </%def>
 
 <%def name="breadcrumbs()">
     <div class="breadcrumbs">
     ${self.breadcrumbs_links()}
     </div>
 </%def>
 
 <%def name="usermenu()">
     ## USER MENU
     <li>
       <a class="menu_link" id="quick_login_link">
           <span class="icon" style="padding:5px 5px 0px 5px">
              <img src="${h.gravatar_url(c.rhodecode_user.email,20)}" alt="avatar">
           </span>
           %if c.rhodecode_user.username != 'default':
             <span class="menu_link_user">${c.rhodecode_user.username}</span>
             %if c.unread_notifications != 0:
               <span class="menu_link_notifications">${c.unread_notifications}</span>
             %endif
           %else:
               <span>${_('Not logged in')}</span>
           %endif
       </a>
 
   <div class="user-menu">
       <div id="quick_login">
         %if c.rhodecode_user.username == 'default':
             <h4>${_('Login to your account')}</h4>
             ${h.form(h.url('login_home',came_from=h.url.current()))}
             <div class="form">
                 <div class="fields">
                     <div class="field">
                         <div class="label">
                             <label for="username">${_('Username')}:</label>
                         </div>
                         <div class="input">
                             ${h.text('username',class_='focus',size=40)}
                         </div>
 
                     </div>
                     <div class="field">
                         <div class="label">
                             <label for="password">${_('Password')}:</label>
                         </div>
                         <div class="input">
                             ${h.password('password',class_='focus',size=40)}
                         </div>
 
                     </div>
                     <div class="buttons">
                         <div class="password_forgoten">${h.link_to(_('Forgot password ?'),h.url('reset_password'))}</div>
                         <div class="register">
                         %if h.HasPermissionAny('hg.admin', 'hg.register.auto_activate', 'hg.register.manual_activate')():
                          ${h.link_to(_("Don't have an account ?"),h.url('register'))}
                         %endif
                         </div>
                         <div class="submit">
                             ${h.submit('sign_in',_('Log In'),class_="ui-btn xsmall")}
                         </div>
                     </div>
                 </div>
             </div>
             ${h.end_form()}
         %else:
             <div class="links_left">
                 <div class="full_name">${c.rhodecode_user.full_name_or_username}</div>
                 <div class="email">${c.rhodecode_user.email}</div>
                 <div class="big_gravatar"><img alt="gravatar" src="${h.gravatar_url(c.rhodecode_user.email,48)}" /></div>
                 <div class="notifications"><a href="${h.url('notifications')}">${_('Notifications')}</a></div>
                 <div class="unread"><a href="${h.url('notifications')}">${_('Unread')}: ${c.unread_notifications}</a></div>
             </div>
             <div class="links_right">
             <ol class="links">
               <li>${h.link_to(_(u'Home'),h.url('home'))}</li>
               <li>${h.link_to(_(u'Journal'),h.url('journal'))}</li>
               <li>${h.link_to(_(u'My account'),h.url('admin_settings_my_account'))}</li>
               <li class="logout">${h.link_to(_(u'Log Out'),h.url('logout_home'))}</li>
             </ol>
             </div>
         %endif
       </div>
   </div>
 
     </li>
 </%def>
 
 <%def name="menu(current=None)">
         <%
         def is_current(selected):
             if selected == current:
                 return h.literal('class="current"')
         %>
         <ul id="quick">
           <!-- repo switcher -->
           <li ${is_current('home')}>
               <a class="menu_link" id="repo_switcher" title="${_('Switch repository')}" href="${h.url('home')}">
               <span class="icon">
                   <img src="${h.url('/images/icons/database.png')}" alt="${_('Products')}" />
               </span>
               <span>${_('Repositories')}</span>
               </a>
               <ul id="repo_switcher_list" class="repo_switcher">
                   <li>
                       <a href="#">${_('loading...')}</a>
                   </li>
               </ul>
           </li>
         ## we render this menu only not for those pages
         %if current not in ['home','admin', 'search', 'journal']:
             ##REGULAR MENU
             <li ${is_current('summary')}>
                <a class="menu_link" title="${_('Summary page')}" href="${h.url('summary_home',repo_name=c.repo_name)}">
                <span class="icon">
                    <img src="${h.url('/images/icons/clipboard_16.png')}" alt="${_('Summary')}" />
                </span>
                <span>${_('Summary')}</span>
                </a>
             </li>
             <li ${is_current('changelog')}>
                <a class="menu_link" title="${_('Changeset list')}" href="${h.url('changelog_home',repo_name=c.repo_name)}">
                <span class="icon">
                    <img src="${h.url('/images/icons/time.png')}" alt="${_('Changelog')}" />
                </span>
                <span>${_('Changelog')}</span>
                </a>
             </li>
             <li ${is_current('switch_to')}>
                <a class="menu_link" id="branch_tag_switcher" title="${_('Switch to')}" href="#">
                <span class="icon">
                    <img src="${h.url('/images/icons/arrow_switch.png')}" alt="${_('Switch to')}" />
                </span>
                <span>${_('Switch to')}</span>
                </a>
                 <ul id="switch_to_list" class="switch_to">
                     <li><a href="#">${_('loading...')}</a></li>
                 </ul>
             </li>
             <li ${is_current('files')}>
                <a class="menu_link" title="${_('Show repository content')}" href="${h.url('files_home',repo_name=c.repo_name)}">
                <span class="icon">
                    <img src="${h.url('/images/icons/file.png')}" alt="${_('Files')}" />
                </span>
                <span>${_('Files')}</span>
                </a>
             </li>
             <li ${is_current('options')}>
                <a class="menu_link" title="${_('Options')}" href="#">
                <span class="icon">
                    <img src="${h.url('/images/icons/table_gear.png')}" alt="${_('Admin')}" />
                </span>
                <span>${_('Options')}</span>
                </a>
                <ul>
                %if h.HasRepoPermissionAll('repository.admin')(c.repo_name):
                  %if h.HasPermissionAll('hg.admin')('access settings on repository'):
                      <li>${h.link_to(_('repository settings'),h.url('edit_repo',repo_name=c.repo_name),class_='settings')}</li>
                  %else:
                      <li>${h.link_to(_('repository settings'),h.url('repo_settings_home',repo_name=c.repo_name),class_='settings')}</li>
                  %endif
                %endif
 
                 <li>${h.link_to(_('fork'),h.url('repo_fork_home',repo_name=c.repo_name),class_='fork')}</li>
                 %if h.is_hg(c.rhodecode_repo):
                  <li>${h.link_to(_('open new pull request'),h.url('pullrequest_home',repo_name=c.repo_name),class_='pull_request')}</li>
                 %endif
                 %if c.rhodecode_db_repo.fork:
-                 <li>${h.link_to(_('compare fork'),h.url('compare_url',repo_name=c.repo_name,org_ref_type='branch',org_ref=request.GET.get('branch') or 'default',other_repo=c.rhodecode_db_repo.fork.repo_name,other_ref_type='branch',other_ref='default'),class_='compare_request')}</li>
+                 <li>${h.link_to(_('compare fork'),h.url('compare_url',repo_name=c.rhodecode_db_repo.fork.repo_name,org_ref_type='branch',org_ref='default',other_repo=c.repo_name,other_ref_type='branch',other_ref=request.GET.get('branch') or 'default'),class_='compare_request')}</li>
                 %endif
                 <li>${h.link_to(_('lightweight changelog'),h.url('shortlog_home',repo_name=c.repo_name),class_='shortlog')}</li>
                 <li>${h.link_to(_('search'),h.url('search_repo',repo_name=c.repo_name),class_='search')}</li>
 
                 %if h.HasRepoPermissionAny('repository.write','repository.admin')(c.repo_name) and c.rhodecode_db_repo.enable_locking:
                   %if c.rhodecode_db_repo.locked[0]:
                     <li>${h.link_to(_('unlock'), h.url('toggle_locking',repo_name=c.repo_name),class_='locking_del')}</li>
                   %else:
                     <li>${h.link_to(_('lock'), h.url('toggle_locking',repo_name=c.repo_name),class_='locking_add')}</li>
                   %endif
                 %endif
 
                 % if h.HasPermissionAll('hg.admin')('access admin main page'):
                  <li>
                    ${h.link_to(_('admin'),h.url('admin_home'),class_='admin')}
                     <%def name="admin_menu()">
                     <ul>
                         <li>${h.link_to(_('admin journal'),h.url('admin_home'),class_='journal')}</li>
                         <li>${h.link_to(_('repositories'),h.url('repos'),class_='repos')}</li>
                         <li>${h.link_to(_('repositories groups'),h.url('repos_groups'),class_='repos_groups')}</li>
                         <li>${h.link_to(_('users'),h.url('users'),class_='users')}</li>
                         <li>${h.link_to(_('users groups'),h.url('users_groups'),class_='groups')}</li>
                         <li>${h.link_to(_('permissions'),h.url('edit_permission',id='default'),class_='permissions')}</li>
                         <li>${h.link_to(_('ldap'),h.url('ldap_home'),class_='ldap')}</li>
                         <li>${h.link_to(_('defaults'),h.url('defaults'),class_='defaults')}</li>
                         <li class="last">${h.link_to(_('settings'),h.url('admin_settings'),class_='settings')}</li>
                     </ul>
                     </%def>
                     ## ADMIN MENU
                     ${admin_menu()}
                  </li>
                 % endif
                </ul>
             </li>
             <li>
                 <a class="menu_link" title="${_('Followers')}" href="${h.url('repo_followers_home',repo_name=c.repo_name)}">
                 <span class="icon_short">
                     <img src="${h.url('/images/icons/heart.png')}" alt="${_('Followers')}" />
                 </span>
                 <span id="current_followers_count" class="short">${c.repository_followers}</span>
                 </a>
             </li>
             <li>
                 <a class="menu_link" title="${_('Forks')}" href="${h.url('repo_forks_home',repo_name=c.repo_name)}">
                 <span class="icon_short">
                     <img src="${h.url('/images/icons/arrow_divide.png')}" alt="${_('Forks')}" />
                 </span>
                 <span class="short">${c.repository_forks}</span>
                 </a>
             </li>
             <li>
                 <a class="menu_link" title="${_('Pull requests')}" href="${h.url('pullrequest_show_all',repo_name=c.repo_name)}">
                 <span class="icon_short">
                     <img src="${h.url('/images/icons/arrow_join.png')}" alt="${_('Pull requests')}" />
                 </span>
                 <span class="short">${c.repository_pull_requests}</span>
                 </a>
             </li>
             ${usermenu()}
             <script type="text/javascript">
                 YUE.on('branch_tag_switcher','mouseover',function(){
                    var loaded = YUD.hasClass('branch_tag_switcher','loaded');
                    if(!loaded){
                        YUD.addClass('branch_tag_switcher','loaded');
                        ypjax("${h.url('branch_tag_switcher',repo_name=c.repo_name)}",'switch_to_list',
                            function(o){},
                            function(o){YUD.removeClass('branch_tag_switcher','loaded');}
                            ,null);
                    }
                    return false;
                 });
             </script>
         %else:
             ##ROOT MENU
             %if c.rhodecode_user.username != 'default':
              <li ${is_current('journal')}>
                 <a class="menu_link" title="${_('Show recent activity')}"  href="${h.url('journal')}">
                 <span class="icon">
                     <img src="${h.url('/images/icons/book.png')}" alt="${_('Journal')}" />
                 </span>
                 <span>${_('Journal')}</span>
                 </a>
              </li>
             %else:
              <li ${is_current('journal')}>
                 <a class="menu_link" title="${_('Public journal')}"  href="${h.url('public_journal')}">
                 <span class="icon">
                     <img src="${h.url('/images/icons/book.png')}" alt="${_('Public journal')}" />
                 </span>
                 <span>${_('Public journal')}</span>
                 </a>
              </li>
             %endif
             <li ${is_current('search')}>
                 <a class="menu_link" title="${_('Search in repositories')}"  href="${h.url('search')}">
                 <span class="icon">
                     <img src="${h.url('/images/icons/search_16.png')}" alt="${_('Search')}" />
                 </span>
                 <span>${_('Search')}</span>
                 </a>
             </li>
             %if h.HasPermissionAll('hg.admin')('access admin main page'):
             <li ${is_current('admin')}>
                <a class="menu_link" title="${_('Admin')}" href="${h.url('admin_home')}">
                <span class="icon">
                    <img src="${h.url('/images/icons/cog_edit.png')}" alt="${_('Admin')}" />
                </span>
                <span>${_('Admin')}</span>
                </a>
                 ${admin_menu()}
             </li>
             %endif
             ${usermenu()}
         %endif
 <script type="text/javascript">
     YUE.on('repo_switcher','mouseover',function(){
       var target = 'q_filter_rs';
       var qfilter_activate = function(){
           var nodes = YUQ('ul#repo_switcher_list li a.repo_name');
           var func = function(node){
               return node.parentNode;
           }
           q_filter(target,nodes,func);
       }
 
       var loaded = YUD.hasClass('repo_switcher','loaded');
       if(!loaded){
          YUD.addClass('repo_switcher','loaded');
          ypjax("${h.url('repo_switcher')}",'repo_switcher_list',
              function(o){qfilter_activate();YUD.get(target).focus()},
              function(o){YUD.removeClass('repo_switcher','loaded');}
              ,null);
       }else{
          YUD.get(target).focus();
       }
       return false;
      });
 
      YUE.on('header-dd', 'click',function(e){
          YUD.addClass('header-inner', 'hover');
      });
 
 </script>
 </%def>

rhodecode/templates/changelog/changelog.html

@@ -1,306 +1,306 b''
 ## -*- coding: utf-8 -*-
 
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
 ${_('%s Changelog') % c.repo_name} - ${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;
     <% size = c.size if c.size <= c.total_cs else c.total_cs %>
     ${_('Changelog')} - ${ungettext('showing %d out of %d revision', 'showing %d out of %d revisions', size) % (size, c.total_cs)}
 </%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">
         % if c.pagination:
             <div id="graph">
                 <div id="graph_nodes">
                     <canvas id="graph_canvas"></canvas>
                 </div>
                 <div id="graph_content">
                     <div class="info_box" style="clear: both;padding: 10px 6px;vertical-align: right;text-align: right;">
                     <a href="#" class="ui-btn small" id="rev_range_container" style="display:none"></a>
                     <a href="#" class="ui-btn small" id="rev_range_clear" style="display:none">${_('Clear selection')}</a>
 
                     %if c.rhodecode_db_repo.fork:
-                        <a title="${_('compare fork with %s' % c.rhodecode_db_repo.fork.repo_name)}" href="${h.url('compare_url',repo_name=c.repo_name,org_ref_type='branch',org_ref=request.GET.get('branch') or 'default',other_repo=c.rhodecode_db_repo.fork.repo_name,other_ref_type='branch',other_ref='default')}" class="ui-btn small">${_('Compare fork with parent')}</a>
+                        <a title="${_('compare fork with %s' % c.rhodecode_db_repo.fork.repo_name)}" href="${h.url('compare_url',repo_name=c.rhodecode_db_repo.fork.repo_name,org_ref_type='branch',org_ref='default',other_repo=c.repo_name,other_ref_type='branch',other_ref=request.GET.get('branch') or 'default')}" class="ui-btn small">${_('Compare fork with parent')}</a>
                     %endif
                     %if h.is_hg(c.rhodecode_repo):
                     <a id="open_new_pr" href="${h.url('pullrequest_home',repo_name=c.repo_name)}" class="ui-btn small">${_('open new pull request')}</a>
                     %endif
                     </div>
                     <div class="container_header">
                         ${h.form(h.url.current(),method='get')}
                         <div class="info_box" style="float:left">
                           ${h.submit('set',_('Show'),class_="ui-btn")}
                           ${h.text('size',size=1,value=c.size)}
                           ${_('revisions')}
                         </div>
                         ${h.end_form()}
                     <div style="float:right">${h.select('branch_filter',c.branch_name,c.branch_filters)}</div>
                     </div>
 
                 %for cnt,cs in enumerate(c.pagination):
                     <div id="chg_${cnt+1}" class="container ${'tablerow%s' % (cnt%2)}">
                         <div class="left">
                             <div>
                             ${h.checkbox(cs.raw_id,class_="changeset_range")}
                             <span class="tooltip" title="${h.tooltip(h.age(cs.date))}"><a href="${h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id)}"><span class="changeset_id">${cs.revision}:<span class="changeset_hash">${h.short_id(cs.raw_id)}</span></span></a></span>
                             </div>
                             <div class="author">
                                 <div class="gravatar">
                                     <img alt="gravatar" src="${h.gravatar_url(h.email_or_none(cs.author),16)}"/>
                                 </div>
                                 <div title="${cs.author}" class="user">${h.shorter(h.person(cs.author),22)}</div>
                             </div>
                             <div class="date">${h.fmt_date(cs.date)}</div>
                         </div>
                         <div class="mid">
                             <div class="message">${h.urlify_commit(cs.message, c.repo_name,h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id))}</div>
                             <div class="expand"><span class="expandtext">&darr; ${_('show more')} &darr;</span></div>
                         </div>
                         <div class="right">
                                     <div class="changes">
                                         <div id="changed_total_${cs.raw_id}" style="float:right;" class="changed_total tooltip" title="${h.tooltip(_('Affected number of files, click to show more details'))}">${len(cs.affected_files)}</div>
                                         <div class="comments-container">
                                         %if len(c.comments.get(cs.raw_id,[])) > 0:
                                             <div class="comments-cnt" title="${('comments')}">
                                               <a href="${h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id,anchor='comment-%s' % c.comments[cs.raw_id][0].comment_id)}">
                                                <div class="comments-cnt">${len(c.comments[cs.raw_id])}</div>
                                                <img src="${h.url('/images/icons/comments.png')}">
                                               </a>
                                             </div>
                                         %endif
                                         </div>
                                         <div class="changeset-status-container">
                                             %if c.statuses.get(cs.raw_id):
                                               <div title="${_('Changeset status')}" class="changeset-status-lbl">${c.statuses.get(cs.raw_id)[1]}</div>
                                               <div class="changeset-status-ico">
                                               %if c.statuses.get(cs.raw_id)[2]:
                                                 <a class="tooltip" title="${_('Click to open associated pull request #%s' % c.statuses.get(cs.raw_id)[2])}" href="${h.url('pullrequest_show',repo_name=c.statuses.get(cs.raw_id)[3],pull_request_id=c.statuses.get(cs.raw_id)[2])}"><img src="${h.url('/images/icons/flag_status_%s.png' % c.statuses.get(cs.raw_id)[0])}" /></a>
                                               %else:
                                                 <img src="${h.url('/images/icons/flag_status_%s.png' % c.statuses.get(cs.raw_id)[0])}" />
                                               %endif
                                               </div>
                                             %endif
                                         </div>
                                     </div>
                                    %if cs.parents:
                                     %for p_cs in reversed(cs.parents):
                                         <div class="parent">${_('Parent')}
                                             <span class="changeset_id">${p_cs.revision}:<span class="changeset_hash">${h.link_to(h.short_id(p_cs.raw_id),
                                             h.url('changeset_home',repo_name=c.repo_name,revision=p_cs.raw_id),title=p_cs.message)}</span></span>
                                         </div>
                                     %endfor
                                    %else:
                                         <div class="parent">${_('No parents')}</div>
                                    %endif
 
                                 <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>
 
                 %endfor
                 <div class="pagination-wh pagination-left">
                     ${c.pagination.pager('$link_previous ~2~ $link_next')}
                 </div>
                 </div>
             </div>
 
             <script type="text/javascript" src="${h.url('/js/graph.js')}"></script>
             <script type="text/javascript">
                 YAHOO.util.Event.onDOMReady(function(){
 
                     //Monitor range checkboxes and build a link to changesets
                     //ranges
                     var checkboxes = YUD.getElementsByClassName('changeset_range');
                     var url_tmpl = "${h.url('changeset_home',repo_name=c.repo_name,revision='__REVRANGE__')}";
                     var pr_tmpl = "${h.url('pullrequest_home',repo_name=c.repo_name)}";
                     YUE.on(checkboxes,'click',function(e){
                         var clicked_cb = e.currentTarget;
                         var checked_checkboxes = [];
                         for (pos in checkboxes){
                             if(checkboxes[pos].checked){
                                 checked_checkboxes.push(checkboxes[pos]);
                             }
                         }
                         if(YUD.get('open_new_pr')){
                           if(checked_checkboxes.length>0){
                             // modify open pull request to show we have selected cs
                             YUD.get('open_new_pr').innerHTML = _TM['Open new pull request for selected changesets'];
 
                           }else{
                             YUD.get('open_new_pr').innerHTML = _TM['Open new pull request'];
                           }
                         }
 
                         if(checked_checkboxes.length>0){
                             var rev_end = checked_checkboxes[0].name;
                             var rev_start = checked_checkboxes[checked_checkboxes.length-1].name;
 
                             // now select all checkboxes in the middle.
                             var checked = false;
                             for (var i=0; i<checkboxes.length; i++){
                                 var cb = checkboxes[i];
                                 var rev = cb.name;
 
                                 if (rev == rev_end){
                                     checked = true;
                                 }
                                 if (checked){
                                     cb.checked = true;
                                 }
                                 else{
                                     cb.checked = false;
                                 }
                                 if (rev == rev_start){
                                     checked = false;
                                 }
 
                             }
 
                             var url = url_tmpl.replace('__REVRANGE__',
                                     rev_start+'...'+rev_end);
 
                             var link = _TM['Show selected changes __S -> __E'];
                             link = link.replace('__S',rev_start.substr(0,6));
                             link = link.replace('__E',rev_end.substr(0,6));
                             YUD.get('rev_range_container').href = url;
                             YUD.get('rev_range_container').innerHTML = link;
                             YUD.setStyle('rev_range_container','display','');
                             YUD.setStyle('rev_range_clear','display','');
 
                             YUD.get('open_new_pr').href = pr_tmpl + '?rev_start={0}&rev_end={1}'.format(rev_start,rev_end);
 
                         }
                         else{
                             YUD.setStyle('rev_range_container','display','none');
                             YUD.setStyle('rev_range_clear','display','none');
                         }
                     });
                     YUE.on('rev_range_clear','click',function(e){
                         for (var i=0; i<checkboxes.length; i++){
                             var cb = checkboxes[i];
                             cb.checked = false;
                         }
                         YUE.preventDefault(e);
                     })
                     var msgs = YUQ('.message');
                     // get first element height
                     var el = YUQ('#graph_content .container')[0];
                     var row_h = el.clientHeight;
                     for(var i=0;i<msgs.length;i++){
                         var m = msgs[i];
 
                         var h = m.clientHeight;
                         var pad = YUD.getStyle(m,'padding');
                         if(h > row_h){
                             var offset = row_h - (h+12);
                             YUD.setStyle(m.nextElementSibling,'display','block');
                             YUD.setStyle(m.nextElementSibling,'margin-top',offset+'px');
                         };
                     }
                     YUE.on(YUQ('.expand'),'click',function(e){
                         var elem = e.currentTarget.parentNode.parentNode;
                         YUD.setStyle(e.currentTarget,'display','none');
                         YUD.setStyle(elem,'height','auto');
 
                         //redraw the graph, line_count and jsdata are global vars
                         set_canvas(100);
 
                         var r = new BranchRenderer();
                         r.render(jsdata,100,line_count);
 
                     })
 
                     // Fetch changeset details
                     YUE.on(YUD.getElementsByClassName('changed_total'),'click',function(e){
                         var id = e.currentTarget.id;
                         var url = "${h.url('changelog_details',repo_name=c.repo_name,cs='__CS__')}";
                         var url = url.replace('__CS__',id.replace('changed_total_',''));
                         ypjax(url,id,function(){tooltip_activate()});
                     });
 
                     // change branch filter
                     YUE.on(YUD.get('branch_filter'),'change',function(e){
                         var selected_branch = e.currentTarget.options[e.currentTarget.selectedIndex].value;
                         var url_main = "${h.url('changelog_home',repo_name=c.repo_name)}";
                         var url = "${h.url('changelog_home',repo_name=c.repo_name,branch='__BRANCH__')}";
                         var url = url.replace('__BRANCH__',selected_branch);
                         if(selected_branch != ''){
                             window.location = url;
                         }else{
                             window.location = url_main;
                         }
 
                     });
 
                     function set_canvas(width) {
                         var c = document.getElementById('graph_nodes');
                         var t = document.getElementById('graph_content');
                         canvas = document.getElementById('graph_canvas');
                         var div_h = t.clientHeight;
                         c.style.height=div_h+'px';
                         canvas.setAttribute('height',div_h);
                         c.style.height=width+'px';
                         canvas.setAttribute('width',width);
                     };
                     var heads = 1;
                     var line_count = 0;
                     var jsdata = ${c.jsdata|n};
 
                     for (var i=0;i<jsdata.length;i++) {
                         var in_l = jsdata[i][2];
                         for (var j in in_l) {
                             var m = in_l[j][1];
                             if (m > line_count)
                                 line_count = m;
                         }
                     }
                     set_canvas(100);
 
                     var r = new BranchRenderer();
                     r.render(jsdata,100,line_count);
 
                 });
             </script>
         %else:
             ${_('There are no changes yet')}
         %endif
     </div>
 </div>
 </%def>

rhodecode/templates/forks/forks_data.html

@@ -1,43 +1,43 b''
 ## -*- coding: utf-8 -*-
 
 % if c.forks_pager:
     % for f in c.forks_pager:
         <div>
             <div class="fork_user">
                 <div class="gravatar">
                     <img alt="gravatar" src="${h.gravatar_url(f.user.email,24)}"/>
                 </div>
                 <span style="font-size: 20px">
                  <b>${f.user.username}</b> (${f.user.name} ${f.user.lastname}) /
                   ${h.link_to(f.repo_name,h.url('summary_home',repo_name=f.repo_name))}
                 </span>
                 <div style="padding:5px 3px 3px 42px;">${f.description}</div>
             </div>
             <div style="clear:both;padding-top: 10px"></div>
             <div class="follower_date">${_('forked')} -
                 <span class="tooltip" title="${h.tooltip(h.fmt_date(f.created_on))}"> ${h.age(f.created_on)}</span>
                 <a title="${_('compare fork with %s' % c.repo_name)}"
-                    href="${h.url('compare_url',repo_name=f.repo_name,org_ref_type='branch',org_ref='default',other_repo=c.repo_name,other_ref_type='branch',other_ref='default')}"
+                    href="${h.url('compare_url',repo_name=c.repo_name,org_ref_type='branch',org_ref='default',other_repo=f.repo_name,other_ref_type='branch',other_ref='default')}"
                     class="ui-btn small">${_('Compare fork')}</a>
             </div>
             <div style="border-bottom: 1px solid #DDD;margin:10px 0px 10px 0px"></div>
         </div>
     % endfor
   <div class="pagination-wh pagination-left">
   <script type="text/javascript">
   YUE.onDOMReady(function(){
       YUE.delegate("forks","click",function(e, matchedEl, container){
           ypjax(e.target.href,"forks",function(){
               show_more_event();
               tooltip_activate();
               show_changeset_tooltip();
           });
           YUE.preventDefault(e);
       },'.pager_link');
   });
   </script>
   ${c.forks_pager.pager('$link_previous ~2~ $link_next')}
   </div>
 % else:
     ${_('There are no forks yet')}
 % endif

rhodecode/templates/pullrequests/pullrequest.html

@@ -1,199 +1,199 b''
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${c.repo_name} ${_('New pull request')}
 </%def>
 
 <%def name="breadcrumbs_links()">
     ${h.link_to(_(u'Home'),h.url('/'))}
     &raquo;
     ${h.link_to(c.repo_name,h.url('changelog_home',repo_name=c.repo_name))}
     &raquo;
     ${_('New pull request')}
 </%def>
 
 <%def name="main()">
 
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     ${h.form(url('pullrequest', repo_name=c.repo_name), method='post', id='pull_request_form')}
     <div style="float:left;padding:0px 30px 30px 30px">
         <input type="hidden" name="rev_start" value="${request.GET.get('rev_start')}" />
         <input type="hidden" name="rev_end" value="${request.GET.get('rev_end')}" />
 
         ##ORG
         <div style="float:left">
             <div class="fork_user">
                 <div class="gravatar">
                     <img alt="gravatar" src="${h.gravatar_url(c.rhodecode_db_repo.user.email,24)}"/>
                 </div>
                 <span style="font-size: 20px">
                 ${h.select('org_repo','',c.org_repos,class_='refs')}:${h.select('org_ref','',c.org_refs,class_='refs')}
                 </span>
                  <div style="padding:5px 3px 3px 42px;">${c.rhodecode_db_repo.description}</div>
             </div>
             <div style="clear:both;padding-top: 10px"></div>
         </div>
           <div style="float:left;font-size:24px;padding:0px 20px">
           <img height=32 width=32 src="${h.url('/images/arrow_right_64.png')}"/>
           </div>
 
         ##OTHER, most Probably the PARENT OF THIS FORK
         <div style="float:left">
             <div class="fork_user">
                 <div class="gravatar">
                     <img id="other_repo_gravatar" alt="gravatar" src=""/>
                 </div>
                 <span style="font-size: 20px">
                 ${h.select('other_repo',c.default_pull_request ,c.other_repos,class_='refs')}:${h.select('other_ref',c.default_pull_request_rev,c.default_revs,class_='refs')}
                 </span>
          <span style="padding:3px">
            <a id="refresh" href="#" class="tooltip" title="${h.tooltip(_('refresh overview'))}">
              <img style="margin:3px" class="icon" title="${_('Refresh')}" alt="${_('Refresh')}" src="${h.url('/images/icons/arrow_refresh.png')}"/>
            </a>
          </span>
                  <div id="other_repo_desc" style="padding:5px 3px 3px 42px;"></div>
             </div>
             <div style="clear:both;padding-top: 10px"></div>
         </div>
        <div style="clear:both;padding-top: 10px"></div>
        ## overview pulled by ajax
        <div style="float:left" id="pull_request_overview"></div>
        <div style="float:left;clear:both;padding:10px 10px 10px 0px;display:none">
             <a id="pull_request_overview_url" href="#">${_('Detailed compare view')}</a>
        </div>
      </div>
     <div style="float:left; border-left:1px dashed #eee">
         <h4>${_('Pull request reviewers')}</h4>
         <div id="reviewers" style="padding:0px 0px 0px 15px">
           ## members goes here !
           <div class="group_members_wrap">
             <ul id="review_members" class="group_members">
             %for member in c.review_members:
               <li id="reviewer_${member.user_id}">
                 <div class="reviewers_member">
                   <div class="gravatar"><img alt="gravatar" src="${h.gravatar_url(member.email,14)}"/> </div>
                   <div style="float:left">${member.full_name} (${_('owner')})</div>
                   <input type="hidden" value="${member.user_id}" name="review_members" />
                   <span class="delete_icon action_button" onclick="removeReviewer(${member.user_id})"></span>
                 </div>
               </li>
             %endfor
             </ul>
           </div>
 
           <div class='ac'>
             <div class="reviewer_ac">
                ${h.text('user', class_='yui-ac-input')}
                <span class="help-block">${_('Add reviewer to this pull request.')}</span>
                <div id="reviewers_container"></div>
             </div>
           </div>
         </div>
     </div>
     <h3>${_('Create new pull request')}</h3>
 
     <div class="form">
         <!-- fields -->
 
         <div class="fields">
 
              <div class="field">
                 <div class="label">
                     <label for="pullrequest_title">${_('Title')}:</label>
                 </div>
                 <div class="input">
                     ${h.text('pullrequest_title',size=30)}
                 </div>
              </div>
 
             <div class="field">
                 <div class="label label-textarea">
                     <label for="pullrequest_desc">${_('description')}:</label>
                 </div>
                 <div class="textarea text-area editor">
                     ${h.textarea('pullrequest_desc',size=30)}
                 </div>
             </div>
 
             <div class="buttons">
                 ${h.submit('save',_('Send pull request'),class_="ui-btn large")}
                 ${h.reset('reset',_('Reset'),class_="ui-btn large")}
            </div>
         </div>
     </div>
     ${h.end_form()}
 
 </div>
 
 <script type="text/javascript">
   var _USERS_AC_DATA = ${c.users_array|n};
   var _GROUPS_AC_DATA = ${c.users_groups_array|n};
   PullRequestAutoComplete('user', 'reviewers_container', _USERS_AC_DATA, _GROUPS_AC_DATA);
 
   var other_repos_info = ${c.other_repos_info|n};
 
   var loadPreview = function(){
       YUD.setStyle(YUD.get('pull_request_overview_url').parentElement,'display','none');
       //url template
       var url = "${h.url('compare_url',
-                         repo_name='__org_repo__',
-                         org_ref_type='__org_ref_type__',
-                         org_ref='__org_ref__',
-                         other_repo='__other_repo__',
-                         other_ref_type='__other_ref_type__',
-                         other_ref='__other_ref__',
+                         repo_name='__other_repo__',
+                         org_ref_type='__other_ref_type__',
+                         org_ref='__other_ref__',
+                         other_repo='__org_repo__',
+                         other_ref_type='__org_ref_type__',
+                         other_ref='__org_ref__',
                          as_form=True,
                          rev_start=request.GET.get('rev_start',''),
                          rev_end=request.GET.get('rev_end',''))}";
       var org_repo = YUQ('#pull_request_form #org_repo')[0].value;
       var org_ref = YUQ('#pull_request_form #org_ref')[0].value.split(':');
       
       var other_repo = YUQ('#pull_request_form #other_repo')[0].value;
       var other_ref = YUQ('#pull_request_form #other_ref')[0].value.split(':');
       
       var select_refs = YUQ('#pull_request_form select.refs')
       var rev_data = {
     	  'org_repo': org_repo,
     	  'org_ref': org_ref[1],
     	  'org_ref_type': org_ref[0],
     	  'other_repo': other_repo,
           'other_ref': other_ref[1],
           'other_ref_type': other_ref[0],    	  
       }; // gather the org/other ref and repo here
       
       for (k in rev_data){
     	  url = url.replace('__'+k+'__',rev_data[k]);
       }
 
       YUE.on('other_repo', 'change', function(e){
           var repo_name = e.currentTarget.value;
           // replace the <select> of changed repo
           YUD.get('other_ref').innerHTML = other_repos_info[repo_name]['revs'];
       });
 
       ypjax(url,'pull_request_overview', function(data){
           var sel_box = YUQ('#pull_request_form #other_repo')[0];
           var repo_name = sel_box.options[sel_box.selectedIndex].value;
           YUD.get('pull_request_overview_url').href = url;
           YUD.setStyle(YUD.get('pull_request_overview_url').parentElement,'display','');
           YUD.get('other_repo_gravatar').src = other_repos_info[repo_name]['gravatar'];
           YUD.get('other_repo_desc').innerHTML = other_repos_info[repo_name]['description'];
           YUD.get('other_ref').innerHTML = other_repos_info[repo_name]['revs'];
           // select back the revision that was just compared
           setSelectValue(YUD.get('other_ref'), rev_data['other_ref']);
       })
   }
   YUE.on('refresh','click',function(e){
      loadPreview()
   })
 
   //lazy load overview after 0.5s
   setTimeout(loadPreview, 500)
 
 </script>
 
 </%def>

rhodecode/tests/functional/test_compare.py

@@ -1,348 +1,348 b''
 from rhodecode.tests import *
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.meta import Session
 from rhodecode.model.db import Repository
 from rhodecode.model.scm import ScmModel
 from rhodecode.lib.vcs.backends.base import EmptyChangeset
 
 
 def _fork_repo(fork_name, vcs_type, parent=None):
     if vcs_type =='hg':
         _REPO = HG_REPO
     elif vcs_type == 'git':
         _REPO = GIT_REPO
 
     if parent:
         _REPO = parent
 
     form_data = dict(
         repo_name=fork_name,
         repo_name_full=fork_name,
         repo_group=None,
         repo_type=vcs_type,
         description='',
         private=False,
         copy_permissions=False,
         landing_rev='tip',
         update_after_clone=False,
         fork_parent_id=Repository.get_by_repo_name(_REPO),
     )
     repo = RepoModel().create_fork(form_data, cur_user=TEST_USER_ADMIN_LOGIN)
 
     Session().commit()
     return Repository.get_by_repo_name(fork_name)
 
 
 def _commit_change(repo, filename, content, message, vcs_type, parent=None, newfile=False):
     repo = Repository.get_by_repo_name(repo)
     _cs = parent
     if not parent:
         _cs = EmptyChangeset(alias=vcs_type)
 
     if newfile:
         cs = ScmModel().create_node(
             repo=repo.scm_instance, repo_name=repo.repo_name,
             cs=_cs, user=TEST_USER_ADMIN_LOGIN,
             author=TEST_USER_ADMIN_LOGIN,
             message=message,
             content=content,
             f_path=filename
         )
     else:
         cs = ScmModel().commit_change(
             repo=repo.scm_instance, repo_name=repo.repo_name,
             cs=parent, user=TEST_USER_ADMIN_LOGIN,
             author=TEST_USER_ADMIN_LOGIN,
             message=message,
             content=content,
             f_path=filename
         )
     return cs
 
 
 class TestCompareController(TestController):
 
     def test_compare_forks_on_branch_extra_commits_hg(self):
         self.log_user()
 
         repo1 = RepoModel().create_repo(repo_name='one', repo_type='hg',
                                         description='diff-test',
                                         owner=TEST_USER_ADMIN_LOGIN)
         r1_id = repo1.repo_id
         Session().commit()
         #commit something !
         cs0 = _commit_change(repo1.repo_name, filename='file1', content='line1\n',
                              message='commit1', vcs_type='hg', parent=None, newfile=True)
 
         #fork this repo
         repo2 = _fork_repo('one-fork', 'hg', parent='one')
         Session().commit()
         r2_id = repo2.repo_id
 
         #add two extra commit into fork
         cs1 = _commit_change(repo2.repo_name, filename='file1', content='line1\nline2\n',
                              message='commit2', vcs_type='hg', parent=cs0)
 
         cs2 = _commit_change(repo2.repo_name, filename='file1', content='line1\nline2\nline3\n',
                              message='commit3', vcs_type='hg', parent=cs1)
 
         rev1 = 'default'
         rev2 = 'default'
         response = self.app.get(url(controller='compare', action='index',
-                                    repo_name=repo2.repo_name,
+                                    repo_name=repo1.repo_name,
                                     org_ref_type="branch",
-                                    org_ref=rev1,
-                                    other_repo=repo1.repo_name,
+                                    org_ref=rev2,
+                                    other_repo=repo2.repo_name,
                                     other_ref_type="branch",
-                                    other_ref=rev2,
+                                    other_ref=rev1,
                                     ))
 
         try:
-            response.mustcontain('%s@%s -> %s@%s' % (repo2.repo_name, rev1, repo1.repo_name, rev2))
+            response.mustcontain('%s@%s -> %s@%s' % (repo1.repo_name, rev2, repo2.repo_name, rev1))
             response.mustcontain("""Showing 2 commits""")
             response.mustcontain("""1 file changed with 2 insertions and 0 deletions""")
 
             response.mustcontain("""<div class="message tooltip" title="commit2" style="white-space:normal">commit2</div>""")
             response.mustcontain("""<div class="message tooltip" title="commit3" style="white-space:normal">commit3</div>""")
 
             response.mustcontain("""<a href="/%s/changeset/%s">r1:%s</a>""" % (repo2.repo_name, cs1.raw_id, cs1.short_id))
             response.mustcontain("""<a href="/%s/changeset/%s">r2:%s</a>""" % (repo2.repo_name, cs2.raw_id, cs2.short_id))
             ## files
-            response.mustcontain("""<a href="/%s/compare/branch@%s...branch@%s?other_repo=%s#C--826e8142e6ba">file1</a>""" % (repo2.repo_name, rev1, rev2, repo1.repo_name))
+            response.mustcontain("""<a href="/%s/compare/branch@%s...branch@%s?other_repo=%s#C--826e8142e6ba">file1</a>""" % (repo1.repo_name, rev2, rev1, repo2.repo_name))
             #swap
-            response.mustcontain("""<a href="/%s/compare/branch@%s...branch@%s?as_form=None&amp;other_repo=%s">[swap]</a>""" % (repo1.repo_name, rev1, rev2, repo2.repo_name))
+            response.mustcontain("""<a href="/%s/compare/branch@%s...branch@%s?as_form=None&amp;other_repo=%s">[swap]</a>""" % (repo2.repo_name, rev1, rev2, repo1.repo_name))
         finally:
             RepoModel().delete(r2_id)
             RepoModel().delete(r1_id)
 
     def test_compare_forks_on_branch_extra_commits_origin_has_incomming_hg(self):
         self.log_user()
 
         repo1 = RepoModel().create_repo(repo_name='one', repo_type='hg',
                                         description='diff-test',
                                         owner=TEST_USER_ADMIN_LOGIN)
         r1_id = repo1.repo_id
         Session().commit()
         #commit something !
         cs0 = _commit_change(repo1.repo_name, filename='file1', content='line1\n',
                              message='commit1', vcs_type='hg', parent=None, newfile=True)
 
         #fork this repo
         repo2 = _fork_repo('one-fork', 'hg', parent='one')
         Session().commit()
 
         #now commit something to origin repo
         cs1_prim = _commit_change(repo1.repo_name, filename='file2', content='line1file2\n',
                                   message='commit2', vcs_type='hg', parent=cs0, newfile=True)
 
         r2_id = repo2.repo_id
 
         #add two extra commit into fork
         cs1 = _commit_change(repo2.repo_name, filename='file1', content='line1\nline2\n',
                              message='commit2', vcs_type='hg', parent=cs0)
 
         cs2 = _commit_change(repo2.repo_name, filename='file1', content='line1\nline2\nline3\n',
                              message='commit3', vcs_type='hg', parent=cs1)
 
         rev1 = 'default'
         rev2 = 'default'
         response = self.app.get(url(controller='compare', action='index',
-                                    repo_name=repo2.repo_name,
+                                    repo_name=repo1.repo_name,
                                     org_ref_type="branch",
-                                    org_ref=rev1,
-                                    other_repo=repo1.repo_name,
+                                    org_ref=rev2,
+                                    other_repo=repo2.repo_name,
                                     other_ref_type="branch",
-                                    other_ref=rev2,
+                                    other_ref=rev1,
                                     ))
 
         try:
-            response.mustcontain('%s@%s -&gt; %s@%s' % (repo2.repo_name, rev1, repo1.repo_name, rev2))
+            response.mustcontain('%s@%s -&gt; %s@%s' % (repo1.repo_name, rev2, repo2.repo_name, rev1))
             response.mustcontain("""Showing 2 commits""")
             response.mustcontain("""1 file changed with 2 insertions and 0 deletions""")
 
             response.mustcontain("""<div class="message tooltip" title="commit2" style="white-space:normal">commit2</div>""")
             response.mustcontain("""<div class="message tooltip" title="commit3" style="white-space:normal">commit3</div>""")
 
             response.mustcontain("""<a href="/%s/changeset/%s">r1:%s</a>""" % (repo2.repo_name, cs1.raw_id, cs1.short_id))
             response.mustcontain("""<a href="/%s/changeset/%s">r2:%s</a>""" % (repo2.repo_name, cs2.raw_id, cs2.short_id))
             ## files
-            response.mustcontain("""<a href="/%s/compare/branch@%s...branch@%s?other_repo=%s#C--826e8142e6ba">file1</a>""" % (repo2.repo_name, rev1, rev2, repo1.repo_name))
+            response.mustcontain("""<a href="/%s/compare/branch@%s...branch@%s?other_repo=%s#C--826e8142e6ba">file1</a>""" % (repo1.repo_name, rev2, rev1, repo2.repo_name))
             #swap
-            response.mustcontain("""<a href="/%s/compare/branch@%s...branch@%s?as_form=None&amp;other_repo=%s">[swap]</a>""" % (repo1.repo_name, rev1, rev2, repo2.repo_name))
+            response.mustcontain("""<a href="/%s/compare/branch@%s...branch@%s?as_form=None&amp;other_repo=%s">[swap]</a>""" % (repo2.repo_name, rev1, rev2, repo1.repo_name))
         finally:
             RepoModel().delete(r2_id)
             RepoModel().delete(r1_id)
 
 
 #    def test_compare_remote_repos_remote_flag_off(self):
 #        self.log_user()
 #        _fork_repo(HG_FORK, 'hg')
 #
 #        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 -&gt; %s@%s' % (HG_REPO, rev1, HG_FORK, rev2))
 #            ## outgoing changesets between those revisions
 #
 #            response.mustcontain("""<a href="/%s/changeset/2dda4e345facb0ccff1a191052dd1606dba6781d">r4:2dda4e345fac</a>""" % (HG_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_branches_hg(self):
 #        self.log_user()
 #
 #        _fork_repo(HG_FORK, 'hg')
 #
 #        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 -&gt; %s@%s' % (HG_REPO, rev1, HG_FORK, rev2))
 #            ## outgoing changesets between those revisions
 #
 #            response.mustcontain("""<a href="/%s/changeset/2dda4e345facb0ccff1a191052dd1606dba6781d">r4:2dda4e345fac</a>""" % (HG_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_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 -&gt; %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
 #                                        ))
 #
 #            response.mustcontain('%s@%s -&gt; %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)