Use changelog controller for displaying history of files.

step 1 for removing obsolete shortlog

rhodecode/config/routing.py

@@ -1,679 +1,679 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 Exception:
             pass
 
         return is_valid_repo(repo_name, config['base_path'])
 
     def check_group(environ, match_dict):
         """
         check for valid repository 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_group_skip_path(environ, match_dict):
         """
         check for valid repository group for proper 404 handling, but skips
         verification of existing path
 
         :param environ:
         :param match_dict:
         """
         repos_group_name = match_dict.get('group_name')
         return is_valid_repos_group(repos_group_name, config['base_path'],
                                     skip_path_check=True)
 
     def check_user_group(environ, match_dict):
         """
         check for valid user group for proper 404 handling
 
         :param environ:
         :param match_dict:
         """
         return True
 
     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", "/create_repository",
                   action="create_repository", 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))
         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))
         #add repo perm member
         m.connect('set_repo_perm_member',
                   "/repos/{repo_name:.*?}/grant_perm",
                   action="set_repo_perm_member",
                   conditions=dict(method=["POST"], function=check_repo))
 
         #ajax delete repo perm user
         m.connect('delete_repo_perm_member',
                   "/repos/{repo_name:.*?}/revoke_perm",
                   action="delete_repo_perm_member",
                   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))
         m.connect('toggle_locking', "/locking_toggle/{repo_name:.*?}",
                   action="toggle_locking", conditions=dict(method=["GET"],
                                                       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))
         #add repo group perm member
         m.connect('set_repo_group_perm_member',
                   "/repos_groups/{group_name:.*?}/grant_perm",
                   action="set_repo_group_perm_member",
                   conditions=dict(method=["POST"], function=check_group))
 
         #ajax delete repo group perm
         m.connect('delete_repo_group_perm_member',
                   "/repos_groups/{group_name:.*?}/revoke_perm",
                   action="delete_repo_group_perm_member",
                   conditions=dict(method=["DELETE"], function=check_group))
 
         m.connect("delete_repos_group", "/repos_groups/{group_name:.*?}",
                   action="delete", conditions=dict(method=["DELETE"],
                                                    function=check_group_skip_path))
         m.connect("edit_repos_group", "/repos_groups/{group_name:.*?}/edit",
                   action="edit", conditions=dict(method=["GET"],
                                                  function=check_group))
         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))
 
     #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 USER 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"]),
                   function=check_user_group)
         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
         # update
         m.connect("users_group_perm", "/users_groups/{id}/update_global_perm",
                   action="update_perm", conditions=dict(method=["PUT"]))
 
         #add user group perm member
         m.connect('set_user_group_perm_member', "/users_groups/{id}/grant_perm",
              action="set_user_group_perm_member",
              conditions=dict(method=["POST"]))
 
         #ajax delete user group perm
         m.connect('delete_user_group_perm_member', "/users_groups/{id}/revoke_perm",
              action="delete_user_group_perm_member",
              conditions=dict(method=["DELETE"]))
 
     #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_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))
 
     # no longer user, but kept for routes to work
     rmap.connect("_edit_repo", "/{repo_name:.*?}/edit",
                  controller='admin/repos', action="edit",
                  conditions=dict(method=["GET"], function=check_repo)
                  )
 
     rmap.connect("edit_repo", "/{repo_name:.*?}/settings",
                  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_preview',
                  '/{repo_name:.*?}/changeset/comment/preview',
                 controller='changeset', action='preview_comment',
                 conditions=dict(function=check_repo, method=["POST"]))
 
     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|__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_file_home', '/{repo_name:.*?}/changelog/{revision}/{f_path:.*}',
+                controller='changelog', f_path=None,
+                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_home_nopath', '/{repo_name:.*?}/files/{revision}',
                 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_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/changelog.py

@@ -1,122 +1,142 b''
 # -*- coding: utf-8 -*-
 """
     rhodecode.controllers.changelog
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
     changelog controller for rhodecode
 
     :created_on: Apr 21, 2010
     :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 pylons import request, url, session, tmpl_context as c
 from pylons.controllers.util import redirect
 from pylons.i18n.translation import _
 
 import rhodecode.lib.helpers as h
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.helpers import RepoPage
 from rhodecode.lib.compat import json
 from rhodecode.lib.graphmod import _colored, _dagwalker
-from rhodecode.lib.vcs.exceptions import RepositoryError, ChangesetDoesNotExistError
+from rhodecode.lib.vcs.exceptions import RepositoryError, ChangesetDoesNotExistError,\
+    ChangesetError, NodeDoesNotExistError
 from rhodecode.lib.utils2 import safe_int
 
 log = logging.getLogger(__name__)
 
 
 class ChangelogController(BaseRepoController):
 
     def __before__(self):
         super(ChangelogController, self).__before__()
         c.affected_files_cut_off = 60
 
     def _graph(self, repo, revs_int, repo_size, size, p):
         """
         Generates a DAG graph for repo
 
         :param repo:
         :param revs_int:
         :param repo_size:
         :param size:
         :param p:
         """
         if not revs_int:
             c.jsdata = json.dumps([])
             return
 
         data = []
         revs = revs_int
 
         dag = _dagwalker(repo, revs, repo.alias)
         dag = _colored(dag)
         for (id, type, ctx, vtx, edges) in dag:
             data.append(['', vtx, edges])
 
         c.jsdata = json.dumps(data)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
-    def index(self):
+    def index(self, repo_name, revision=None, f_path=None):
         limit = 100
         default = 20
         if request.GET.get('size'):
             c.size = max(min(safe_int(request.GET.get('size')), limit), 1)
             session['changelog_size'] = c.size
             session.save()
         else:
             c.size = int(session.get('changelog_size', default))
         # min size must be 1
         c.size = max(c.size, 1)
         p = safe_int(request.GET.get('page', 1), 1)
         branch_name = request.GET.get('branch', None)
+        c.changelog_for_path = f_path
         try:
+
+            if f_path:
+                log.debug('generating changelog for path %s' % f_path)
+                # get the history for the file !
+                tip_cs = c.rhodecode_repo.get_changeset()
+                try:
+                    collection = tip_cs.get_file_history(f_path)
+                except (NodeDoesNotExistError, ChangesetError):
+                    #this node is not present at tip !
+                    try:
+                        cs = self.__get_cs_or_redirect(revision, repo_name)
+                        collection = cs.get_file_history(f_path)
+                    except RepositoryError, e:
+                        h.flash(str(e), category='warning')
+                        redirect(h.url('changelog_home', repo_name=repo_name))
+                collection = list(reversed(collection))
+            else:
             collection = c.rhodecode_repo.get_changesets(start=0,
                                                     branch_name=branch_name)
             c.total_cs = len(collection)
 
             c.pagination = RepoPage(collection, page=p, item_count=c.total_cs,
                                     items_per_page=c.size, branch=branch_name)
             collection = list(c.pagination)
             page_revisions = [x.raw_id for x in c.pagination]
             c.comments = c.rhodecode_db_repo.get_comments(page_revisions)
             c.statuses = c.rhodecode_db_repo.statuses(page_revisions)
         except (RepositoryError, ChangesetDoesNotExistError, Exception), e:
             log.error(traceback.format_exc())
             h.flash(str(e), category='error')
             return redirect(url('changelog_home', repo_name=c.repo_name))
 
         c.branch_name = branch_name
         c.branch_filters = [('', _('All Branches'))] + \
             [(k, k) for k in c.rhodecode_repo.branches.keys()]
-
-        self._graph(c.rhodecode_repo, [x.revision for x in c.pagination],
-                    c.total_cs, c.size, p)
+        _revs = []
+        if not f_path:
+            _revs = [x.revision for x in c.pagination]
+        self._graph(c.rhodecode_repo, _revs, c.total_cs, c.size, p)
 
         return render('changelog/changelog.html')
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def changelog_details(self, cs):
         if request.environ.get('HTTP_X_PARTIAL_XHR'):
             c.cs = c.rhodecode_repo.get_changeset(cs)
             return render('changelog/changelog_details.html')

rhodecode/templates/changelog/changelog.html

