jro_apps/redmine Commit - r3961:3a2efb47572d

Refactor: convert ProjectEnumerations to a resource on a project....

Eric Davis -

r3961:3a2efb47572d

parent child

Context file:

r3961:3a2efb47572d

Collapse all files

app/controllers/application_controller.rb +7 0

              # redMine - project management software
              # Copyright (C) 2006-2007  Jean-Philippe Lang
              #
              # 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 2
              # 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, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require 'uri'
              require 'cgi'
              class ApplicationController < ActionController::Base
                include Redmine::I18n
                layout 'base'
                exempt_from_layout 'builder'
                # Remove broken cookie after upgrade from 0.8.x (#4292)
                # See https://rails.lighthouseapp.com/projects/8994/tickets/3360
                # TODO: remove it when Rails is fixed
                before_filter :delete_broken_cookies
                def delete_broken_cookies
                  if cookies['_redmine_session'] && cookies['_redmine_session'] !~ /--/
                    cookies.delete '_redmine_session'
                    redirect_to home_path
                    return false
                  end
                end
                before_filter :user_setup, :check_if_login_required, :set_localization
                filter_parameter_logging :password
                protect_from_forgery
                rescue_from ActionController::InvalidAuthenticityToken, :with => :invalid_authenticity_token
                include Redmine::Search::Controller
                include Redmine::MenuManager::MenuController
                helper Redmine::MenuManager::MenuHelper
                Redmine::Scm::Base.all.each do |scm|
                  require_dependency "repository/#{scm.underscore}"
                end
                def user_setup
                  # Check the settings cache for each request
                  Setting.check_cache
                  # Find the current user
                  User.current = find_current_user
                end
                # Returns the current user or nil if no user is logged in
                # and starts a session if needed
                def find_current_user
                  if session[:user_id]
                    # existing session
                    (User.active.find(session[:user_id]) rescue nil)
                  elsif cookies[:autologin] && Setting.autologin?
                    # auto-login feature starts a new session
                    user = User.try_to_autologin(cookies[:autologin])
                    session[:user_id] = user.id if user
                    user
                  elsif params[:format] == 'atom' && params[:key] && accept_key_auth_actions.include?(params[:action])
                    # RSS key authentication does not start a session
                    User.find_by_rss_key(params[:key])
                  elsif Setting.rest_api_enabled? && ['xml', 'json'].include?(params[:format])
                    if params[:key].present? && accept_key_auth_actions.include?(params[:action])
                      # Use API key
                      User.find_by_api_key(params[:key])
                    else
                      # HTTP Basic, either username/password or API key/random
                      authenticate_with_http_basic do |username, password|
                        User.try_to_login(username, password) || User.find_by_api_key(username)
                      end
                    end
                  end
                end
                # Sets the logged in user
                def logged_user=(user)
                  reset_session
                  if user && user.is_a?(User)
                    User.current = user
                    session[:user_id] = user.id
                  else
                    User.current = User.anonymous
                  end
                end
                # check if login is globally required to access the application
                def check_if_login_required
                  # no check needed if user is already logged in
                  return true if User.current.logged?
                  require_login if Setting.login_required?
                end
                def set_localization
                  lang = nil
                  if User.current.logged?
                    lang = find_language(User.current.language)
                  end
                  if lang.nil? && request.env['HTTP_ACCEPT_LANGUAGE']
                    accept_lang = parse_qvalues(request.env['HTTP_ACCEPT_LANGUAGE']).first
                    if !accept_lang.blank?
                      accept_lang = accept_lang.downcase
                      lang = find_language(accept_lang) || find_language(accept_lang.split('-').first)
                    end
                  end
                  lang ||= Setting.default_language
                  set_language_if_valid(lang)
                end
                def require_login
                  if !User.current.logged?
                    # Extract only the basic url parameters on non-GET requests
                    if request.get?
                      url = url_for(params)
                    else
                      url = url_for(:controller => params[:controller], :action => params[:action], :id => params[:id], :project_id => params[:project_id])
                    end
                    respond_to do |format|
                      format.html { redirect_to :controller => "account", :action => "login", :back_url => url }
                      format.atom { redirect_to :controller => "account", :action => "login", :back_url => url }
                      format.xml  { head :unauthorized, 'WWW-Authenticate' => 'Basic realm="Redmine API"' }
                      format.js   { head :unauthorized, 'WWW-Authenticate' => 'Basic realm="Redmine API"' }
                      format.json { head :unauthorized, 'WWW-Authenticate' => 'Basic realm="Redmine API"' }
                    end
                    return false
                  end
                  true
                end
                def require_admin
                  return unless require_login
                  if !User.current.admin?
                    render_403
                    return false
                  end
                  true
                end
                def deny_access
                  User.current.logged? ? render_403 : require_login
                end
                # Authorize the user for the requested action
                def authorize(ctrl = params[:controller], action = params[:action], global = false)
                  allowed = User.current.allowed_to?({:controller => ctrl, :action => action}, @project, :global => global)
                  allowed ? true : deny_access
                end
                # Authorize the user for the requested action outside a project
                def authorize_global(ctrl = params[:controller], action = params[:action], global = true)
                  authorize(ctrl, action, global)
                end
                # Find project of id params[:id]
                def find_project
                  @project = Project.find(params[:id])
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
+               # Find project of id params[:project_id]
+               def find_project_by_project_id
+                 @project = Project.find(params[:project_id])
+               rescue ActiveRecord::RecordNotFound
+                 render_404
+               end
                # Find a project based on params[:project_id]
                # TODO: some subclasses override this, see about merging their logic
                def find_optional_project
                  @project = Project.find(params[:project_id]) unless params[:project_id].blank?
                  allowed = User.current.allowed_to?({:controller => params[:controller], :action => params[:action]}, @project, :global => true)
                  allowed ? true : deny_access
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                # Finds and sets @project based on @object.project
                def find_project_from_association
                  render_404 unless @object.present?
                  @project = @object.project
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def find_model_object
                  model = self.class.read_inheritable_attribute('model_object')
                  if model
                    @object = model.find(params[:id])
                    self.instance_variable_set('@' + controller_name.singularize, @object) if @object
                  end
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                def self.model_object(model)
                  write_inheritable_attribute('model_object', model)
                end
                # Filter for bulk issue operations
                def find_issues
                  @issues = Issue.find_all_by_id(params[:id] || params[:ids])
                  raise ActiveRecord::RecordNotFound if @issues.empty?
                  projects = @issues.collect(&:project).compact.uniq
                  if projects.size == 1
                    @project = projects.first
                  else
                    # TODO: let users bulk edit/move/destroy issues from different projects
                    render_error 'Can not bulk edit/move/destroy issues from different projects'
                    return false
                  end
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                # make sure that the user is a member of the project (or admin) if project is private
                # used as a before_filter for actions that do not require any particular permission on the project
                def check_project_privacy
                  if @project && @project.active?
                    if @project.is_public? || User.current.member_of?(@project) || User.current.admin?
                      true
                    else
                      User.current.logged? ? render_403 : require_login
                    end
                  else
                    @project = nil
                    render_404
                    false
                  end
                end
                def back_url
                  params[:back_url] || request.env['HTTP_REFERER']
                end
                def redirect_back_or_default(default)
                  back_url = CGI.unescape(params[:back_url].to_s)
                  if !back_url.blank?
                    begin
                      uri = URI.parse(back_url)
                      # do not redirect user to another host or to the login or register page
                      if (uri.relative? || (uri.host == request.host)) && !uri.path.match(%r{/(login|account/register)})
                        redirect_to(back_url)
                        return
                      end
                    rescue URI::InvalidURIError
                      # redirect to default
                    end
                  end
                  redirect_to default
                end
                def render_403
                  @project = nil
                  respond_to do |format|
                    format.html { render :template => "common/403", :layout => use_layout, :status => 403 }
                    format.atom { head 403 }
                    format.xml { head 403 }
                    format.js { head 403 }
                    format.json { head 403 }
                  end
                  return false
                end
                def render_404
                  respond_to do |format|
                    format.html { render :template => "common/404", :layout => use_layout, :status => 404 }
                    format.atom { head 404 }
                    format.xml { head 404 }
                    format.js { head 404 }
                    format.json { head 404 }
                  end
                  return false
                end
                def render_error(msg)
                  respond_to do |format|
                    format.html {
                      flash.now[:error] = msg
                      render :text => '', :layout => use_layout, :status => 500
                    }
                    format.atom { head 500 }
                    format.xml { head 500 }
                    format.js { head 500 }
                    format.json { head 500 }
                  end
                end
                # Picks which layout to use based on the request
                #
                # @return [boolean, string] name of the layout to use or false for no layout
                def use_layout
                  request.xhr? ? false : 'base'
                end
                def invalid_authenticity_token
                  if api_request?
                    logger.error "Form authenticity token is missing or is invalid. API calls must include a proper Content-type header (text/xml or text/json)."
                  end
                  render_error "Invalid form authenticity token."
                end
                def render_feed(items, options={})
                  @items = items || []
                  @items.sort! {|x,y| y.event_datetime <=> x.event_datetime }
                  @items = @items.slice(0, Setting.feeds_limit.to_i)
                  @title = options[:title] || Setting.app_title
                  render :template => "common/feed.atom.rxml", :layout => false, :content_type => 'application/atom+xml'
                end
                def self.accept_key_auth(*actions)
                  actions = actions.flatten.map(&:to_s)
                  write_inheritable_attribute('accept_key_auth_actions', actions)
                end
                def accept_key_auth_actions
                  self.class.read_inheritable_attribute('accept_key_auth_actions') || []
                end
                # Returns the number of objects that should be displayed
                # on the paginated list
                def per_page_option
                  per_page = nil
                  if params[:per_page] && Setting.per_page_options_array.include?(params[:per_page].to_s.to_i)
                    per_page = params[:per_page].to_s.to_i
                    session[:per_page] = per_page
                  elsif session[:per_page]
                    per_page = session[:per_page]
                  else
                    per_page = Setting.per_page_options_array.first || 25
                  end
                  per_page
                end
                # qvalues http header parser
                # code taken from webrick
                def parse_qvalues(value)
                  tmp = []
                  if value
                    parts = value.split(/,\s*/)
                    parts.each {|part|
                      if m = %r{^([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?$}.match(part)
                        val = m[1]
                        q = (m[2] or 1).to_f
                        tmp.push([val, q])
                      end
                    }
                    tmp = tmp.sort_by{|val, q| -q}
                    tmp.collect!{|val, q| val}
                  end
                  return tmp
                rescue
                  nil
                end
                # Returns a string that can be used as filename value in Content-Disposition header
                def filename_for_content_disposition(name)
                  request.env['HTTP_USER_AGENT'] =~ %r{MSIE} ? ERB::Util.url_encode(name) : name
                end
                def api_request?
                  %w(xml json).include? params[:format]
                end
                # Renders a warning flash if obj has unsaved attachments
                def render_attachment_warning_if_needed(obj)
                  flash[:warning] = l(:warning_attachments_not_saved, obj.unsaved_attachments.size) if obj.unsaved_attachments.present?
                end
                # Sets the `flash` notice or error based the number of issues that did not save
                #
                # @param [Array, Issue] issues all of the saved and unsaved Issues
                # @param [Array, Integer] unsaved_issue_ids the issue ids that were not saved
                def set_flash_from_bulk_issue_save(issues, unsaved_issue_ids)
                  if unsaved_issue_ids.empty?
                    flash[:notice] = l(:notice_successful_update) unless issues.empty?
                  else
                    flash[:error] = l(:notice_failed_to_save_issues,
                                      :count => unsaved_issue_ids.size,
                                      :total => issues.size,
                                      :ids => '#' + unsaved_issue_ids.join(', #'))
                  end
                end
                # Rescues an invalid query statement. Just in case...
                def query_statement_invalid(exception)
                  logger.error "Query::StatementInvalid: #{exception.message}" if logger
                  session.delete(:query)
                  sort_clear if respond_to?(:sort_clear)
                  render_error "An error occurred while executing the query and has been logged. Please report this error to your Redmine administrator."
                end
                # Converts the errors on an ActiveRecord object into a common JSON format
                def object_errors_to_json(object)
                  object.errors.collect do |attribute, error|
                    { attribute => error }
                  end.to_json
                end
              end

app/controllers/project_enumerations_controller.rb +3 -3

              class ProjectEnumerationsController < ApplicationController
-               before_filter :find_project
+               before_filter :find_project_by_project_id
                before_filter :authorize
-               def save
-                 if request.post? && params[:enumerations]
+               def update
+                 if request.put? && params[:enumerations]
                    Project.transaction do
                      params[:enumerations].each do |id, activity|
                        @project.update_or_create_time_entry_activity(id, activity)
                      end
                    end
                    flash[:notice] = l(:notice_successful_update)
                  end
                  redirect_to :controller => 'projects', :action => 'settings', :tab => 'activities', :id => @project
                end
                def destroy
                  @project.time_entry_activities.each do |time_entry_activity|
                    time_entry_activity.destroy(time_entry_activity.parent)
                  end
                  flash[:notice] = l(:notice_successful_update)
                  redirect_to :controller => 'projects', :action => 'settings', :tab => 'activities', :id => @project
                end
              end

app/views/projects/settings/_activities.rhtml +2 -2

-             <% form_tag({:controller => 'project_enumerations', :action => 'save', :id => @project}, :class => "tabular") do %>
+             <% form_tag(project_project_enumerations_path(@project), :method => :put, :class => "tabular") do %>
              <table class="list">
                <thead><tr>
                  <th><%= l(:field_name) %></th>
                  <th><%= l(:enumeration_system_activity) %></th>
                  <% TimeEntryActivity.new.available_custom_fields.each do |value| %>
              	<th><%= h value.name %></th>
                  <% end %>
                  <th style="width:15%;"><%= l(:field_active) %></th>
                </tr></thead>
                <% @project.activities(true).each do |enumeration| %>
                <% fields_for "enumerations[#{enumeration.id}]", enumeration do |ff| %>
                <tr class="<%= cycle('odd', 'even') %>">
                  <td>
                    <%= ff.hidden_field :parent_id, :value => enumeration.id unless enumeration.project %>
                    <%= h(enumeration) %>
                  </td>
                  <td align="center" style="width:15%;"><%= checked_image !enumeration.project %></td>
                  <% enumeration.custom_field_values.each do |value| %>
              	<td align="center">
                    <%= custom_field_tag "enumerations[#{enumeration.id}]", value %>
                  </td>
                  <% end %>
                  <td align="center" style="width:15%;">
                    <%= ff.check_box :active %>
                  </td>
                </tr>
                <% end %>
                <% end %>
              </table>
              <div class="contextual">
-             <%= link_to(l(:button_reset), {:controller => 'project_enumerations', :action => 'destroy', :id => @project},
+             <%= link_to(l(:button_reset), project_project_enumerations_path(@project),
              						:method => :delete,
              						:confirm => l(:text_are_you_sure),
                          :class => 'icon icon-del') %>
              </div>
              <%= submit_tag l(:button_save) %>
              <% end %>

config/routes.rb +3 -7

              ActionController::Routing::Routes.draw do |map|
                # Add your own custom routes here.
                # The priority is based upon order of creation: first created -> highest priority.
                # Here's a sample route:
                # map.connect 'products/:id', :controller => 'catalog', :action => 'view'
                # Keep in mind you can assign values other than :controller and :action
                map.home '', :controller => 'welcome'
                map.signin 'login', :controller => 'account', :action => 'login'
                map.signout 'logout', :controller => 'account', :action => 'logout'
                map.connect 'roles/workflow/:id/:role_id/:tracker_id', :controller => 'roles', :action => 'workflow'
                map.connect 'help/:ctrl/:page', :controller => 'help'
                map.connect 'time_entries/:id/edit', :action => 'edit', :controller => 'timelog'
                map.connect 'projects/:project_id/time_entries/new', :action => 'edit', :controller => 'timelog'
                map.connect 'projects/:project_id/issues/:issue_id/time_entries/new', :action => 'edit', :controller => 'timelog'
                map.with_options :controller => 'timelog' do |timelog|
                  timelog.connect 'projects/:project_id/time_entries', :action => 'details'
                  timelog.with_options :action => 'details', :conditions => {:method => :get}  do |time_details|
                    time_details.connect 'time_entries'
                    time_details.connect 'time_entries.:format'
                    time_details.connect 'issues/:issue_id/time_entries'
                    time_details.connect 'issues/:issue_id/time_entries.:format'
                    time_details.connect 'projects/:project_id/time_entries.:format'
                    time_details.connect 'projects/:project_id/issues/:issue_id/time_entries'
                    time_details.connect 'projects/:project_id/issues/:issue_id/time_entries.:format'
                  end
                  timelog.connect 'projects/:project_id/time_entries/report', :action => 'report'
                  timelog.with_options :action => 'report',:conditions => {:method => :get} do |time_report|
                    time_report.connect 'time_entries/report'
                    time_report.connect 'time_entries/report.:format'
                    time_report.connect 'projects/:project_id/time_entries/report.:format'
                  end
                  timelog.with_options :action => 'edit', :conditions => {:method => :get} do |time_edit|
                    time_edit.connect 'issues/:issue_id/time_entries/new'
                  end
                  timelog.connect 'time_entries/:id/destroy', :action => 'destroy', :conditions => {:method => :post}
                end
                map.connect 'projects/:id/wiki', :controller => 'wikis', :action => 'edit', :conditions => {:method => :post}
                map.connect 'projects/:id/wiki/destroy', :controller => 'wikis', :action => 'destroy', :conditions => {:method => :get}
                map.connect 'projects/:id/wiki/destroy', :controller => 'wikis', :action => 'destroy', :conditions => {:method => :post}
                map.with_options :controller => 'wiki' do |wiki_routes|
                  wiki_routes.with_options :conditions => {:method => :get} do |wiki_views|
                    wiki_views.connect 'projects/:id/wiki/:page', :action => 'special', :page => /page_index|date_index|export/i
                    wiki_views.connect 'projects/:id/wiki/:page', :action => 'index', :page => nil
                    wiki_views.connect 'projects/:id/wiki/:page/edit', :action => 'edit'
                    wiki_views.connect 'projects/:id/wiki/:page/rename', :action => 'rename'
                    wiki_views.connect 'projects/:id/wiki/:page/history', :action => 'history'
                    wiki_views.connect 'projects/:id/wiki/:page/diff/:version/vs/:version_from', :action => 'diff'
                    wiki_views.connect 'projects/:id/wiki/:page/annotate/:version', :action => 'annotate'
                  end
                  wiki_routes.connect 'projects/:id/wiki/:page/:action',
                    :action => /edit|rename|destroy|preview|protect/,
                    :conditions => {:method => :post}
                end
                map.with_options :controller => 'messages' do |messages_routes|
                  messages_routes.with_options :conditions => {:method => :get} do |messages_views|
                    messages_views.connect 'boards/:board_id/topics/new', :action => 'new'
                    messages_views.connect 'boards/:board_id/topics/:id', :action => 'show'
                    messages_views.connect 'boards/:board_id/topics/:id/edit', :action => 'edit'
                  end
                  messages_routes.with_options :conditions => {:method => :post} do |messages_actions|
                    messages_actions.connect 'boards/:board_id/topics/new', :action => 'new'
                    messages_actions.connect 'boards/:board_id/topics/:id/replies', :action => 'reply'
                    messages_actions.connect 'boards/:board_id/topics/:id/:action', :action => /edit|destroy/
                  end
                end
                map.with_options :controller => 'boards' do |board_routes|
                  board_routes.with_options :conditions => {:method => :get} do |board_views|
                    board_views.connect 'projects/:project_id/boards', :action => 'index'
                    board_views.connect 'projects/:project_id/boards/new', :action => 'new'
                    board_views.connect 'projects/:project_id/boards/:id', :action => 'show'
                    board_views.connect 'projects/:project_id/boards/:id.:format', :action => 'show'
                    board_views.connect 'projects/:project_id/boards/:id/edit', :action => 'edit'
                  end
                  board_routes.with_options :conditions => {:method => :post} do |board_actions|
                    board_actions.connect 'projects/:project_id/boards', :action => 'new'
                    board_actions.connect 'projects/:project_id/boards/:id/:action', :action => /edit|destroy/
                  end
                end
                map.with_options :controller => 'documents' do |document_routes|
                  document_routes.with_options :conditions => {:method => :get} do |document_views|
                    document_views.connect 'projects/:project_id/documents', :action => 'index'
                    document_views.connect 'projects/:project_id/documents/new', :action => 'new'
                    document_views.connect 'documents/:id', :action => 'show'
                    document_views.connect 'documents/:id/edit', :action => 'edit'
                  end
                  document_routes.with_options :conditions => {:method => :post} do |document_actions|
                    document_actions.connect 'projects/:project_id/documents', :action => 'new'
                    document_actions.connect 'documents/:id/:action', :action => /destroy|edit/
                  end
                end
                map.resources :issue_moves, :only => [:new, :create], :path_prefix => '/issues', :as => 'move'
                # Misc issue routes. TODO: move into resources
                map.auto_complete_issues '/issues/auto_complete', :controller => 'auto_completes', :action => 'issues'
                map.preview_issue '/issues/preview/:id', :controller => 'previews', :action => 'issue' # TODO: would look nicer as /issues/:id/preview
                map.issues_context_menu '/issues/context_menu', :controller => 'context_menus', :action => 'issues'
                map.issue_changes '/issues/changes', :controller => 'journals', :action => 'index'
                map.bulk_edit_issue 'issues/bulk_edit', :controller => 'issues', :action => 'bulk_edit', :conditions => { :method => :get }
                map.bulk_update_issue 'issues/bulk_edit', :controller => 'issues', :action => 'bulk_update', :conditions => { :method => :post }
                map.quoted_issue '/issues/:id/quoted', :controller => 'journals', :action => 'new', :id => /\d+/, :conditions => { :method => :post }
                map.connect '/issues/:id/destroy', :controller => 'issues', :action => 'destroy', :conditions => { :method => :post } # legacy
                map.resource :gantt, :path_prefix => '/issues', :controller => 'gantts', :only => [:show, :update]
                map.resource :gantt, :path_prefix => '/projects/:project_id/issues', :controller => 'gantts', :only => [:show, :update]
                map.resource :calendar, :path_prefix => '/issues', :controller => 'calendars', :only => [:show, :update]
                map.resource :calendar, :path_prefix => '/projects/:project_id/issues', :controller => 'calendars', :only => [:show, :update]
                map.with_options :controller => 'reports', :conditions => {:method => :get} do |reports|
                  reports.connect 'projects/:id/issues/report', :action => 'issue_report'
                  reports.connect 'projects/:id/issues/report/:detail', :action => 'issue_report_details'
                end
                # Following two routes conflict with the resources because #index allows POST
                map.connect '/issues', :controller => 'issues', :action => 'index', :conditions => { :method => :post }
                map.connect '/issues/create', :controller => 'issues', :action => 'index', :conditions => { :method => :post }
                map.resources :issues, :member => { :edit => :post }, :collection => {}
                map.resources :issues, :path_prefix => '/projects/:project_id', :collection => { :create => :post }
                map.with_options  :controller => 'issue_relations', :conditions => {:method => :post} do |relations|
                  relations.connect 'issues/:issue_id/relations/:id', :action => 'new'
                  relations.connect 'issues/:issue_id/relations/:id/destroy', :action => 'destroy'
                end
                map.with_options :controller => 'news' do |news_routes|
                  news_routes.with_options :conditions => {:method => :get} do |news_views|
                    news_views.connect 'news', :action => 'index'
                    news_views.connect 'projects/:project_id/news', :action => 'index'
                    news_views.connect 'projects/:project_id/news.:format', :action => 'index'
                    news_views.connect 'news.:format', :action => 'index'
                    news_views.connect 'projects/:project_id/news/new', :action => 'new'
                    news_views.connect 'news/:id', :action => 'show'
                    news_views.connect 'news/:id/edit', :action => 'edit'
                  end
                  news_routes.with_options do |news_actions|
                    news_actions.connect 'projects/:project_id/news', :action => 'new'
                    news_actions.connect 'news/:id/edit', :action => 'edit'
                    news_actions.connect 'news/:id/destroy', :action => 'destroy'
                  end
                end
                map.connect 'projects/:id/members/new', :controller => 'members', :action => 'new'
                map.with_options :controller => 'users' do |users|
                  users.with_options :conditions => {:method => :get} do |user_views|
                    user_views.connect 'users', :action => 'index'
                    user_views.connect 'users/:id', :action => 'show', :id => /\d+/
                    user_views.connect 'users/new', :action => 'add'
                    user_views.connect 'users/:id/edit/:tab', :action => 'edit', :tab => nil
                  end
                  users.with_options :conditions => {:method => :post} do |user_actions|
                    user_actions.connect 'users', :action => 'add'
                    user_actions.connect 'users/new', :action => 'add'
                    user_actions.connect 'users/:id/edit', :action => 'edit'
                    user_actions.connect 'users/:id/memberships', :action => 'edit_membership'
                    user_actions.connect 'users/:id/memberships/:membership_id', :action => 'edit_membership'
                    user_actions.connect 'users/:id/memberships/:membership_id/destroy', :action => 'destroy_membership'
                  end
                end
                map.resources :projects, :member => {
                  :copy => [:get, :post],
                  :settings => :get,
                  :modules => :post,
                  :archive => :post,
                  :unarchive => :post
+               }
+               } do |project|
+                 project.resource :project_enumerations, :as => 'enumerations', :only => [:update, :destroy]
+               end
                # Destroy uses a get request to prompt the user before the actual DELETE request
                map.project_destroy_confirm 'projects/:id/destroy', :controller => 'projects', :action => 'destroy', :conditions => {:method => :get}
                # TODO: port to be part of the resources route(s)
                map.with_options :controller => 'projects' do |project_mapper|
                  project_mapper.with_options :conditions => {:method => :get} do |project_views|
                    project_views.connect 'projects/:id/files', :controller => 'files', :action => 'index'
                    project_views.connect 'projects/:id/files/new', :controller => 'files', :action => 'new'
                    project_views.connect 'projects/:id/settings/:tab', :controller => 'projects', :action => 'settings'
                    project_views.connect 'projects/:project_id/issues/:copy_from/copy', :controller => 'issues', :action => 'new'
                  end
                  project_mapper.with_options :conditions => {:method => :post} do |project_actions|
                    project_actions.connect 'projects/:id/files/new', :controller => 'files', :action => 'new'
-                   project_actions.connect 'projects/:id/activities/save', :controller => 'project_enumerations', :action => 'save'
-                 end
-                 project_mapper.with_options :conditions => {:method => :delete} do |project_actions|
-                   project_actions.conditions 'projects/:id/reset_activities', :controller => 'project_enumerations', :action => 'destroy'
                  end
                end
                map.with_options :controller => 'activities', :action => 'index', :conditions => {:method => :get} do |activity|
                  activity.connect 'projects/:id/activity'
                  activity.connect 'projects/:id/activity.:format'
                  activity.connect 'activity', :id => nil
                  activity.connect 'activity.:format', :id => nil
                end
                map.with_options :controller => 'versions' do |versions|
                  versions.connect 'projects/:project_id/versions/new', :action => 'new'
                  versions.connect 'projects/:project_id/roadmap', :action => 'index'
                  versions.with_options :conditions => {:method => :post} do |version_actions|
                    version_actions.connect 'projects/:project_id/versions/close_completed', :action => 'close_completed'
                  end
                end
                map.with_options :controller => 'issue_categories' do |categories|
                  categories.connect 'projects/:project_id/issue_categories/new', :action => 'new'
                end
                map.with_options :controller => 'repositories' do |repositories|
                  repositories.with_options :conditions => {:method => :get} do |repository_views|
                    repository_views.connect 'projects/:id/repository', :action => 'show'
                    repository_views.connect 'projects/:id/repository/edit', :action => 'edit'
                    repository_views.connect 'projects/:id/repository/statistics', :action => 'stats'
                    repository_views.connect 'projects/:id/repository/revisions', :action => 'revisions'
                    repository_views.connect 'projects/:id/repository/revisions.:format', :action => 'revisions'
                    repository_views.connect 'projects/:id/repository/revisions/:rev', :action => 'revision'
                    repository_views.connect 'projects/:id/repository/revisions/:rev/diff', :action => 'diff'
                    repository_views.connect 'projects/:id/repository/revisions/:rev/diff.:format', :action => 'diff'
                    repository_views.connect 'projects/:id/repository/revisions/:rev/raw/*path', :action => 'entry', :format => 'raw', :requirements => { :rev => /[a-z0-9\.\-_]+/ }
                    repository_views.connect 'projects/:id/repository/revisions/:rev/:action/*path', :requirements => { :rev => /[a-z0-9\.\-_]+/ }
                    repository_views.connect 'projects/:id/repository/raw/*path', :action => 'entry', :format => 'raw'
                    # TODO: why the following route is required?
                    repository_views.connect 'projects/:id/repository/entry/*path', :action => 'entry'
                    repository_views.connect 'projects/:id/repository/:action/*path'
                  end
                  repositories.connect 'projects/:id/repository/:action', :conditions => {:method => :post}
                end
                map.connect 'attachments/:id', :controller => 'attachments', :action => 'show', :id => /\d+/
                map.connect 'attachments/:id/:filename', :controller => 'attachments', :action => 'show', :id => /\d+/, :filename => /.*/
                map.connect 'attachments/download/:id/:filename', :controller => 'attachments', :action => 'download', :id => /\d+/, :filename => /.*/
                map.resources :groups
                #left old routes at the bottom for backwards compat
                map.connect 'projects/:project_id/issues/:action', :controller => 'issues'
                map.connect 'projects/:project_id/documents/:action', :controller => 'documents'
                map.connect 'projects/:project_id/boards/:action/:id', :controller => 'boards'
                map.connect 'boards/:board_id/topics/:action/:id', :controller => 'messages'
                map.connect 'wiki/:id/:page/:action', :page => nil, :controller => 'wiki'
                map.connect 'issues/:issue_id/relations/:action/:id', :controller => 'issue_relations'
                map.connect 'projects/:project_id/news/:action', :controller => 'news'
                map.connect 'projects/:project_id/timelog/:action/:id', :controller => 'timelog', :project_id => /.+/
                map.with_options :controller => 'repositories' do |omap|
                  omap.repositories_show 'repositories/browse/:id/*path', :action => 'browse'
                  omap.repositories_changes 'repositories/changes/:id/*path', :action => 'changes'
                  omap.repositories_diff 'repositories/diff/:id/*path', :action => 'diff'
                  omap.repositories_entry 'repositories/entry/:id/*path', :action => 'entry'
                  omap.repositories_entry 'repositories/annotate/:id/*path', :action => 'annotate'
                  omap.connect 'repositories/revision/:id/:rev', :action => 'revision'
                end
                map.with_options :controller => 'sys' do |sys|
                  sys.connect 'sys/projects.:format', :action => 'projects', :conditions => {:method => :get}
                  sys.connect 'sys/projects/:id/repository.:format', :action => 'create_project_repository', :conditions => {:method => :post}
                end
                # Install the default route as the lowest priority.
                map.connect ':controller/:action/:id'
                map.connect 'robots.txt', :controller => 'welcome', :action => 'robots'
                # Used for OpenID
                map.root :controller => 'account', :action => 'login'
              end

lib/redmine.rb +1 -1

              require 'redmine/access_control'
              require 'redmine/menu_manager'
              require 'redmine/activity'
              require 'redmine/search'
              require 'redmine/custom_field_format'
              require 'redmine/mime_type'
              require 'redmine/core_ext'
              require 'redmine/themes'
              require 'redmine/hook'
              require 'redmine/plugin'
              require 'redmine/wiki_formatting'
              require 'redmine/scm/base'
              begin
                require_library_or_gem 'RMagick' unless Object.const_defined?(:Magick)
              rescue LoadError
                # RMagick is not available
              end
              if RUBY_VERSION < '1.9'
                require 'faster_csv'
              else
                require 'csv'
                FCSV = CSV
              end
              Redmine::Scm::Base.add "Subversion"
              Redmine::Scm::Base.add "Darcs"
              Redmine::Scm::Base.add "Mercurial"
              Redmine::Scm::Base.add "Cvs"
              Redmine::Scm::Base.add "Bazaar"
              Redmine::Scm::Base.add "Git"
              Redmine::Scm::Base.add "Filesystem"
              Redmine::CustomFieldFormat.map do |fields|
                fields.register Redmine::CustomFieldFormat.new('string', :label => :label_string, :order => 1)
                fields.register Redmine::CustomFieldFormat.new('text', :label => :label_text, :order => 2)
                fields.register Redmine::CustomFieldFormat.new('int', :label => :label_integer, :order => 3)
                fields.register Redmine::CustomFieldFormat.new('float', :label => :label_float, :order => 4)
                fields.register Redmine::CustomFieldFormat.new('list', :label => :label_list, :order => 5)
                fields.register Redmine::CustomFieldFormat.new('date', :label => :label_date, :order => 6)
                fields.register Redmine::CustomFieldFormat.new('bool', :label => :label_boolean, :order => 7)
              end
              # Permissions
              Redmine::AccessControl.map do |map|
                map.permission :view_project, {:projects => [:show], :activities => [:index]}, :public => true
                map.permission :search_project, {:search => :index}, :public => true
                map.permission :add_project, {:projects => [:new, :create]}, :require => :loggedin
                map.permission :edit_project, {:projects => [:settings, :edit, :update]}, :require => :member
                map.permission :select_project_modules, {:projects => :modules}, :require => :member
                map.permission :manage_members, {:projects => :settings, :members => [:new, :edit, :destroy, :autocomplete_for_member]}, :require => :member
                map.permission :manage_versions, {:projects => :settings, :versions => [:new, :edit, :close_completed, :destroy]}, :require => :member
                map.permission :add_subprojects, {:projects => [:new, :create]}, :require => :member
                map.project_module :issue_tracking do |map|
                  # Issue categories
                  map.permission :manage_categories, {:projects => :settings, :issue_categories => [:new, :edit, :destroy]}, :require => :member
                  # Issues
                  map.permission :view_issues, {:issues => [:index, :show],
                                                :auto_complete => [:issues],
                                                :context_menus => [:issues],
                                                :versions => [:index, :show, :status_by],
                                                :journals => :index,
                                                :queries => :index,
                                                :reports => [:issue_report, :issue_report_details]}
                  map.permission :add_issues, {:issues => [:new, :create, :update_form]}
                  map.permission :edit_issues, {:issues => [:edit, :update, :bulk_edit, :bulk_update, :update_form], :journals => [:new]}
                  map.permission :manage_issue_relations, {:issue_relations => [:new, :destroy]}
                  map.permission :manage_subtasks, {}
                  map.permission :add_issue_notes, {:issues => [:edit, :update], :journals => [:new]}
                  map.permission :edit_issue_notes, {:journals => :edit}, :require => :loggedin
                  map.permission :edit_own_issue_notes, {:journals => :edit}, :require => :loggedin
                  map.permission :move_issues, {:issue_moves => [:new, :create]}, :require => :loggedin
                  map.permission :delete_issues, {:issues => :destroy}, :require => :member
                  # Queries
                  map.permission :manage_public_queries, {:queries => [:new, :edit, :destroy]}, :require => :member
                  map.permission :save_queries, {:queries => [:new, :edit, :destroy]}, :require => :loggedin
                  # Watchers
                  map.permission :view_issue_watchers, {}
                  map.permission :add_issue_watchers, {:watchers => :new}
                  map.permission :delete_issue_watchers, {:watchers => :destroy}
                end
                map.project_module :time_tracking do |map|
                  map.permission :log_time, {:timelog => :edit}, :require => :loggedin
                  map.permission :view_time_entries, :timelog => [:details, :report]
                  map.permission :edit_time_entries, {:timelog => [:edit, :destroy]}, :require => :member
                  map.permission :edit_own_time_entries, {:timelog => [:edit, :destroy]}, :require => :loggedin
-                 map.permission :manage_project_activities, {:project_enumerations => [:save, :destroy]}, :require => :member
+                 map.permission :manage_project_activities, {:project_enumerations => [:update, :destroy]}, :require => :member
                end
                map.project_module :news do |map|
                  map.permission :manage_news, {:news => [:new, :edit, :destroy, :destroy_comment]}, :require => :member
                  map.permission :view_news, {:news => [:index, :show]}, :public => true
                  map.permission :comment_news, {:news => :add_comment}
                end
                map.project_module :documents do |map|
                  map.permission :manage_documents, {:documents => [:new, :edit, :destroy, :add_attachment]}, :require => :loggedin
                  map.permission :view_documents, :documents => [:index, :show, :download]
                end
                map.project_module :files do |map|
                  map.permission :manage_files, {:files => :new}, :require => :loggedin
                  map.permission :view_files, :files => :index, :versions => :download
                end
                map.project_module :wiki do |map|
                  map.permission :manage_wiki, {:wikis => [:edit, :destroy]}, :require => :member
                  map.permission :rename_wiki_pages, {:wiki => :rename}, :require => :member
                  map.permission :delete_wiki_pages, {:wiki => :destroy}, :require => :member
                  map.permission :view_wiki_pages, :wiki => [:index, :special]
                  map.permission :export_wiki_pages, {}
                  map.permission :view_wiki_edits, :wiki => [:history, :diff, :annotate]
                  map.permission :edit_wiki_pages, :wiki => [:edit, :preview, :add_attachment]
                  map.permission :delete_wiki_pages_attachments, {}
                  map.permission :protect_wiki_pages, {:wiki => :protect}, :require => :member
                end
                map.project_module :repository do |map|
                  map.permission :manage_repository, {:repositories => [:edit, :committers, :destroy]}, :require => :member
                  map.permission :browse_repository, :repositories => [:show, :browse, :entry, :annotate, :changes, :diff, :stats, :graph]
                  map.permission :view_changesets, :repositories => [:show, :revisions, :revision]
                  map.permission :commit_access, {}
                end
                map.project_module :boards do |map|
                  map.permission :manage_boards, {:boards => [:new, :edit, :destroy]}, :require => :member
                  map.permission :view_messages, {:boards => [:index, :show], :messages => [:show]}, :public => true
                  map.permission :add_messages, {:messages => [:new, :reply, :quote]}
                  map.permission :edit_messages, {:messages => :edit}, :require => :member
                  map.permission :edit_own_messages, {:messages => :edit}, :require => :loggedin
                  map.permission :delete_messages, {:messages => :destroy}, :require => :member
                  map.permission :delete_own_messages, {:messages => :destroy}, :require => :loggedin
                end
                map.project_module :calendar do |map|
                  map.permission :view_calendar, :calendars => [:show, :update]
                end
                map.project_module :gantt do |map|
                  map.permission :view_gantt, :gantts => [:show, :update]
                end
              end
              Redmine::MenuManager.map :top_menu do |menu|
                menu.push :home, :home_path
                menu.push :my_page, { :controller => 'my', :action => 'page' }, :if => Proc.new { User.current.logged? }
                menu.push :projects, { :controller => 'projects', :action => 'index' }, :caption => :label_project_plural
                menu.push :administration, { :controller => 'admin', :action => 'index' }, :if => Proc.new { User.current.admin? }, :last => true
                menu.push :help, Redmine::Info.help_url, :last => true
              end
              Redmine::MenuManager.map :account_menu do |menu|
                menu.push :login, :signin_path, :if => Proc.new { !User.current.logged? }
                menu.push :register, { :controller => 'account', :action => 'register' }, :if => Proc.new { !User.current.logged? && Setting.self_registration? }
                menu.push :my_account, { :controller => 'my', :action => 'account' }, :if => Proc.new { User.current.logged? }
                menu.push :logout, :signout_path, :if => Proc.new { User.current.logged? }
              end
              Redmine::MenuManager.map :application_menu do |menu|
                # Empty
              end
              Redmine::MenuManager.map :admin_menu do |menu|
                menu.push :projects, {:controller => 'admin', :action => 'projects'}, :caption => :label_project_plural
                menu.push :users, {:controller => 'users'}, :caption => :label_user_plural
                menu.push :groups, {:controller => 'groups'}, :caption => :label_group_plural
                menu.push :roles, {:controller => 'roles'}, :caption => :label_role_and_permissions
                menu.push :trackers, {:controller => 'trackers'}, :caption => :label_tracker_plural
                menu.push :issue_statuses, {:controller => 'issue_statuses'}, :caption => :label_issue_status_plural,
                          :html => {:class => 'issue_statuses'}
                menu.push :workflows, {:controller => 'workflows', :action => 'edit'}, :caption => :label_workflow
                menu.push :custom_fields, {:controller => 'custom_fields'},  :caption => :label_custom_field_plural,
                          :html => {:class => 'custom_fields'}
                menu.push :enumerations, {:controller => 'enumerations'}
                menu.push :settings, {:controller => 'settings'}
                menu.push :ldap_authentication, {:controller => 'ldap_auth_sources', :action => 'index'},
                          :html => {:class => 'server_authentication'}
                menu.push :plugins, {:controller => 'admin', :action => 'plugins'}, :last => true
                menu.push :info, {:controller => 'admin', :action => 'info'}, :caption => :label_information_plural, :last => true
              end
              Redmine::MenuManager.map :project_menu do |menu|
                menu.push :overview, { :controller => 'projects', :action => 'show' }
                menu.push :activity, { :controller => 'activities', :action => 'index' }
                menu.push :roadmap, { :controller => 'versions', :action => 'index' }, :param => :project_id,
                            :if => Proc.new { |p| p.shared_versions.any? }
                menu.push :issues, { :controller => 'issues', :action => 'index' }, :param => :project_id, :caption => :label_issue_plural
                menu.push :new_issue, { :controller => 'issues', :action => 'new' }, :param => :project_id, :caption => :label_issue_new,
                            :html => { :accesskey => Redmine::AccessKeys.key_for(:new_issue) }
                menu.push :gantt, { :controller => 'gantts', :action => 'show' }, :param => :project_id, :caption => :label_gantt
                menu.push :calendar, { :controller => 'calendars', :action => 'show' }, :param => :project_id, :caption => :label_calendar
                menu.push :news, { :controller => 'news', :action => 'index' }, :param => :project_id, :caption => :label_news_plural
                menu.push :documents, { :controller => 'documents', :action => 'index' }, :param => :project_id, :caption => :label_document_plural
                menu.push :wiki, { :controller => 'wiki', :action => 'index', :page => nil },
                            :if => Proc.new { |p| p.wiki && !p.wiki.new_record? }
                menu.push :boards, { :controller => 'boards', :action => 'index', :id => nil }, :param => :project_id,
                            :if => Proc.new { |p| p.boards.any? }, :caption => :label_board_plural
                menu.push :files, { :controller => 'files', :action => 'index' }, :caption => :label_file_plural
                menu.push :repository, { :controller => 'repositories', :action => 'show' },
                            :if => Proc.new { |p| p.repository && !p.repository.new_record? }
                menu.push :settings, { :controller => 'projects', :action => 'settings' }, :last => true
              end
              Redmine::Activity.map do |activity|
                activity.register :issues, :class_name => %w(Issue Journal)
                activity.register :changesets
                activity.register :news
                activity.register :documents, :class_name => %w(Document Attachment)
                activity.register :files, :class_name => 'Attachment'
                activity.register :wiki_edits, :class_name => 'WikiContent::Version', :default => false
                activity.register :messages, :default => false
                activity.register :time_entries, :default => false
              end
              Redmine::Search.map do |search|
                search.register :issues
                search.register :news
                search.register :documents
                search.register :changesets
                search.register :wiki_pages
                search.register :messages
                search.register :projects
              end
              Redmine::WikiFormatting.map do |format|
                format.register :textile, Redmine::WikiFormatting::Textile::Formatter, Redmine::WikiFormatting::Textile::Helper
              end

test/functional/project_enumerations_controller_test.rb +11 -11

              require File.dirname(__FILE__) + '/../test_helper'
              class ProjectEnumerationsControllerTest < ActionController::TestCase
                fixtures :all
                def setup
                  @request.session[:user_id] = nil
                  Setting.default_language = 'en'
                end
-               def test_save_to_override_system_activities
+               def test_update_to_override_system_activities
                  @request.session[:user_id] = 2 # manager
                  billable_field = TimeEntryActivityCustomField.find_by_name("Billable")
-                 post :save, :id => 1, :enumerations => {
+                 put :update, :project_id => 1, :enumerations => {
                    "9"=> {"parent_id"=>"9", "custom_field_values"=>{"7" => "1"}, "active"=>"0"}, # Design, De-activate
                    "10"=> {"parent_id"=>"10", "custom_field_values"=>{"7"=>"0"}, "active"=>"1"}, # Development, Change custom value
                    "14"=>{"parent_id"=>"14", "custom_field_values"=>{"7"=>"1"}, "active"=>"1"}, # Inactive Activity, Activate with custom value
                    "11"=>{"parent_id"=>"11", "custom_field_values"=>{"7"=>"1"}, "active"=>"1"} # QA, no changes
                  }
                  assert_response :redirect
                  assert_redirected_to 'projects/ecookbook/settings/activities'
                  # Created project specific activities...
                  project = Project.find('ecookbook')
                  # ... Design
                  design = project.time_entry_activities.find_by_name("Design")
                  assert design, "Project activity not found"
                  assert_equal 9, design.parent_id # Relate to the system activity
                  assert_not_equal design.parent.id, design.id # Different records
                  assert_equal design.parent.name, design.name # Same name
                  assert !design.active?
                  # ... Development
                  development = project.time_entry_activities.find_by_name("Development")
                  assert development, "Project activity not found"
                  assert_equal 10, development.parent_id # Relate to the system activity
                  assert_not_equal development.parent.id, development.id # Different records
                  assert_equal development.parent.name, development.name # Same name
                  assert development.active?
                  assert_equal "0", development.custom_value_for(billable_field).value
                  # ... Inactive Activity
                  previously_inactive = project.time_entry_activities.find_by_name("Inactive Activity")
                  assert previously_inactive, "Project activity not found"
                  assert_equal 14, previously_inactive.parent_id # Relate to the system activity
                  assert_not_equal previously_inactive.parent.id, previously_inactive.id # Different records
                  assert_equal previously_inactive.parent.name, previously_inactive.name # Same name
                  assert previously_inactive.active?
                  assert_equal "1", previously_inactive.custom_value_for(billable_field).value
                  # ... QA
                  assert_equal nil, project.time_entry_activities.find_by_name("QA"), "Custom QA activity created when it wasn't modified"
                end
-               def test_save_will_update_project_specific_activities
+               def test_update_will_update_project_specific_activities
                  @request.session[:user_id] = 2 # manager
                  project_activity = TimeEntryActivity.new({
                                                             :name => 'Project Specific',
                                                             :parent => TimeEntryActivity.find(:first),
                                                             :project => Project.find(1),
                                                             :active => true
                                                           })
                  assert project_activity.save
                  project_activity_two = TimeEntryActivity.new({
                                                                 :name => 'Project Specific Two',
                                                                 :parent => TimeEntryActivity.find(:last),
                                                                 :project => Project.find(1),
                                                                 :active => true
                                                               })
                  assert project_activity_two.save
-                 post :save, :id => 1, :enumerations => {
+                 put :update, :project_id => 1, :enumerations => {
                    project_activity.id => {"custom_field_values"=>{"7" => "1"}, "active"=>"0"}, # De-activate
                    project_activity_two.id => {"custom_field_values"=>{"7" => "1"}, "active"=>"0"} # De-activate
                  }
                  assert_response :redirect
                  assert_redirected_to 'projects/ecookbook/settings/activities'
                  # Created project specific activities...
                  project = Project.find('ecookbook')
                  assert_equal 2, project.time_entry_activities.count
                  activity_one = project.time_entry_activities.find_by_name(project_activity.name)
                  assert activity_one, "Project activity not found"
                  assert_equal project_activity.id, activity_one.id
                  assert !activity_one.active?
                  activity_two = project.time_entry_activities.find_by_name(project_activity_two.name)
                  assert activity_two, "Project activity not found"
                  assert_equal project_activity_two.id, activity_two.id
                  assert !activity_two.active?
                end
-               def test_save_when_creating_new_activities_will_convert_existing_data
+               def test_update_when_creating_new_activities_will_convert_existing_data
                  assert_equal 3, TimeEntry.find_all_by_activity_id_and_project_id(9, 1).size
                  @request.session[:user_id] = 2 # manager
-                 post :save, :id => 1, :enumerations => {
+                 put :update, :project_id => 1, :enumerations => {
                    "9"=> {"parent_id"=>"9", "custom_field_values"=>{"7" => "1"}, "active"=>"0"} # Design, De-activate
                  }
                  assert_response :redirect
                  # No more TimeEntries using the system activity
                  assert_equal 0, TimeEntry.find_all_by_activity_id_and_project_id(9, 1).size, "Time Entries still assigned to system activities"
                  # All TimeEntries using project activity
                  project_specific_activity = TimeEntryActivity.find_by_parent_id_and_project_id(9, 1)
                  assert_equal 3, TimeEntry.find_all_by_activity_id_and_project_id(project_specific_activity.id, 1).size, "No Time Entries assigned to the project activity"
                end
-               def test_save_when_creating_new_activities_will_not_convert_existing_data_if_an_exception_is_raised
+               def test_update_when_creating_new_activities_will_not_convert_existing_data_if_an_exception_is_raised
                  # TODO: Need to cause an exception on create but these tests
                  # aren't setup for mocking.  Just create a record now so the
                  # second one is a dupicate
                  parent = TimeEntryActivity.find(9)
                  TimeEntryActivity.create!({:name => parent.name, :project_id => 1, :position => parent.position, :active => true})
                  TimeEntry.create!({:project_id => 1, :hours => 1.0, :user => User.find(1), :issue_id => 3, :activity_id => 10, :spent_on => '2009-01-01'})
                  assert_equal 3, TimeEntry.find_all_by_activity_id_and_project_id(9, 1).size
                  assert_equal 1, TimeEntry.find_all_by_activity_id_and_project_id(10, 1).size
                  @request.session[:user_id] = 2 # manager
-                 post :save, :id => 1, :enumerations => {
+                 put :update, :project_id => 1, :enumerations => {
                    "9"=> {"parent_id"=>"9", "custom_field_values"=>{"7" => "1"}, "active"=>"0"}, # Design
                    "10"=> {"parent_id"=>"10", "custom_field_values"=>{"7"=>"0"}, "active"=>"1"} # Development, Change custom value
                  }
                  assert_response :redirect
                  # TimeEntries shouldn't have been reassigned on the failed record
                  assert_equal 3, TimeEntry.find_all_by_activity_id_and_project_id(9, 1).size, "Time Entries are not assigned to system activities"
                  # TimeEntries shouldn't have been reassigned on the saved record either
                  assert_equal 1, TimeEntry.find_all_by_activity_id_and_project_id(10, 1).size, "Time Entries are not assigned to system activities"
                end
-                 def test_destroy
+               def test_destroy
                  @request.session[:user_id] = 2 # manager
                  project_activity = TimeEntryActivity.new({
                                                             :name => 'Project Specific',
                                                             :parent => TimeEntryActivity.find(:first),
                                                             :project => Project.find(1),
                                                             :active => true
                                                           })
                  assert project_activity.save
                  project_activity_two = TimeEntryActivity.new({
                                                                 :name => 'Project Specific Two',
                                                                 :parent => TimeEntryActivity.find(:last),
                                                                 :project => Project.find(1),
                                                                 :active => true
                                                               })
                  assert project_activity_two.save
-                 delete :destroy, :id => 1
+                 delete :destroy, :project_id => 1
                  assert_response :redirect
                  assert_redirected_to 'projects/ecookbook/settings/activities'
                  assert_nil TimeEntryActivity.find_by_id(project_activity.id)
                  assert_nil TimeEntryActivity.find_by_id(project_activity_two.id)
                end
                def test_destroy_should_reassign_time_entries_back_to_the_system_activity
                  @request.session[:user_id] = 2 # manager
                  project_activity = TimeEntryActivity.new({
                                                             :name => 'Project Specific Design',
                                                             :parent => TimeEntryActivity.find(9),
                                                             :project => Project.find(1),
                                                             :active => true
                                                           })
                  assert project_activity.save
                  assert TimeEntry.update_all("activity_id = '#{project_activity.id}'", ["project_id = ? AND activity_id = ?", 1, 9])
                  assert 3, TimeEntry.find_all_by_activity_id_and_project_id(project_activity.id, 1).size
-                 delete :destroy, :id => 1
+                 delete :destroy, :project_id => 1
                  assert_response :redirect
                  assert_redirected_to 'projects/ecookbook/settings/activities'
                  assert_nil TimeEntryActivity.find_by_id(project_activity.id)
                  assert_equal 0, TimeEntry.find_all_by_activity_id_and_project_id(project_activity.id, 1).size, "TimeEntries still assigned to project specific activity"
                  assert_equal 3, TimeEntry.find_all_by_activity_id_and_project_id(9, 1).size, "TimeEntries still assigned to project specific activity"
                end
              end

test/integration/routing_test.rb +2 -2

              # redMine - project management software
              # Copyright (C) 2006-2010  Jean-Philippe Lang
              #
              # 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 2
              # 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, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require "#{File.dirname(__FILE__)}/../test_helper"
              class RoutingTest < ActionController::IntegrationTest
                context "activities" do
                  should_route :get, "/activity", :controller => 'activities', :action => 'index', :id => nil
                  should_route :get, "/activity.atom", :controller => 'activities', :action => 'index', :id => nil, :format => 'atom'
                end
                context "attachments" do
                  should_route :get, "/attachments/1", :controller => 'attachments', :action => 'show', :id => '1'
                  should_route :get, "/attachments/1/filename.ext", :controller => 'attachments', :action => 'show', :id => '1', :filename => 'filename.ext'
                  should_route :get, "/attachments/download/1", :controller => 'attachments', :action => 'download', :id => '1'
                  should_route :get, "/attachments/download/1/filename.ext", :controller => 'attachments', :action => 'download', :id => '1', :filename => 'filename.ext'
                end
                context "boards" do
                  should_route :get, "/projects/world_domination/boards", :controller => 'boards', :action => 'index', :project_id => 'world_domination'
                  should_route :get, "/projects/world_domination/boards/new", :controller => 'boards', :action => 'new', :project_id => 'world_domination'
                  should_route :get, "/projects/world_domination/boards/44", :controller => 'boards', :action => 'show', :project_id => 'world_domination', :id => '44'
                  should_route :get, "/projects/world_domination/boards/44.atom", :controller => 'boards', :action => 'show', :project_id => 'world_domination', :id => '44', :format => 'atom'
                  should_route :get, "/projects/world_domination/boards/44/edit", :controller => 'boards', :action => 'edit', :project_id => 'world_domination', :id => '44'
                  should_route :post, "/projects/world_domination/boards/new", :controller => 'boards', :action => 'new', :project_id => 'world_domination'
                  should_route :post, "/projects/world_domination/boards/44/edit", :controller => 'boards', :action => 'edit', :project_id => 'world_domination', :id => '44'
                  should_route :post, "/projects/world_domination/boards/44/destroy", :controller => 'boards', :action => 'destroy', :project_id => 'world_domination', :id => '44'
                end
                context "documents" do
                  should_route :get, "/projects/567/documents", :controller => 'documents', :action => 'index', :project_id => '567'
                  should_route :get, "/projects/567/documents/new", :controller => 'documents', :action => 'new', :project_id => '567'
                  should_route :get, "/documents/22", :controller => 'documents', :action => 'show', :id => '22'
                  should_route :get, "/documents/22/edit", :controller => 'documents', :action => 'edit', :id => '22'
                  should_route :post, "/projects/567/documents/new", :controller => 'documents', :action => 'new', :project_id => '567'
                  should_route :post, "/documents/567/edit", :controller => 'documents', :action => 'edit', :id => '567'
                  should_route :post, "/documents/567/destroy", :controller => 'documents', :action => 'destroy', :id => '567'
                end
                context "issues" do
                  # REST actions
                  should_route :get, "/issues", :controller => 'issues', :action => 'index'
                  should_route :get, "/issues.pdf", :controller => 'issues', :action => 'index', :format => 'pdf'
                  should_route :get, "/issues.atom", :controller => 'issues', :action => 'index', :format => 'atom'
                  should_route :get, "/issues.xml", :controller => 'issues', :action => 'index', :format => 'xml'
                  should_route :get, "/projects/23/issues", :controller => 'issues', :action => 'index', :project_id => '23'
                  should_route :get, "/projects/23/issues.pdf", :controller => 'issues', :action => 'index', :project_id => '23', :format => 'pdf'
                  should_route :get, "/projects/23/issues.atom", :controller => 'issues', :action => 'index', :project_id => '23', :format => 'atom'
                  should_route :get, "/projects/23/issues.xml", :controller => 'issues', :action => 'index', :project_id => '23', :format => 'xml'
                  should_route :get, "/issues/64", :controller => 'issues', :action => 'show', :id => '64'
                  should_route :get, "/issues/64.pdf", :controller => 'issues', :action => 'show', :id => '64', :format => 'pdf'
                  should_route :get, "/issues/64.atom", :controller => 'issues', :action => 'show', :id => '64', :format => 'atom'
                  should_route :get, "/issues/64.xml", :controller => 'issues', :action => 'show', :id => '64', :format => 'xml'
                  should_route :get, "/projects/23/issues/new", :controller => 'issues', :action => 'new', :project_id => '23'
                  should_route :post, "/projects/23/issues", :controller => 'issues', :action => 'create', :project_id => '23'
                  should_route :post, "/issues.xml", :controller => 'issues', :action => 'create', :format => 'xml'
                  should_route :get, "/issues/64/edit", :controller => 'issues', :action => 'edit', :id => '64'
                  # TODO: Should use PUT
                  should_route :post, "/issues/64/edit", :controller => 'issues', :action => 'edit', :id => '64'
                  should_route :put, "/issues/1.xml", :controller => 'issues', :action => 'update', :id => '1', :format => 'xml'
                  # TODO: Should use DELETE
                  should_route :post, "/issues/64/destroy", :controller => 'issues', :action => 'destroy', :id => '64'
                  should_route :delete, "/issues/1.xml", :controller => 'issues', :action => 'destroy', :id => '1', :format => 'xml'
                  # Extra actions
                  should_route :get, "/projects/23/issues/64/copy", :controller => 'issues', :action => 'new', :project_id => '23', :copy_from => '64'
                  should_route :get, "/issues/move/new", :controller => 'issue_moves', :action => 'new'
                  should_route :post, "/issues/move", :controller => 'issue_moves', :action => 'create'
                  should_route :post, "/issues/1/quoted", :controller => 'journals', :action => 'new', :id => '1'
                  should_route :get, "/issues/calendar", :controller => 'calendars', :action => 'show'
                  should_route :put, "/issues/calendar", :controller => 'calendars', :action => 'update'
                  should_route :get, "/projects/project-name/issues/calendar", :controller => 'calendars', :action => 'show', :project_id => 'project-name'
                  should_route :put, "/projects/project-name/issues/calendar", :controller => 'calendars', :action => 'update', :project_id => 'project-name'
                  should_route :get, "/issues/gantt", :controller => 'gantts', :action => 'show'
                  should_route :put, "/issues/gantt", :controller => 'gantts', :action => 'update'
                  should_route :get, "/projects/project-name/issues/gantt", :controller => 'gantts', :action => 'show', :project_id => 'project-name'
                  should_route :put, "/projects/project-name/issues/gantt", :controller => 'gantts', :action => 'update', :project_id => 'project-name'
                  should_route :get, "/issues/auto_complete", :controller => 'auto_completes', :action => 'issues'
                  should_route :get, "/issues/preview/123", :controller => 'previews', :action => 'issue', :id => '123'
                  should_route :post, "/issues/preview/123", :controller => 'previews', :action => 'issue', :id => '123'
                  should_route :get, "/issues/context_menu", :controller => 'context_menus', :action => 'issues'
                  should_route :post, "/issues/context_menu", :controller => 'context_menus', :action => 'issues'
                  should_route :get, "/issues/changes", :controller => 'journals', :action => 'index'
                  should_route :get, "/issues/bulk_edit", :controller => 'issues', :action => 'bulk_edit'
                  should_route :post, "/issues/bulk_edit", :controller => 'issues', :action => 'bulk_update'
                end
                context "issue categories" do
                  should_route :get, "/projects/test/issue_categories/new", :controller => 'issue_categories', :action => 'new', :project_id => 'test'
                  should_route :post, "/projects/test/issue_categories/new", :controller => 'issue_categories', :action => 'new', :project_id => 'test'
                end
                context "issue relations" do
                  should_route :post, "/issues/1/relations", :controller => 'issue_relations', :action => 'new', :issue_id => '1'
                  should_route :post, "/issues/1/relations/23/destroy", :controller => 'issue_relations', :action => 'destroy', :issue_id => '1', :id => '23'
                end
                context "issue reports" do
                  should_route :get, "/projects/567/issues/report", :controller => 'reports', :action => 'issue_report', :id => '567'
                  should_route :get, "/projects/567/issues/report/assigned_to", :controller => 'reports', :action => 'issue_report_details', :id => '567', :detail => 'assigned_to'
                end
                context "members" do
                  should_route :post, "/projects/5234/members/new", :controller => 'members', :action => 'new', :id => '5234'
                end
                context "messages" do
                  should_route :get, "/boards/22/topics/2", :controller => 'messages', :action => 'show', :id => '2', :board_id => '22'
                  should_route :get, "/boards/lala/topics/new", :controller => 'messages', :action => 'new', :board_id => 'lala'
                  should_route :get, "/boards/lala/topics/22/edit", :controller => 'messages', :action => 'edit', :id => '22', :board_id => 'lala'
                  should_route :post, "/boards/lala/topics/new", :controller => 'messages', :action => 'new', :board_id => 'lala'
                  should_route :post, "/boards/lala/topics/22/edit", :controller => 'messages', :action => 'edit', :id => '22', :board_id => 'lala'
                  should_route :post, "/boards/22/topics/555/replies", :controller => 'messages', :action => 'reply', :id => '555', :board_id => '22'
                  should_route :post, "/boards/22/topics/555/destroy", :controller => 'messages', :action => 'destroy', :id => '555', :board_id => '22'
                end
                context "news" do
                  should_route :get, "/news", :controller => 'news', :action => 'index'
                  should_route :get, "/news.atom", :controller => 'news', :action => 'index', :format => 'atom'
                  should_route :get, "/news.xml", :controller => 'news', :action => 'index', :format => 'xml'
                  should_route :get, "/news.json", :controller => 'news', :action => 'index', :format => 'json'
                  should_route :get, "/projects/567/news", :controller => 'news', :action => 'index', :project_id => '567'
                  should_route :get, "/projects/567/news.atom", :controller => 'news', :action => 'index', :format => 'atom', :project_id => '567'
                  should_route :get, "/projects/567/news.xml", :controller => 'news', :action => 'index', :format => 'xml', :project_id => '567'
                  should_route :get, "/projects/567/news.json", :controller => 'news', :action => 'index', :format => 'json', :project_id => '567'
                  should_route :get, "/news/2", :controller => 'news', :action => 'show', :id => '2'
                  should_route :get, "/projects/567/news/new", :controller => 'news', :action => 'new', :project_id => '567'
                  should_route :get, "/news/234", :controller => 'news', :action => 'show', :id => '234'
                  should_route :post, "/projects/567/news/new", :controller => 'news', :action => 'new', :project_id => '567'
                  should_route :post, "/news/567/edit", :controller => 'news', :action => 'edit', :id => '567'
                  should_route :post, "/news/567/destroy", :controller => 'news', :action => 'destroy', :id => '567'
                end
                context "projects" do
                  should_route :get, "/projects", :controller => 'projects', :action => 'index'
                  should_route :get, "/projects.atom", :controller => 'projects', :action => 'index', :format => 'atom'
                  should_route :get, "/projects.xml", :controller => 'projects', :action => 'index', :format => 'xml'
                  should_route :get, "/projects/new", :controller => 'projects', :action => 'new'
                  should_route :get, "/projects/test", :controller => 'projects', :action => 'show', :id => 'test'
                  should_route :get, "/projects/1.xml", :controller => 'projects', :action => 'show', :id => '1', :format => 'xml'
                  should_route :get, "/projects/4223/settings", :controller => 'projects', :action => 'settings', :id => '4223'
                  should_route :get, "/projects/4223/settings/members", :controller => 'projects', :action => 'settings', :id => '4223', :tab => 'members'
                  should_route :get, "/projects/33/files", :controller => 'files', :action => 'index', :id => '33'
                  should_route :get, "/projects/33/files/new", :controller => 'files', :action => 'new', :id => '33'
                  should_route :get, "/projects/33/roadmap", :controller => 'versions', :action => 'index', :project_id => '33'
                  should_route :get, "/projects/33/activity", :controller => 'activities', :action => 'index', :id => '33'
                  should_route :get, "/projects/33/activity.atom", :controller => 'activities', :action => 'index', :id => '33', :format => 'atom'
                  should_route :post, "/projects", :controller => 'projects', :action => 'create'
                  should_route :post, "/projects.xml", :controller => 'projects', :action => 'create', :format => 'xml'
                  should_route :post, "/projects/33/files/new", :controller => 'files', :action => 'new', :id => '33'
                  should_route :post, "/projects/64/archive", :controller => 'projects', :action => 'archive', :id => '64'
                  should_route :post, "/projects/64/unarchive", :controller => 'projects', :action => 'unarchive', :id => '64'
-                 should_route :post, "/projects/64/activities/save", :controller => 'project_enumerations', :action => 'save', :id => '64'
+                 should_route :put, "/projects/64/enumerations", :controller => 'project_enumerations', :action => 'update', :project_id => '64'
                  should_route :put, "/projects/4223", :controller => 'projects', :action => 'update', :id => '4223'
                  should_route :put, "/projects/1.xml", :controller => 'projects', :action => 'update', :id => '1', :format => 'xml'
                  should_route :delete, "/projects/64", :controller => 'projects', :action => 'destroy', :id => '64'
                  should_route :delete, "/projects/1.xml", :controller => 'projects', :action => 'destroy', :id => '1', :format => 'xml'
-                 should_route :delete, "/projects/64/reset_activities", :controller => 'project_enumerations', :action => 'destroy', :id => '64'
+                 should_route :delete, "/projects/64/enumerations", :controller => 'project_enumerations', :action => 'destroy', :project_id => '64'
                end
                context "repositories" do
                  should_route :get, "/projects/redmine/repository", :controller => 'repositories', :action => 'show', :id => 'redmine'
                  should_route :get, "/projects/redmine/repository/edit", :controller => 'repositories', :action => 'edit', :id => 'redmine'
                  should_route :get, "/projects/redmine/repository/revisions", :controller => 'repositories', :action => 'revisions', :id => 'redmine'
                  should_route :get, "/projects/redmine/repository/revisions.atom", :controller => 'repositories', :action => 'revisions', :id => 'redmine', :format => 'atom'
                  should_route :get, "/projects/redmine/repository/revisions/2457", :controller => 'repositories', :action => 'revision', :id => 'redmine', :rev => '2457'
                  should_route :get, "/projects/redmine/repository/revisions/2457/diff", :controller => 'repositories', :action => 'diff', :id => 'redmine', :rev => '2457'
                  should_route :get, "/projects/redmine/repository/revisions/2457/diff.diff", :controller => 'repositories', :action => 'diff', :id => 'redmine', :rev => '2457', :format => 'diff'
                  should_route :get, "/projects/redmine/repository/diff/path/to/file.c", :controller => 'repositories', :action => 'diff', :id => 'redmine', :path => %w[path to file.c]
                  should_route :get, "/projects/redmine/repository/revisions/2/diff/path/to/file.c", :controller => 'repositories', :action => 'diff', :id => 'redmine', :path => %w[path to file.c], :rev => '2'
                  should_route :get, "/projects/redmine/repository/browse/path/to/file.c", :controller => 'repositories', :action => 'browse', :id => 'redmine', :path => %w[path to file.c]
                  should_route :get, "/projects/redmine/repository/entry/path/to/file.c", :controller => 'repositories', :action => 'entry', :id => 'redmine', :path => %w[path to file.c]
                  should_route :get, "/projects/redmine/repository/revisions/2/entry/path/to/file.c", :controller => 'repositories', :action => 'entry', :id => 'redmine', :path => %w[path to file.c], :rev => '2'
                  should_route :get, "/projects/redmine/repository/raw/path/to/file.c", :controller => 'repositories', :action => 'entry', :id => 'redmine', :path => %w[path to file.c], :format => 'raw'
                  should_route :get, "/projects/redmine/repository/revisions/2/raw/path/to/file.c", :controller => 'repositories', :action => 'entry', :id => 'redmine', :path => %w[path to file.c], :rev => '2', :format => 'raw'
                  should_route :get, "/projects/redmine/repository/annotate/path/to/file.c", :controller => 'repositories', :action => 'annotate', :id => 'redmine', :path => %w[path to file.c]
                  should_route :get, "/projects/redmine/repository/changes/path/to/file.c", :controller => 'repositories', :action => 'changes', :id => 'redmine', :path => %w[path to file.c]
                  should_route :get, "/projects/redmine/repository/statistics", :controller => 'repositories', :action => 'stats', :id => 'redmine'
                  should_route :post, "/projects/redmine/repository/edit", :controller => 'repositories', :action => 'edit', :id => 'redmine'
                end
                context "timelogs" do
                  should_route :get, "/issues/567/time_entries/new", :controller => 'timelog', :action => 'edit', :issue_id => '567'
                  should_route :get, "/projects/ecookbook/time_entries/new", :controller => 'timelog', :action => 'edit', :project_id => 'ecookbook'
                  should_route :get, "/projects/ecookbook/issues/567/time_entries/new", :controller => 'timelog', :action => 'edit', :project_id => 'ecookbook', :issue_id => '567'
                  should_route :get, "/time_entries/22/edit", :controller => 'timelog', :action => 'edit', :id => '22'
                  should_route :get, "/time_entries/report", :controller => 'timelog', :action => 'report'
                  should_route :get, "/projects/567/time_entries/report", :controller => 'timelog', :action => 'report', :project_id => '567'
                  should_route :get, "/projects/567/time_entries/report.csv", :controller => 'timelog', :action => 'report', :project_id => '567', :format => 'csv'
                  should_route :get, "/time_entries", :controller => 'timelog', :action => 'details'
                  should_route :get, "/time_entries.csv", :controller => 'timelog', :action => 'details', :format => 'csv'
                  should_route :get, "/time_entries.atom", :controller => 'timelog', :action => 'details', :format => 'atom'
                  should_route :get, "/projects/567/time_entries", :controller => 'timelog', :action => 'details', :project_id => '567'
                  should_route :get, "/projects/567/time_entries.csv", :controller => 'timelog', :action => 'details', :project_id => '567', :format => 'csv'
                  should_route :get, "/projects/567/time_entries.atom", :controller => 'timelog', :action => 'details', :project_id => '567', :format => 'atom'
                  should_route :get, "/issues/234/time_entries", :controller => 'timelog', :action => 'details', :issue_id => '234'
                  should_route :get, "/issues/234/time_entries.csv", :controller => 'timelog', :action => 'details', :issue_id => '234', :format => 'csv'
                  should_route :get, "/issues/234/time_entries.atom", :controller => 'timelog', :action => 'details', :issue_id => '234', :format => 'atom'
                  should_route :get, "/projects/ecookbook/issues/123/time_entries", :controller => 'timelog', :action => 'details', :project_id => 'ecookbook', :issue_id => '123'
                  should_route :post, "/time_entries/55/destroy", :controller => 'timelog', :action => 'destroy', :id => '55'
                end
                context "users" do
                  should_route :get, "/users", :controller => 'users', :action => 'index'
                  should_route :get, "/users/44", :controller => 'users', :action => 'show', :id => '44'
                  should_route :get, "/users/new", :controller => 'users', :action => 'add'
                  should_route :get, "/users/444/edit", :controller => 'users', :action => 'edit', :id => '444'
                  should_route :get, "/users/222/edit/membership", :controller => 'users', :action => 'edit', :id => '222', :tab => 'membership'
                  should_route :post, "/users/new", :controller => 'users', :action => 'add'
                  should_route :post, "/users/444/edit", :controller => 'users', :action => 'edit', :id => '444'
                  should_route :post, "/users/123/memberships", :controller => 'users', :action => 'edit_membership', :id => '123'
                  should_route :post, "/users/123/memberships/55", :controller => 'users', :action => 'edit_membership', :id => '123', :membership_id => '55'
                  should_route :post, "/users/567/memberships/12/destroy", :controller => 'users', :action => 'destroy_membership', :id => '567', :membership_id => '12'
                end
                context "versions" do
                  should_route :get, "/projects/foo/versions/new", :controller => 'versions', :action => 'new', :project_id => 'foo'
                  should_route :post, "/projects/foo/versions/new", :controller => 'versions', :action => 'new', :project_id => 'foo'
                end
                context "wiki (singular, project's pages)" do
                  should_route :get, "/projects/567/wiki", :controller => 'wiki', :action => 'index', :id => '567'
                  should_route :get, "/projects/567/wiki/lalala", :controller => 'wiki', :action => 'index', :id => '567', :page => 'lalala'
                  should_route :get, "/projects/567/wiki/my_page/edit", :controller => 'wiki', :action => 'edit', :id => '567', :page => 'my_page'
                  should_route :get, "/projects/1/wiki/CookBook_documentation/history", :controller => 'wiki', :action => 'history', :id => '1', :page => 'CookBook_documentation'
                  should_route :get, "/projects/1/wiki/CookBook_documentation/diff/2/vs/1", :controller => 'wiki', :action => 'diff', :id => '1', :page => 'CookBook_documentation', :version => '2', :version_from => '1'
                  should_route :get, "/projects/1/wiki/CookBook_documentation/annotate/2", :controller => 'wiki', :action => 'annotate', :id => '1', :page => 'CookBook_documentation', :version => '2'
                  should_route :get, "/projects/22/wiki/ladida/rename", :controller => 'wiki', :action => 'rename', :id => '22', :page => 'ladida'
                  should_route :get, "/projects/567/wiki/page_index", :controller => 'wiki', :action => 'special', :id => '567', :page => 'page_index'
                  should_route :get, "/projects/567/wiki/Page_Index", :controller => 'wiki', :action => 'special', :id => '567', :page => 'Page_Index'
                  should_route :get, "/projects/567/wiki/date_index", :controller => 'wiki', :action => 'special', :id => '567', :page => 'date_index'
                  should_route :get, "/projects/567/wiki/export", :controller => 'wiki', :action => 'special', :id => '567', :page => 'export'
                  should_route :post, "/projects/567/wiki/my_page/edit", :controller => 'wiki', :action => 'edit', :id => '567', :page => 'my_page'
                  should_route :post, "/projects/567/wiki/CookBook_documentation/preview", :controller => 'wiki', :action => 'preview', :id => '567', :page => 'CookBook_documentation'
                  should_route :post, "/projects/22/wiki/ladida/rename", :controller => 'wiki', :action => 'rename', :id => '22', :page => 'ladida'
                  should_route :post, "/projects/22/wiki/ladida/destroy", :controller => 'wiki', :action => 'destroy', :id => '22', :page => 'ladida'
                  should_route :post, "/projects/22/wiki/ladida/protect", :controller => 'wiki', :action => 'protect', :id => '22', :page => 'ladida'
                end
                context "wikis (plural, admin setup)" do
                  should_route :get, "/projects/ladida/wiki/destroy", :controller => 'wikis', :action => 'destroy', :id => 'ladida'
                  should_route :post, "/projects/ladida/wiki", :controller => 'wikis', :action => 'edit', :id => 'ladida'
                  should_route :post, "/projects/ladida/wiki/destroy", :controller => 'wikis', :action => 'destroy', :id => 'ladida'
                end
                context "administration panel" do
                  should_route :get, "/admin/projects", :controller => 'admin', :action => 'projects'
                end
              end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages