jro_apps/redmine Commit - r8024:b127f9157d45

Resourcified custom fields....

Jean-Philippe Lang -

r8024:b127f9157d45

parent child

Context file:

r8024:b127f9157d45

Collapse all files

app/controllers/custom_fields_controller.rb +26 -12

             # Redmine - project management software
             # Copyright (C) 2006-2011  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.
             class CustomFieldsController < ApplicationController
               layout 'admin'
               before_filter :require_admin
+              before_filter :build_new_custom_field, :only => [:new, :create]
+              before_filter :find_custom_field, :only => [:edit, :update, :destroy]
               def index
                 @custom_fields_by_type = CustomField.find(:all).group_by {|f| f.class.name }
                 @tab = params[:tab] || 'IssueCustomField'
               end
               def new
-                @custom_field = begin
+              end
-                  if params[:type].to_s.match(/.+CustomField$/)
-                    params[:type].to_s.constantize.new(params[:custom_field])
-                  end
-                rescue
-                end
-                (redirect_to(:action => 'index'); return) unless @custom_field.is_a?(CustomField)
+              def create
                 if request.post? and @custom_field.save
                   flash[:notice] = l(:notice_successful_create)
                   call_hook(:controller_custom_fields_new_after_save, :params => params, :custom_field => @custom_field)
                   redirect_to :action => 'index', :tab => @custom_field.class.name
                 else
-                  @trackers = Tracker.find(:all, :order => 'position')
+                  render :action => 'new'
                 end
               end
               def edit
-                @custom_field = CustomField.find(params[:id])
+              end
-                if request.post? and @custom_field.update_attributes(params[:custom_field])
+              def update
+                if request.put? and @custom_field.update_attributes(params[:custom_field])
                   flash[:notice] = l(:notice_successful_update)
                   call_hook(:controller_custom_fields_edit_after_save, :params => params, :custom_field => @custom_field)
                   redirect_to :action => 'index', :tab => @custom_field.class.name
                 else
-                  @trackers = Tracker.find(:all, :order => 'position')
+                  render :action => 'edit'
                 end
               end
               def destroy
-                @custom_field = CustomField.find(params[:id]).destroy
+                @custom_field.destroy
                 redirect_to :action => 'index', :tab => @custom_field.class.name
               rescue
                 flash[:error] = l(:error_can_not_delete_custom_field)
                 redirect_to :action => 'index'
               end
+              private
+              def build_new_custom_field
+                @custom_field = CustomField.new_subclass_instance(params[:type], params[:custom_field])
+                if @custom_field.nil?
+                  render_404
+                end
+              end
+              def find_custom_field
+                @custom_field = CustomField.find(params[:id])
+              rescue ActiveRecord::RecordNotFound
+                render_404
+              end
             end

app/models/custom_field.rb +16 0

             # Redmine - project management software
             # Copyright (C) 2006-2011  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.
             class CustomField < ActiveRecord::Base
               has_many :custom_values, :dependent => :delete_all
               acts_as_list :scope => 'type = \'#{self.class}\''
               serialize :possible_values
               validates_presence_of :name, :field_format
               validates_uniqueness_of :name, :scope => :type
               validates_length_of :name, :maximum => 30
               validates_inclusion_of :field_format, :in => Redmine::CustomFieldFormat.available_formats
               validate :validate_values
               def initialize(attributes = nil)
                 super
                 self.possible_values ||= []
               end
               def before_validation
                 # make sure these fields are not searchable
                 self.searchable = false if %w(int float date bool).include?(field_format)
                 true
               end
               def validate_values
                 if self.field_format == "list"
                   errors.add(:possible_values, :blank) if self.possible_values.nil? || self.possible_values.empty?
                   errors.add(:possible_values, :invalid) unless self.possible_values.is_a? Array
                 end
                 if regexp.present?
                   begin
                     Regexp.new(regexp)
                   rescue
                     errors.add(:regexp, :invalid)
                   end
                 end
                 # validate default value
                 v = CustomValue.new(:custom_field => self.clone, :value => default_value, :customized => nil)
                 v.custom_field.is_required = false
                 errors.add(:default_value, :invalid) unless v.valid?
               end
               def possible_values_options(obj=nil)
                 case field_format
                 when 'user', 'version'
                   if obj.respond_to?(:project) && obj.project
                     case field_format
                     when 'user'
                       obj.project.users.sort.collect {|u| [u.to_s, u.id.to_s]}
                     when 'version'
                       obj.project.shared_versions.sort.collect {|u| [u.to_s, u.id.to_s]}
                     end
                   elsif obj.is_a?(Array)
                     obj.collect {|o| possible_values_options(o)}.inject {|memo, v| memo & v}
                   else
                     []
                   end
                 else
                   read_attribute :possible_values
                 end
               end
               def possible_values(obj=nil)
                 case field_format
                 when 'user', 'version'
                   possible_values_options(obj).collect(&:last)
                 else
                   read_attribute :possible_values
                 end
               end
               # Makes possible_values accept a multiline string
               def possible_values=(arg)
                 if arg.is_a?(Array)
                   write_attribute(:possible_values, arg.compact.collect(&:strip).select {|v| !v.blank?})
                 else
                   self.possible_values = arg.to_s.split(/[\n\r]+/)
                 end
               end
               def cast_value(value)
                 casted = nil
                 unless value.blank?
                   case field_format
                   when 'string', 'text', 'list'
                     casted = value
                   when 'date'
                     casted = begin; value.to_date; rescue; nil end
                   when 'bool'
                     casted = (value == '1' ? true : false)
                   when 'int'
                     casted = value.to_i
                   when 'float'
                     casted = value.to_f
                   when 'user', 'version'
                     casted = (value.blank? ? nil : field_format.classify.constantize.find_by_id(value.to_i))
                   end
                 end
                 casted
               end
               # Returns a ORDER BY clause that can used to sort customized
               # objects by their value of the custom field.
               # Returns false, if the custom field can not be used for sorting.
               def order_statement
                 case field_format
                   when 'string', 'text', 'list', 'date', 'bool'
                     # COALESCE is here to make sure that blank and NULL values are sorted equally
                     "COALESCE((SELECT cv_sort.value FROM #{CustomValue.table_name} cv_sort" +
                       " WHERE cv_sort.customized_type='#{self.class.customized_class.name}'" +
                       " AND cv_sort.customized_id=#{self.class.customized_class.table_name}.id" +
                       " AND cv_sort.custom_field_id=#{id} LIMIT 1), '')"
                   when 'int', 'float'
                     # Make the database cast values into numeric
                     # Postgresql will raise an error if a value can not be casted!
                     # CustomValue validations should ensure that it doesn't occur
                     "(SELECT CAST(cv_sort.value AS decimal(60,3)) FROM #{CustomValue.table_name} cv_sort" +
                       " WHERE cv_sort.customized_type='#{self.class.customized_class.name}'" +
                       " AND cv_sort.customized_id=#{self.class.customized_class.table_name}.id" +
                       " AND cv_sort.custom_field_id=#{id} AND cv_sort.value <> '' AND cv_sort.value IS NOT NULL LIMIT 1)"
                   else
                     nil
                 end
               end
               def <=>(field)
                 position <=> field.position
               end
               def self.customized_class
                 self.name =~ /^(.+)CustomField$/
                 begin; $1.constantize; rescue nil; end
               end
               # to move in project_custom_field
               def self.for_all
                 find(:all, :conditions => ["is_for_all=?", true], :order => 'position')
               end