@@ -1,274 +1,280 b''
 ## -*- coding: utf-8 -*-
 
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
 ${_('%s Changelog') % c.repo_name} &middot; ${c.rhodecode_name}
 </%def>
 
 <%def name="breadcrumbs_links()">
     <% 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('repositories')}
 </%def>
 
 <%def name="main()">
 ${self.context_bar('changelog')}
 <div class="box">
     <!-- box / title -->
     <div class="title">
         ${self.breadcrumbs()}
     </div>
     <div class="table">
         % if c.pagination:
             <div id="graph">
+                <div style="display:${'none' if c.changelog_for_path else ''}">
                 <div class="info_box" style="clear: both;padding: 10px 6px;min-height: 12px;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 id="compare_fork" 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',merge=1)}" 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 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>
+                </div>
                 <div id="graph_nodes">
                     <canvas id="graph_canvas"></canvas>
                 </div>
                 <div id="graph_content">
 
                 <table id="changesets">
                 <tbody>
                 %for cnt,cs in enumerate(c.pagination):
                     <tr id="chg_${cnt+1}" class="container ${'tablerow%s' % (cnt%2)}">
                         <td class="checkbox">
+                            %if c.changelog_for_path:
+                                ${h.checkbox(cs.raw_id,class_="changeset_range", disabled="disabled")}
+                            %else:
                             ${h.checkbox(cs.raw_id,class_="changeset_range")}
+                            %endif
                         <td class="status">
                           %if c.statuses.get(cs.raw_id):
                             <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
                         </td>
                         <td class="author">
                             <img alt="gravatar" src="${h.gravatar_url(h.email_or_none(cs.author),16)}"/>
                             <span title="${cs.author}" class="user">${h.shorter(h.person(cs.author),22)}</span>
                         </td>
                         <td class="hash" style="width:${len(h.show_id(cs))*6.5}px">
                             <a href="${h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id)}">
                                 <span class="changeset_hash">${h.show_id(cs)}</span>
                             </a>
                         </td>
                         <td class="date">
                             <div class="date">${h.age(cs.date,True)}</div>
                         </td>
                         <td class="mid">
                             <div class="log-container">
                                 <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 class="extra-container">
                                     %if c.comments.get(cs.raw_id,[]):
                                         <div class="comments-container">
                                             <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)}">
                                                     ${len(c.comments[cs.raw_id])}
                                                 </a>
                                             </div>
                                         </div>
                                     %endif
                                     %if h.is_hg(c.rhodecode_repo):
                                         %for book in cs.bookmarks:
                                             <div class="booktag" title="${_('Bookmark %s') % book}">
                                                 ${h.link_to(h.shorter(book),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}
                                             </div>
                                         %endfor
                                     %endif
                                     %for tag in cs.tags:
                                         <div class="tagtag" title="${_('Tag %s') % tag}">
                                             ${h.link_to(h.shorter(tag),h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id))}
                                         </div>
                                     %endfor
                                     %if (not c.branch_name) and cs.branch:
                                         <div class="branchtag" title="${_('Branch %s' % cs.branch)}">
                                             ${h.link_to(h.shorter(cs.branch),h.url('changelog_home',repo_name=c.repo_name,branch=cs.branch))}
                                         </div>
                                     %endif
                                 </div>
                             </div>
                         </td>
                     </tr>
                 %endfor
                 </tbody>
                 </table>
 
                 <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)}";
 
                 var checkbox_checker = function(e){
                     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>1){
                             YUD.setStyle('open_new_pr','display','none');
                         } else {
                             YUD.setStyle('open_new_pr','display','');
                             if(checked_checkboxes.length>0){
                                 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;
                         var url = url_tmpl.replace('__REVRANGE__',
                                 rev_start+'...'+rev_end);
 
                         var link = (rev_start == rev_end)
                             ? _TM['Show selected changeset __S']
                             : _TM['Show selected changesets __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);
                         YUD.setStyle('compare_fork','display','none');
                     }else{
                         YUD.setStyle('rev_range_container','display','none');
                         YUD.setStyle('rev_range_clear','display','none');
                         if (checkboxes){
                             YUD.get('open_new_pr').href = pr_tmpl + '?rev_end={0}'.format(checkboxes[0].name);
                         }
                         YUD.setStyle('compare_fork','display','');
                     }
                 };
                 YUE.onDOMReady(checkbox_checker);
                 YUE.on(checkboxes,'click', checkbox_checker);
 
                 YUE.on('rev_range_clear','click',function(e){
                     for (var i=0; i<checkboxes.length; i++){
                         var cb = checkboxes[i];
                         cb.checked = false;
                     }
                     checkbox_checker();
                     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);
 
                 });
 
                 // 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;
                     canvas.setAttribute('height',div_h);
                     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/files/files_history_box.html