+              # Returns an instance of the given subclass name
+              def self.new_subclass_instance(class_name, *args)
+                klass = nil
+                begin
+                  klass = class_name.to_s.classify.constantize
+                rescue
+                  # invalid class name
+                end
+                unless subclasses.include? klass
+                  klass = nil
+                end
+                if klass
+                  klass.new(*args)
+                end
+              end
               def type_name
                 nil
               end
             end

app/views/custom_fields/_form.html.erb +1 -1

             <%= error_messages_for 'custom_field' %>
             <script type="text/javascript">
             //<![CDATA[
             function toggle_custom_field_format() {
               format = $("custom_field_field_format");
               p_length = $("custom_field_min_length");
               p_regexp = $("custom_field_regexp");
               p_values = $("custom_field_possible_values");
               p_searchable = $("custom_field_searchable");
               p_default = $("custom_field_default_value");
               p_default.setAttribute('type','text');
               Element.show(p_default.parentNode);
               switch (format.value) {
                 case "list":
                   Element.hide(p_length.parentNode);
                   Element.hide(p_regexp.parentNode);
                   if (p_searchable) Element.show(p_searchable.parentNode);
                   Element.show(p_values.parentNode);
                   break;
                 case "bool":
                   p_default.setAttribute('type','checkbox');
                   Element.hide(p_length.parentNode);
                   Element.hide(p_regexp.parentNode);
                   if (p_searchable) Element.hide(p_searchable.parentNode);
                   Element.hide(p_values.parentNode);
                   break;
                 case "date":
                   Element.hide(p_length.parentNode);
                   Element.hide(p_regexp.parentNode);
                   if (p_searchable) Element.hide(p_searchable.parentNode);
                   Element.hide(p_values.parentNode);
                   break;
                 case "float":
                 case "int":
                   Element.show(p_length.parentNode);
                   Element.show(p_regexp.parentNode);
                   if (p_searchable) Element.hide(p_searchable.parentNode);
                   Element.hide(p_values.parentNode);
                   break;
                 case "user":
                 case "version":
                   Element.hide(p_length.parentNode);
                   Element.hide(p_regexp.parentNode);
                   if (p_searchable) Element.hide(p_searchable.parentNode);
                   Element.hide(p_values.parentNode);
                   Element.hide(p_default.parentNode);
                   break;
                 default:
                   Element.show(p_length.parentNode);
                   Element.show(p_regexp.parentNode);
                   if (p_searchable) Element.show(p_searchable.parentNode);
                   Element.hide(p_values.parentNode);
                   break;
               }
             }
             //]]>
             </script>
             <div class="box tabular">
             <p><%= f.text_field :name, :required => true %></p>
             <p><%= f.select :field_format, custom_field_formats_for_select(@custom_field), {}, :onchange => "toggle_custom_field_format();",
                                                                                 :disabled => !@custom_field.new_record? %></p>
             <p><label for="custom_field_min_length"><%=l(:label_min_max_length)%></label>
                <%= f.text_field :min_length, :size => 5, :no_label => true %> -
                <%= f.text_field :max_length, :size => 5, :no_label => true %><br />(<%=l(:text_min_max_length_info)%>)</p>
             <p><%= f.text_field :regexp, :size => 50 %><br />(<%=l(:text_regexp_info)%>)</p>
             <p>
               <%= f.text_area :possible_values, :value => @custom_field.possible_values.to_a.join("\n"), :rows => 15 %>
               <br /><em><%= l(:text_custom_field_possible_values_info) %></em>
             </p>
             <p><%= @custom_field.field_format == 'bool' ? f.check_box(:default_value) : f.text_field(:default_value) %></p>
             <%= call_hook(:view_custom_fields_form_upper_box, :custom_field => @custom_field, :form => f) %>
             </div>
             <div class="box tabular">
             <% case @custom_field.class.name
             when "IssueCustomField" %>
                 <fieldset><legend><%=l(:label_tracker_plural)%></legend>