@@ -1,26 +1,26 b''
 <dl>
     <dt class="file_history">${_('History')}</dt>
     <dd>
         <div>
             <div style="float:left">
             ${h.form(h.url('files_diff_home',repo_name=c.repo_name,f_path=c.f_path),method='get')}
             ${h.hidden('diff2',c.file_changeset.raw_id)}
             ${h.select('diff1',c.file_changeset.raw_id,c.file_history)}
             ${h.submit('diff',_('Diff to revision'),class_="ui-btn")}
             ${h.submit('show_rev',_('Show at revision'),class_="ui-btn")}
-            ${h.link_to(_('Show full history'),h.url('shortlog_file_home',repo_name=c.repo_name, revision=c.file_changeset.raw_id, f_path=c.f_path),class_="ui-btn")}
+            ${h.link_to(_('Show full history'),h.url('changelog_file_home',repo_name=c.repo_name, revision=c.file_changeset.raw_id, f_path=c.f_path),class_="ui-btn")}
             ${h.hidden('annotate', c.annotate)}
             ${h.end_form()}
             </div>
             <div class="file_author">
                 <div class="item">${h.literal(ungettext(u'%s author',u'%s authors',len(c.authors)) % ('<b>%s</b>' % len(c.authors))) }</div>
                 %for email, user in c.authors:
                   <div class="contributor tooltip" style="float:left" title="${h.tooltip(user)}">
                     <div class="gravatar" style="margin:1px"><img alt="gravatar" src="${h.gravatar_url(email, 20)}"/> </div>
                   </div>
                 %endfor
             </div>
         </div>
         <div style="clear:both"></div>
     </dd>
 </dl>

rhodecode/tests/functional/test_changelog.py

@@ -1,126 +1,175 b''
 from rhodecode.tests import *
 
 
 class TestChangelogController(TestController):
 
     def test_index_hg(self):
         self.log_user()
         response = self.app.get(url(controller='changelog', action='index',
                                     repo_name=HG_REPO))
 
         response.mustcontain('''id="chg_20" class="container tablerow1"''')
         response.mustcontain(
             """<input class="changeset_range" """
             """id="5e204e7583b9c8e7b93a020bd036564b1e731dae" """
             """name="5e204e7583b9c8e7b93a020bd036564b1e731dae" """
             """type="checkbox" value="1" />"""
         )
 
         response.mustcontain(
             """<span class="changeset_hash">r154:5e204e7583b9</span>"""
         )
 
         response.mustcontain("""Small update at simplevcs app""")
 
 #        response.mustcontain(
 #            """<div id="changed_total_5e204e7583b9c8e7b93a020bd036564b1e731dae" """
 #            """style="float:right;" class="changed_total tooltip" """
 #            """title="Affected number of files, click to show """
 #            """more details">3</div>"""
 #        )
 
     def test_index_pagination_hg(self):
         self.log_user()
         #pagination
         self.app.get(url(controller='changelog', action='index',
                                     repo_name=HG_REPO), {'page': 1})
         self.app.get(url(controller='changelog', action='index',
                                     repo_name=HG_REPO), {'page': 2})
         self.app.get(url(controller='changelog', action='index',
                                     repo_name=HG_REPO), {'page': 3})
         self.app.get(url(controller='changelog', action='index',
                                     repo_name=HG_REPO), {'page': 4})
         self.app.get(url(controller='changelog', action='index',
                                     repo_name=HG_REPO), {'page': 5})
         response = self.app.get(url(controller='changelog', action='index',
                                     repo_name=HG_REPO), {'page': 6})
 
         # Test response after pagination...
         response.mustcontain(
             """<input class="changeset_range" """
             """id="46ad32a4f974e45472a898c6b0acb600320579b1" """
             """name="46ad32a4f974e45472a898c6b0acb600320579b1" """
             """type="checkbox" value="1" />"""
         )
 
         response.mustcontain(
             """<span class="changeset_hash">r64:46ad32a4f974</span>"""
         )
 
 #        response.mustcontain(
 #            """<div id="changed_total_46ad32a4f974e45472a898c6b0acb600320579b1" """
 #            """style="float:right;" class="changed_total tooltip" """
 #            """title="Affected number of files, click to show """
 #            """more details">21</div>"""
 #        )
 #
 #        response.mustcontain(
 #            """<a href="/%s/changeset/"""
 #            """46ad32a4f974e45472a898c6b0acb600320579b1" """
 #            """title="Merge with 2e6a2bf9356ca56df08807f4ad86d480da72a8f4">"""
 #            """46ad32a4f974</a>""" % HG_REPO
 #        )
 
     def test_index_git(self):
         self.log_user()
         response = self.app.get(url(controller='changelog', action='index',
                                     repo_name=GIT_REPO))
 
         response.mustcontain('''id="chg_20" class="container tablerow1"''')
         response.mustcontain(
             """<input class="changeset_range" """
             """id="95f9a91d775b0084b2368ae7779e44931c849c0e" """
             """name="95f9a91d775b0084b2368ae7779e44931c849c0e" """
             """type="checkbox" value="1" />"""
         )
 
         response.mustcontain(
             """<span class="changeset_hash">r613:95f9a91d775b</span>"""
         )
 
         response.mustcontain("""fixing stupid typo in context for mercurial""")
 
 #        response.mustcontain(
 #            """<div id="changed_total_5e204e7583b9c8e7b93a020bd036564b1e731dae" """
 #            """style="float:right;" class="changed_total tooltip" """
 #            """title="Affected number of files, click to show """
 #            """more details">3</div>"""
 #        )
 
     def test_index_pagination_git(self):
         self.log_user()
         #pagination
         self.app.get(url(controller='changelog', action='index',
                                     repo_name=GIT_REPO), {'page': 1})
         self.app.get(url(controller='changelog', action='index',
                                     repo_name=GIT_REPO), {'page': 2})
         self.app.get(url(controller='changelog', action='index',
                                     repo_name=GIT_REPO), {'page': 3})
         self.app.get(url(controller='changelog', action='index',
                                     repo_name=GIT_REPO), {'page': 4})
         self.app.get(url(controller='changelog', action='index',
                                     repo_name=GIT_REPO), {'page': 5})
         response = self.app.get(url(controller='changelog', action='index',
                                     repo_name=GIT_REPO), {'page': 6})
 
         # Test response after pagination...
         response.mustcontain(
             """<input class="changeset_range" """
             """id="636ed213f2f11ef91071b9c24f2d5e6bd01a6ed5" """
             """name="636ed213f2f11ef91071b9c24f2d5e6bd01a6ed5" """
             """type="checkbox" value="1" />"""
         )
 
         response.mustcontain(
             """<span class="changeset_hash">r515:636ed213f2f1</span>"""
         )