-                <% for tracker in @trackers %>
+                <% Tracker.all.each do |tracker| %>
                   <%= check_box_tag "custom_field[tracker_ids][]",
                                     tracker.id,
                                     (@custom_field.trackers.include? tracker),
                                     :id => "custom_field_tracker_ids_#{tracker.id}" %>
                   <label class="no-css" for="custom_field_tracker_ids_<%=tracker.id%>">
                     <%= h(tracker.name) %>
                   </label>
                 <% end %>
                 <%= hidden_field_tag "custom_field[tracker_ids][]", '' %>
                 </fieldset>
                 &nbsp;
                 <p><%= f.check_box :is_required %></p>
                 <p><%= f.check_box :is_for_all %></p>
                 <p><%= f.check_box :is_filter %></p>
                 <p><%= f.check_box :searchable %></p>
             <% when "UserCustomField" %>
                 <p><%= f.check_box :is_required %></p>
                 <p><%= f.check_box :visible %></p>
                 <p><%= f.check_box :editable %></p>
             <% when "ProjectCustomField" %>
                 <p><%= f.check_box :is_required %></p>
                 <p><%= f.check_box :visible %></p>
                 <p><%= f.check_box :searchable %></p>
             <% when "TimeEntryCustomField" %>
                 <p><%= f.check_box :is_required %></p>
             <% else %>
                 <p><%= f.check_box :is_required %></p>
             <% end %>
             <%= call_hook(:"view_custom_fields_form_#{@custom_field.type.to_s.underscore}", :custom_field => @custom_field, :form => f) %>
             </div>
             <%= javascript_tag "toggle_custom_field_format();" %>

app/views/custom_fields/_index.html.erb +4 -4

             <table class="list">
               <thead><tr>
                 <th width="30%"><%=l(:field_name)%></th>
                 <th><%=l(:field_field_format)%></th>
                 <th><%=l(:field_is_required)%></th>
                 <% if tab[:name] == 'IssueCustomField' %>
                   <th><%=l(:field_is_for_all)%></th>
                   <th><%=l(:label_used_by)%></th>
                 <% end %>
                 <th><%=l(:button_sort)%></th>
                 <th width="10%"></th>
               </tr></thead>
               <tbody>
               <% (@custom_fields_by_type[tab[:name]] || []).sort.each do |custom_field| -%>
                 <tr class="<%= cycle("odd", "even") %>">
-                  <td><%= link_to h(custom_field.name), :action => 'edit', :id => custom_field %></td>
+                  <td><%= link_to h(custom_field.name), edit_custom_field_path(custom_field) %></td>
                   <td align="center"><%= l(Redmine::CustomFieldFormat.label_for(custom_field.field_format)) %></td>
                   <td align="center"><%= checked_image custom_field.is_required? %></td>
                   <% if tab[:name] == 'IssueCustomField' %>
                   <td align="center"><%= checked_image custom_field.is_for_all? %></td>
                   <td align="center"><%= l(:label_x_projects, :count => custom_field.projects.count) if custom_field.is_a? IssueCustomField and !custom_field.is_for_all? %></td>
                   <% end %>
                   <td align="center" style="width:15%;"><%= reorder_links('custom_field', {:action => 'edit', :id => custom_field}) %></td>
                   <td class="buttons">
-                    <%= link_to(l(:button_delete), { :action => 'destroy', :id => custom_field },
+                    <%= link_to(l(:button_delete), custom_field_path(custom_field),
-                                                   :method => :post,
+                                                   :method => :delete,
                                                    :confirm => l(:text_are_you_sure),
                                                    :class => 'icon icon-del') %>
                   </td>
                 </tr>
               <% end; reset_cycle %>
               </tbody>
             </table>
-            <p><%= link_to l(:label_custom_field_new), {:action => 'new', :type => tab[:name]}, :class => 'icon icon-add' %></p>
+            <p><%= link_to l(:label_custom_field_new), new_custom_field_path(:type => tab[:name]), :class => 'icon icon-add' %></p>

app/views/custom_fields/edit.html.erb +1 -1

             <h2><%= link_to l(:label_custom_field_plural), :controller => 'custom_fields', :action => 'index' %>
               &#187; <%= link_to l(@custom_field.type_name), :controller => 'custom_fields', :action => 'index', :tab => @custom_field.class.name %>
               &#187; <%=h @custom_field.name %></h2>
-            <% labelled_form_for :custom_field, @custom_field, :url => { :action => "edit", :id => @custom_field } do |f| %>
+            <% labelled_form_for :custom_field, @custom_field, :url => custom_field_path(@custom_field), :html => {:method => :put} do |f| %>
             <%= render :partial => 'form', :locals => { :f => f } %>
             <%= submit_tag l(:button_save) %>
             <% end %>

app/views/custom_fields/new.html.erb +1 -1

             <h2><%= link_to l(:label_custom_field_plural), :controller => 'custom_fields', :action => 'index' %>
               &#187; <%= link_to l(@custom_field.type_name), :controller => 'custom_fields', :action => 'index', :tab => @custom_field.class.name %>
               &#187; <%= l(:label_custom_field_new) %></h2>
-            <% labelled_form_for :custom_field, @custom_field, :url => { :action => "new" } do |f| %>
+            <% labelled_form_for :custom_field, @custom_field, :url => custom_fields_path do |f| %>
             <%= render :partial => 'form', :locals => { :f => f } %>
             <%= hidden_field_tag 'type', @custom_field.type %>
             <%= submit_tag l(:button_save) %>
             <% end %>

config/routes.rb +1 0

             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.time_entries_context_menu '/time_entries/context_menu',
                                :controller => 'context_menus', :action => 'time_entries'
               map.resources :time_entries, :controller => 'timelog', :collection => {:report => :get, :bulk_edit => :get, :bulk_update => :post}
               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 => '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.resources :issue_moves, :only => [:new, :create], :path_prefix => '/issues', :as => 'move'
               map.resources :queries, :except => [:show]
               # Misc issue routes. TODO: move into resources
               map.auto_complete_issues '/issues/auto_complete', :controller => 'auto_completes', :action => 'issues', :conditions => { :method => :get }
               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.with_options :controller => 'gantts', :action => 'show' do |gantts_routes|
                 gantts_routes.connect '/projects/:project_id/issues/gantt'
                 gantts_routes.connect '/projects/:project_id/issues/gantt.:format'
                 gantts_routes.connect '/issues/gantt.:format'
               end
               map.with_options :controller => 'calendars', :action => 'show' do |calendars_routes|
                 calendars_routes.connect '/projects/:project_id/issues/calendar'
                 calendars_routes.connect '/issues/calendar'
               end
               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
               map.resources :issues do |issues|
                 issues.resources :time_entries, :controller => 'timelog', :collection => {:report => :get}
                 issues.resources :relations, :shallow => true, :controller => 'issue_relations', :only => [:index, :show, :create, :destroy]
               end
               map.connect 'projects/:id/members/new', :controller => 'members', :action => 'new'
               map.with_options :controller => 'users' do |users|
                 users.connect 'users/:id/edit/:tab', :action => 'edit', :tab => nil, :conditions => {:method => :get}
                 users.with_options :conditions => {:method => :post} do |user_actions|
                   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 :users, :member => {
                 :edit_membership => :post,
                 :destroy_membership => :post
               }
               # For nice "roadmap" in the url for the index action
               map.connect 'projects/:project_id/roadmap', :controller => 'versions', :action => 'index'
               map.all_news 'news', :controller => 'news', :action => 'index'
               map.formatted_all_news 'news.:format', :controller => 'news', :action => 'index'
               map.preview_news '/news/preview', :controller => 'previews', :action => 'news'
               map.connect 'news/:id/comments', :controller => 'comments', :action => 'create', :conditions => {:method => :post}
               map.connect 'news/:id/comments/:comment_id', :controller => 'comments', :action => 'destroy', :conditions => {:method => :delete}
               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]
                 project.resources :issues, :only => [:index, :new, :create] do |issues|
                   issues.resources :time_entries, :controller => 'timelog', :collection => {:report => :get}
                 end
                 project.resources :files, :only => [:index, :new, :create]
                 project.resources :versions, :shallow => true, :collection => {:close_completed => :put}, :member => {:status_by => :post}
                 project.resources :news, :shallow => true
                 project.resources :time_entries, :controller => 'timelog', :path_prefix => 'projects/:project_id', :collection => {:report => :get}
                 project.resources :queries, :only => [:new, :create]
                 project.resources :issue_categories, :shallow => true
                 project.resources :documents, :shallow => true, :member => {:add_attachment => :post}
                 project.resources :boards
                 project.wiki_start_page 'wiki', :controller => 'wiki', :action => 'show', :conditions => {:method => :get}
                 project.wiki_index 'wiki/index', :controller => 'wiki', :action => 'index', :conditions => {:method => :get}
                 project.wiki_diff 'wiki/:id/diff/:version', :controller => 'wiki', :action => 'diff', :version => nil
                 project.wiki_diff 'wiki/:id/diff/:version/vs/:version_from', :controller => 'wiki', :action => 'diff'
                 project.wiki_annotate 'wiki/:id/annotate/:version', :controller => 'wiki', :action => 'annotate'
                 project.resources :wiki, :except => [:new, :create], :member => {
                   :rename => [:get, :post],
                   :history => :get,
                   :preview => :any,
                   :protect => :post,
                   :add_attachment => :post
                 }, :collection => {
                   :export => :get,
                   :date_index => :get
                 }
               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/settings/:tab', :controller => 'projects', :action => 'settings'
                   project_views.connect 'projects/:project_id/issues/:copy_from/copy', :controller => 'issues', :action => 'new'
                 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 => '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.resources :attachments, :only => [:show, :destroy]
               # additional routes for having the file name at the end of url
               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, :member => {:autocomplete_for_user => :get}
               map.group_users 'groups/:id/users', :controller => 'groups', :action => 'add_users', :id => /\d+/, :conditions => {:method => :post}
               map.group_user  'groups/:id/users/:user_id', :controller => 'groups', :action => 'remove_user', :id => /\d+/, :conditions => {:method => :delete}
               map.resources :trackers, :except => :show
               map.resources :issue_statuses, :except => :show, :collection => {:update_issue_done_ratio => :post}
+              map.resources :custom_fields, :except => :show
               #left old routes at the bottom for backwards compat
               map.connect 'boards/:board_id/topics/:action/:id', :controller => 'messages'
               map.connect 'wiki/:id/:page/:action', :page => nil, :controller => 'wiki'
               map.connect 'projects/:project_id/news/:action', :controller => 'news'
               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

test/functional/custom_fields_controller_test.rb +30 -9

             # Redmine - project management software
             # Copyright (C) 2006-2011  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.expand_path('../../test_helper', __FILE__)
             require 'custom_fields_controller'
             # Re-raise errors caught by the controller.
             class CustomFieldsController; def rescue_action(e) raise e end; end
             class CustomFieldsControllerTest < ActionController::TestCase
               fixtures :custom_fields, :custom_values, :trackers, :users
               def setup
                 @controller = CustomFieldsController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 @request.session[:user_id] = 1
               end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'index'
               end
-              def test_get_new_issue_custom_field
+              def test_new_issue_custom_field
                 get :new, :type => 'IssueCustomField'
                 assert_response :success
                 assert_template 'new'
+                assert_tag :input, :attributes => {:name => 'custom_field[name]'}
                 assert_tag :select,
                   :attributes => {:name => 'custom_field[field_format]'},
                   :child => {
                     :tag => 'option',
                     :attributes => {:value => 'user'},
                     :content => 'User'
                   }
                 assert_tag :select,
                   :attributes => {:name => 'custom_field[field_format]'},
                   :child => {
                     :tag => 'option',
                     :attributes => {:value => 'version'},
                     :content => 'Version'
                   }
+                assert_tag :input, :attributes => {:name => 'type', :value => 'IssueCustomField'}
               end
-              def test_get_new_with_invalid_custom_field_class_should_redirect_to_list
+              def test_new_with_invalid_custom_field_class_should_render_404
                 get :new, :type => 'UnknownCustomField'
-                assert_redirected_to '/custom_fields'
+                assert_response 404
               end
-              def test_post_new_list_custom_field
+              def test_create_list_custom_field
                 assert_difference 'CustomField.count' do