+
+    def test_index_hg_with_filenode(self):
+        self.log_user()
+        response = self.app.get(url(controller='changelog', action='index',
+                                    revision='tip', f_path='/vcs/exceptions.py',
+                                    repo_name=HG_REPO))
+        #history commits messages
+        response.mustcontain('Added exceptions module, this time for real')
+        response.mustcontain('Added not implemented hg backend test case')
+        response.mustcontain('Added BaseChangeset class')
+        # Test response...
+
+    def test_index_git_with_filenode(self):
+        self.log_user()
+        response = self.app.get(url(controller='changelog', action='index',
+                                    revision='tip', f_path='/vcs/exceptions.py',
+                                    repo_name=GIT_REPO))
+        #history commits messages
+        response.mustcontain('Added exceptions module, this time for real')
+        response.mustcontain('Added not implemented hg backend test case')
+        response.mustcontain('Added BaseChangeset class')
+
+    def test_index_hg_with_filenode_that_is_dirnode(self):
+        self.log_user()
+        response = self.app.get(url(controller='changelog', action='index',
+                                    revision='tip', f_path='/tests',
+                                    repo_name=HG_REPO))
+        self.assertEqual(response.status, '302 Found')
+
+    def test_index_git_with_filenode_that_is_dirnode(self):
+        self.log_user()
+        response = self.app.get(url(controller='changelog', action='index',
+                                    revision='tip', f_path='/tests',
+                                    repo_name=GIT_REPO))
+        self.assertEqual(response.status, '302 Found')
+
+    def test_index_hg_with_filenode_not_existing(self):
+        self.log_user()
+        response = self.app.get(url(controller='changelog', action='index',
+                                    revision='tip', f_path='/wrong_path',
+                                    repo_name=HG_REPO))
+        self.assertEqual(response.status, '302 Found')
+
+    def test_index_git_with_filenode_not_existing(self):
+        self.log_user()
+        response = self.app.get(url(controller='changelog', action='index',
+                                    revision='tip', f_path='/wrong_path',
+                                    repo_name=GIT_REPO))
+        self.assertEqual(response.status, '302 Found')

rhodecode/tests/functional/test_shortlog.py

@@ -1,65 +1,16 b''
 from rhodecode.tests import *
 
 
 class TestShortlogController(TestController):
 
     def test_index_hg(self):
         self.log_user()
         response = self.app.get(url(controller='shortlog', action='index',
                                     repo_name=HG_REPO))
         # Test response...
 
     def test_index_git(self):
         self.log_user()
         response = self.app.get(url(controller='shortlog', action='index',
                                     repo_name=GIT_REPO))
         # Test response...
-
-    def test_index_hg_with_filenode(self):
-        self.log_user()
-        response = self.app.get(url(controller='shortlog', action='index',
-                                    revision='tip', f_path='/vcs/exceptions.py',
-                                    repo_name=HG_REPO))
-        #history commits messages
-        response.mustcontain('Added exceptions module, this time for real')
-        response.mustcontain('Added not implemented hg backend test case')
-        response.mustcontain('Added BaseChangeset class')
-        # Test response...
-
-    def test_index_git_with_filenode(self):
-        self.log_user()
-        response = self.app.get(url(controller='shortlog', action='index',
-                                    revision='tip', f_path='/vcs/exceptions.py',
-                                    repo_name=GIT_REPO))
-        #history commits messages
-        response.mustcontain('Added exceptions module, this time for real')
-        response.mustcontain('Added not implemented hg backend test case')
-        response.mustcontain('Added BaseChangeset class')
-
-    def test_index_hg_with_filenode_that_is_dirnode(self):
-        self.log_user()
-        response = self.app.get(url(controller='shortlog', action='index',
-                                    revision='tip', f_path='/tests',
-                                    repo_name=HG_REPO))
-        self.assertEqual(response.status, '302 Found')
-
-    def test_index_git_with_filenode_that_is_dirnode(self):
-        self.log_user()
-        response = self.app.get(url(controller='shortlog', action='index',
-                                    revision='tip', f_path='/tests',
-                                    repo_name=GIT_REPO))
-        self.assertEqual(response.status, '302 Found')
-
-    def test_index_hg_with_filenode_not_existing(self):
-        self.log_user()
-        response = self.app.get(url(controller='shortlog', action='index',
-                                    revision='tip', f_path='/wrong_path',
-                                    repo_name=HG_REPO))
-        self.assertEqual(response.status, '302 Found')
-
-    def test_index_git_with_filenode_not_existing(self):
-        self.log_user()
-        response = self.app.get(url(controller='shortlog', action='index',
-                                    revision='tip', f_path='/wrong_path',
-                                    repo_name=GIT_REPO))
-        self.assertEqual(response.status, '302 Found')