-                  post :new, :type => "IssueCustomField",
+                  post :create, :type => "IssueCustomField",
                              :custom_field => {:name => "test_post_new_list",
                                                :default_value => "",
                                                :min_length => "0",
                                                :searchable => "0",
                                                :regexp => "",
                                                :is_for_all => "1",
                                                :possible_values => "0.1\n0.2\n",
                                                :max_length => "0",
                                                :is_filter => "0",
                                                :is_required =>"0",
                                                :field_format => "list",
                                                :tracker_ids => ["1", ""]}
                 end
                 assert_redirected_to '/custom_fields?tab=IssueCustomField'
                 field = IssueCustomField.find_by_name('test_post_new_list')
                 assert_not_nil field
                 assert_equal ["0.1", "0.2"], field.possible_values
                 assert_equal 1, field.trackers.size
               end
-              def test_get_edit
+              def test_create_with_failure
+                assert_no_difference 'CustomField.count' do
+                  post :create, :type => "IssueCustomField", :custom_field => {:name => ''}
+                end
+                assert_response :success
+                assert_template 'new'
+              end
+              def test_edit
                 get :edit, :id => 1
                 assert_response :success
                 assert_template 'edit'
                 assert_tag 'input', :attributes => {:name => 'custom_field[name]', :value => 'Database'}
               end
-              def test_post_edit
+              def test_edit_invalid_custom_field_should_render_404
-                post :edit, :id => 1, :custom_field => {:name => 'New name'}
+                get :edit, :id => 99
+                assert_response 404
+              end
+              def test_update
+                put :update, :id => 1, :custom_field => {:name => 'New name'}
                 assert_redirected_to '/custom_fields?tab=IssueCustomField'
                 field = CustomField.find(1)
                 assert_equal 'New name', field.name
               end
+              def test_update_with_failure
+                put :update, :id => 1, :custom_field => {:name => ''}
+                assert_response :success
+                assert_template 'edit'
+              end
               def test_destroy
                 custom_values_count = CustomValue.count(:conditions => {:custom_field_id => 1})
                 assert custom_values_count > 0
                 assert_difference 'CustomField.count', -1 do
                   assert_difference 'CustomValue.count', - custom_values_count do
-                    post :destroy, :id => 1
+                    delete :destroy, :id => 1
                   end
                 end
                 assert_redirected_to '/custom_fields?tab=IssueCustomField'
                 assert_nil CustomField.find_by_id(1)
                 assert_nil CustomValue.find_by_custom_field_id(1)
               end
             end

test/integration/routing_test.rb +9 0

             # Redmine - project management software
             # Copyright (C) 2006-2011  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.expand_path('../../test_helper', __FILE__)
             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.xml", :controller => 'attachments', :action => 'show', :id => '1', :format => 'xml'
                 should_route :get, "/attachments/1.json", :controller => 'attachments', :action => 'show', :id => '1', :format => 'json'
                 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", :controller => 'boards', :action => 'create', :project_id => 'world_domination'
                 should_route :put, "/projects/world_domination/boards/44", :controller => 'boards', :action => 'update', :project_id => 'world_domination', :id => '44'
                 should_route :delete, "/projects/world_domination/boards/44", :controller => 'boards', :action => 'destroy', :project_id => 'world_domination', :id => '44'
               end
+              context "custom_fields" do
+                should_route :get, "/custom_fields", :controller => 'custom_fields', :action => 'index'
+                should_route :get, "/custom_fields/new", :controller => 'custom_fields', :action => 'new'
+                should_route :post, "/custom_fields", :controller => 'custom_fields', :action => 'create'
+                should_route :get, "/custom_fields/2/edit", :controller => 'custom_fields', :action => 'edit', :id => 2
+                should_route :put, "/custom_fields/2", :controller => 'custom_fields', :action => 'update', :id => 2
+                should_route :delete, "/custom_fields/2", :controller => 'custom_fields', :action => 'destroy', :id => 2
+              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", :controller => 'documents', :action => 'create', :project_id => '567'
                 should_route :put, "/documents/22", :controller => 'documents', :action => 'update', :id => '22'
                 should_route :delete, "/documents/22", :controller => 'documents', :action => 'destroy', :id => '22'
                 should_route :post, "/documents/22/add_attachment", :controller => 'documents', :action => 'add_attachment', :id => '22'
               end
               context "groups" do
                 should_route :post,   "/groups/567/users", :controller => 'groups', :action => 'add_users', :id => '567'
                 should_route :delete, "/groups/567/users/12", :controller => 'groups', :action => 'remove_user', :id => '567', :user_id => '12'
               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'
                 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 :get, "/projects/project-name/issues/calendar", :controller => 'calendars', :action => 'show', :project_id => 'project-name'
                 should_route :get, "/issues/gantt", :controller => 'gantts', :action => 'show'
                 should_route :get, "/issues/gantt.pdf", :controller => 'gantts', :action => 'show', :format => 'pdf'
                 should_route :get, "/projects/project-name/issues/gantt", :controller => 'gantts', :action => 'show', :project_id => 'project-name'
                 should_route :get, "/projects/project-name/issues/gantt.pdf", :controller => 'gantts', :action => 'show', :project_id => 'project-name', :format => 'pdf'
                 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/foo/issue_categories", :controller => 'issue_categories', :action => 'index', :project_id => 'foo'
                 should_route :get, "/projects/foo/issue_categories.xml", :controller => 'issue_categories', :action => 'index', :project_id => 'foo', :format => 'xml'
                 should_route :get, "/projects/foo/issue_categories.json", :controller => 'issue_categories', :action => 'index', :project_id => 'foo', :format => 'json'
                 should_route :get, "/projects/foo/issue_categories/new", :controller => 'issue_categories', :action => 'new', :project_id => 'foo'
                 should_route :post, "/projects/foo/issue_categories", :controller => 'issue_categories', :action => 'create', :project_id => 'foo'
                 should_route :post, "/projects/foo/issue_categories.xml", :controller => 'issue_categories', :action => 'create', :project_id => 'foo', :format => 'xml'
                 should_route :post, "/projects/foo/issue_categories.json", :controller => 'issue_categories', :action => 'create', :project_id => 'foo', :format => 'json'
                 should_route :get, "/issue_categories/1", :controller => 'issue_categories', :action => 'show', :id => '1'
                 should_route :get, "/issue_categories/1.xml", :controller => 'issue_categories', :action => 'show', :id => '1', :format => 'xml'
                 should_route :get, "/issue_categories/1.json", :controller => 'issue_categories', :action => 'show', :id => '1', :format => 'json'
                 should_route :get, "/issue_categories/1/edit", :controller => 'issue_categories', :action => 'edit', :id => '1'
                 should_route :put, "/issue_categories/1", :controller => 'issue_categories', :action => 'update', :id => '1'
                 should_route :put, "/issue_categories/1.xml", :controller => 'issue_categories', :action => 'update', :id => '1', :format => 'xml'
                 should_route :put, "/issue_categories/1.json", :controller => 'issue_categories', :action => 'update', :id => '1', :format => 'json'
                 should_route :delete, "/issue_categories/1", :controller => 'issue_categories', :action => 'destroy', :id => '1'
                 should_route :delete, "/issue_categories/1.xml", :controller => 'issue_categories', :action => 'destroy', :id => '1', :format => 'xml'
                 should_route :delete, "/issue_categories/1.json", :controller => 'issue_categories', :action => 'destroy', :id => '1', :format => 'json'
               end
               context "issue relations" do
                 should_route :get, "/issues/1/relations", :controller => 'issue_relations', :action => 'index', :issue_id => '1'
                 should_route :get, "/issues/1/relations.xml", :controller => 'issue_relations', :action => 'index', :issue_id => '1', :format => 'xml'
                 should_route :get, "/issues/1/relations.json", :controller => 'issue_relations', :action => 'index', :issue_id => '1', :format => 'json'
                 should_route :post, "/issues/1/relations", :controller => 'issue_relations', :action => 'create', :issue_id => '1'
                 should_route :post, "/issues/1/relations.xml", :controller => 'issue_relations', :action => 'create', :issue_id => '1', :format => 'xml'
                 should_route :post, "/issues/1/relations.json", :controller => 'issue_relations', :action => 'create', :issue_id => '1', :format => 'json'
                 should_route :get, "/relations/23", :controller => 'issue_relations', :action => 'show', :id => '23'
                 should_route :get, "/relations/23.xml", :controller => 'issue_relations', :action => 'show', :id => '23', :format => 'xml'
                 should_route :get, "/relations/23.json", :controller => 'issue_relations', :action => 'show', :id => '23', :format => 'json'
                 should_route :delete, "/relations/23", :controller => 'issue_relations', :action => 'destroy', :id => '23'
                 should_route :delete, "/relations/23.xml", :controller => 'issue_relations', :action => 'destroy', :id => '23', :format => 'xml'
                 should_route :delete, "/relations/23.json", :controller => 'issue_relations', :action => 'destroy', :id => '23', :format => 'json'
               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 :get, "/news/567/edit", :controller => 'news', :action => 'edit', :id => '567'
                 should_route :get, "/news/preview", :controller => 'previews', :action => 'news'
                 should_route :post, "/projects/567/news", :controller => 'news', :action => 'create', :project_id => '567'
                 should_route :post, "/news/567/comments", :controller => 'comments', :action => 'create', :id => '567'
                 should_route :put, "/news/567", :controller => 'news', :action => 'update', :id => '567'
                 should_route :delete, "/news/567", :controller => 'news', :action => 'destroy', :id => '567'
                 should_route :delete, "/news/567/comments/15", :controller => 'comments', :action => 'destroy', :id => '567', :comment_id => '15'
               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', :project_id => '33'
                 should_route :get, "/projects/33/files/new", :controller => 'files', :action => 'new', :project_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", :controller => 'files', :action => 'create', :project_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 :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/enumerations", :controller => 'project_enumerations', :action => 'destroy', :project_id => '64'
               end
               context "queries" do
                 should_route :get, "/queries.xml", :controller => 'queries', :action => 'index', :format => 'xml'
                 should_route :get, "/queries.json", :controller => 'queries', :action => 'index', :format => 'json'
                 should_route :get, "/queries/new", :controller => 'queries', :action => 'new'
                 should_route :get, "/projects/redmine/queries/new", :controller => 'queries', :action => 'new', :project_id => 'redmine'
                 should_route :post, "/queries", :controller => 'queries', :action => 'create'
                 should_route :post, "/projects/redmine/queries", :controller => 'queries', :action => 'create', :project_id => 'redmine'
                 should_route :get, "/queries/1/edit", :controller => 'queries', :action => 'edit', :id => '1'
                 should_route :put, "/queries/1", :controller => 'queries', :action => 'update', :id => '1'
                 should_route :delete, "/queries/1", :controller => 'queries', :action => 'destroy', :id => '1'
               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 (global)" do
                 should_route :get, "/time_entries", :controller => 'timelog', :action => 'index'
                 should_route :get, "/time_entries.csv", :controller => 'timelog', :action => 'index', :format => 'csv'
                 should_route :get, "/time_entries.atom", :controller => 'timelog', :action => 'index', :format => 'atom'
                 should_route :get, "/time_entries/new", :controller => 'timelog', :action => 'new'
                 should_route :get, "/time_entries/22/edit", :controller => 'timelog', :action => 'edit', :id => '22'
                 should_route :post, "/time_entries", :controller => 'timelog', :action => 'create'
                 should_route :put, "/time_entries/22", :controller => 'timelog', :action => 'update', :id => '22'
                 should_route :delete, "/time_entries/55", :controller => 'timelog', :action => 'destroy', :id => '55'
               end
               context "timelogs (scoped under project)" do
                 should_route :get, "/projects/567/time_entries", :controller => 'timelog', :action => 'index', :project_id => '567'
                 should_route :get, "/projects/567/time_entries.csv", :controller => 'timelog', :action => 'index', :project_id => '567', :format => 'csv'
                 should_route :get, "/projects/567/time_entries.atom", :controller => 'timelog', :action => 'index', :project_id => '567', :format => 'atom'
                 should_route :get, "/projects/567/time_entries/new", :controller => 'timelog', :action => 'new', :project_id => '567'
                 should_route :get, "/projects/567/time_entries/22/edit", :controller => 'timelog', :action => 'edit', :id => '22', :project_id => '567'
                 should_route :post, "/projects/567/time_entries", :controller => 'timelog', :action => 'create', :project_id => '567'
                 should_route :put, "/projects/567/time_entries/22", :controller => 'timelog', :action => 'update', :id => '22', :project_id => '567'
                 should_route :delete, "/projects/567/time_entries/55", :controller => 'timelog', :action => 'destroy', :id => '55', :project_id => '567'
               end
               context "timelogs (scoped under issues)" do
                 should_route :get, "/issues/234/time_entries", :controller => 'timelog', :action => 'index', :issue_id => '234'
                 should_route :get, "/issues/234/time_entries.csv", :controller => 'timelog', :action => 'index', :issue_id => '234', :format => 'csv'
                 should_route :get, "/issues/234/time_entries.atom", :controller => 'timelog', :action => 'index', :issue_id => '234', :format => 'atom'
                 should_route :get, "/issues/234/time_entries/new", :controller => 'timelog', :action => 'new', :issue_id => '234'
                 should_route :get, "/issues/234/time_entries/22/edit", :controller => 'timelog', :action => 'edit', :id => '22', :issue_id => '234'
                 should_route :post, "/issues/234/time_entries", :controller => 'timelog', :action => 'create', :issue_id => '234'
                 should_route :put, "/issues/234/time_entries/22", :controller => 'timelog', :action => 'update', :id => '22', :issue_id => '234'
                 should_route :delete, "/issues/234/time_entries/55", :controller => 'timelog', :action => 'destroy', :id => '55', :issue_id => '234'
               end
               context "timelogs (scoped under project and issues)" do
                 should_route :get, "/projects/ecookbook/issues/234/time_entries", :controller => 'timelog', :action => 'index', :issue_id => '234', :project_id => 'ecookbook'
                 should_route :get, "/projects/ecookbook/issues/234/time_entries.csv", :controller => 'timelog', :action => 'index', :issue_id => '234', :project_id => 'ecookbook', :format => 'csv'
                 should_route :get, "/projects/ecookbook/issues/234/time_entries.atom", :controller => 'timelog', :action => 'index', :issue_id => '234', :project_id => 'ecookbook', :format => 'atom'
                 should_route :get, "/projects/ecookbook/issues/234/time_entries/new", :controller => 'timelog', :action => 'new', :issue_id => '234', :project_id => 'ecookbook'
                 should_route :get, "/projects/ecookbook/issues/234/time_entries/22/edit", :controller => 'timelog', :action => 'edit', :id => '22', :issue_id => '234', :project_id => 'ecookbook'
                 should_route :post, "/projects/ecookbook/issues/234/time_entries", :controller => 'timelog', :action => 'create', :issue_id => '234', :project_id => 'ecookbook'
                 should_route :put, "/projects/ecookbook/issues/234/time_entries/22", :controller => 'timelog', :action => 'update', :id => '22', :issue_id => '234', :project_id => 'ecookbook'
                 should_route :delete, "/projects/ecookbook/issues/234/time_entries/55", :controller => 'timelog', :action => 'destroy', :id => '55', :issue_id => '234', :project_id => 'ecookbook'
                 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'
               end
               context "users" do
                 should_route :get, "/users", :controller => 'users', :action => 'index'
                 should_route :get, "/users.xml", :controller => 'users', :action => 'index', :format => 'xml'
                 should_route :get, "/users/44", :controller => 'users', :action => 'show', :id => '44'
                 should_route :get, "/users/44.xml", :controller => 'users', :action => 'show', :id => '44', :format => 'xml'
                 should_route :get, "/users/current", :controller => 'users', :action => 'show', :id => 'current'
                 should_route :get, "/users/current.xml", :controller => 'users', :action => 'show', :id => 'current', :format => 'xml'
                 should_route :get, "/users/new", :controller => 'users', :action => 'new'
                 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", :controller => 'users', :action => 'create'
                 should_route :post, "/users.xml", :controller => 'users', :action => 'create', :format => 'xml'
                 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'
                 should_route :put, "/users/444", :controller => 'users', :action => 'update', :id => '444'
                 should_route :put, "/users/444.xml", :controller => 'users', :action => 'update', :id => '444', :format => 'xml'
                 should_route :delete, "/users/44", :controller => 'users', :action => 'destroy', :id => '44'
                 should_route :delete, "/users/44.xml", :controller => 'users', :action => 'destroy', :id => '44', :format => 'xml'
               end
               context "versions" do
                 # /projects/foo/versions is /projects/foo/roadmap
                 should_route :get, "/projects/foo/versions.xml", :controller => 'versions', :action => 'index', :project_id => 'foo', :format => 'xml'
                 should_route :get, "/projects/foo/versions.json", :controller => 'versions', :action => 'index', :project_id => 'foo', :format => 'json'
                 should_route :get, "/projects/foo/versions/new", :controller => 'versions', :action => 'new', :project_id => 'foo'
                 should_route :post, "/projects/foo/versions", :controller => 'versions', :action => 'create', :project_id => 'foo'
                 should_route :post, "/projects/foo/versions.xml", :controller => 'versions', :action => 'create', :project_id => 'foo', :format => 'xml'
                 should_route :post, "/projects/foo/versions.json", :controller => 'versions', :action => 'create', :project_id => 'foo', :format => 'json'
                 should_route :get, "/versions/1", :controller => 'versions', :action => 'show', :id => '1'
                 should_route :get, "/versions/1.xml", :controller => 'versions', :action => 'show', :id => '1', :format => 'xml'
                 should_route :get, "/versions/1.json", :controller => 'versions', :action => 'show', :id => '1', :format => 'json'
                 should_route :get, "/versions/1/edit", :controller => 'versions', :action => 'edit', :id => '1'
                 should_route :put, "/versions/1", :controller => 'versions', :action => 'update', :id => '1'
                 should_route :put, "/versions/1.xml", :controller => 'versions', :action => 'update', :id => '1', :format => 'xml'
                 should_route :put, "/versions/1.json", :controller => 'versions', :action => 'update', :id => '1', :format => 'json'
                 should_route :delete, "/versions/1", :controller => 'versions', :action => 'destroy', :id => '1'
                 should_route :delete, "/versions/1.xml", :controller => 'versions', :action => 'destroy', :id => '1', :format => 'xml'
                 should_route :delete, "/versions/1.json", :controller => 'versions', :action => 'destroy', :id => '1', :format => 'json'
                 should_route :put, "/projects/foo/versions/close_completed", :controller => 'versions', :action => 'close_completed', :project_id => 'foo'
                 should_route :post, "/versions/1/status_by", :controller => 'versions', :action => 'status_by', :id => '1'
               end
               context "wiki (singular, project's pages)" do
                 should_route :get, "/projects/567/wiki", :controller => 'wiki', :action => 'show', :project_id => '567'
                 should_route :get, "/projects/567/wiki/lalala", :controller => 'wiki', :action => 'show', :project_id => '567', :id => 'lalala'
                 should_route :get, "/projects/567/wiki/my_page/edit", :controller => 'wiki', :action => 'edit', :project_id => '567', :id => 'my_page'
                 should_route :get, "/projects/1/wiki/CookBook_documentation/history", :controller => 'wiki', :action => 'history', :project_id => '1', :id => 'CookBook_documentation'
                 should_route :get, "/projects/1/wiki/CookBook_documentation/diff", :controller => 'wiki', :action => 'diff', :project_id => '1', :id => 'CookBook_documentation'
                 should_route :get, "/projects/1/wiki/CookBook_documentation/diff/2", :controller => 'wiki', :action => 'diff', :project_id => '1', :id => 'CookBook_documentation', :version => '2'
                 should_route :get, "/projects/1/wiki/CookBook_documentation/diff/2/vs/1", :controller => 'wiki', :action => 'diff', :project_id => '1', :id => 'CookBook_documentation', :version => '2', :version_from => '1'
                 should_route :get, "/projects/1/wiki/CookBook_documentation/annotate/2", :controller => 'wiki', :action => 'annotate', :project_id => '1', :id => 'CookBook_documentation', :version => '2'
                 should_route :get, "/projects/22/wiki/ladida/rename", :controller => 'wiki', :action => 'rename', :project_id => '22', :id => 'ladida'
                 should_route :get, "/projects/567/wiki/index", :controller => 'wiki', :action => 'index', :project_id => '567'
                 should_route :get, "/projects/567/wiki/date_index", :controller => 'wiki', :action => 'date_index', :project_id => '567'
                 should_route :get, "/projects/567/wiki/export", :controller => 'wiki', :action => 'export', :project_id => '567'
                 should_route :post, "/projects/567/wiki/CookBook_documentation/preview", :controller => 'wiki', :action => 'preview', :project_id => '567', :id => 'CookBook_documentation'
                 should_route :post, "/projects/22/wiki/ladida/rename", :controller => 'wiki', :action => 'rename', :project_id => '22', :id => 'ladida'
                 should_route :post, "/projects/22/wiki/ladida/protect", :controller => 'wiki', :action => 'protect', :project_id => '22', :id => 'ladida'
                 should_route :post, "/projects/22/wiki/ladida/add_attachment", :controller => 'wiki', :action => 'add_attachment', :project_id => '22', :id => 'ladida'
                 should_route :put, "/projects/567/wiki/my_page", :controller => 'wiki', :action => 'update', :project_id => '567', :id => 'my_page'
                 should_route :delete, "/projects/22/wiki/ladida", :controller => 'wiki', :action => 'destroy', :project_id => '22', :id => '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

test/unit/custom_field_test.rb +19 0

             # Redmine - project management software
             # Copyright (C) 2006-2011  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.expand_path('../../test_helper', __FILE__)
             class CustomFieldTest < ActiveSupport::TestCase
               fixtures :custom_fields
               def test_create
                 field = UserCustomField.new(:name => 'Money money money', :field_format => 'float')
                 assert field.save
               end
               def test_regexp_validation
                 field = IssueCustomField.new(:name => 'regexp', :field_format => 'text', :regexp => '[a-z0-9')
                 assert !field.save
                 assert_equal I18n.t('activerecord.errors.messages.invalid'),
                              field.errors[:regexp].to_s
                 field.regexp = '[a-z0-9]'
                 assert field.save
               end
               def test_possible_values_should_accept_an_array
                 field = CustomField.new
                 field.possible_values = ["One value", ""]
                 assert_equal ["One value"], field.possible_values
               end
               def test_possible_values_should_accept_a_string
                 field = CustomField.new
                 field.possible_values = "One value"
                 assert_equal ["One value"], field.possible_values
               end
               def test_possible_values_should_accept_a_multiline_string
                 field = CustomField.new
                 field.possible_values = "One value\nAnd another one  \r\n \n"
                 assert_equal ["One value", "And another one"], field.possible_values
               end
               def test_destroy
                 field = CustomField.find(1)
                 assert field.destroy
               end
+              def test_new_subclass_instance_should_return_an_instance
+                f = CustomField.new_subclass_instance('IssueCustomField')
+                assert_kind_of IssueCustomField, f
+              end
+              def test_new_subclass_instance_should_set_attributes
+                f = CustomField.new_subclass_instance('IssueCustomField', :name => 'Test')
+                assert_kind_of IssueCustomField, f
+                assert_equal 'Test', f.name
+              end
+              def test_new_subclass_instance_with_invalid_class_name_should_return_nil
+                assert_nil CustomField.new_subclass_instance('WrongClassName')
+              end
+              def test_new_subclass_instance_with_non_subclass_name_should_return_nil
+                assert_nil CustomField.new_subclass_instance('Project')
+              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