When action is create or update, we still should use new and edit
# File lib/simple_form/form_builder.rb, line 30 def self.discovery_cache @discovery_cache ||= {} end
Helper for dealing with association selects/radios, generating the collection automatically. It's just a wrapper to input, so all options supported in input are also supported by association. Some extra options can also be given:
simple_form_for @user do |f| f.association :company # Company.all end f.association :company, :collection => Company.all(:order => 'name') # Same as using :order option, but overriding collection
When a block is given, association simple behaves as a proxy to simple_fields_for:
f.association :company do |c| c.input :name c.input :type end
From the options above, only :collection can also be supplied.
# File lib/simple_form/form_builder.rb, line 166 def association(association, options={}, &block) options = options.dup return simple_fields_for(*[association, options.delete(:collection), options].compact, &block) if block_given? raise ArgumentError, "Association cannot be used in forms not associated with an object" unless @object reflection = find_association_reflection(association) raise "Association #{association.inspect} not found" unless reflection options[:as] ||= :select options[:collection] ||= options.fetch(:collection) { reflection.klass.all(reflection.options.slice(:conditions, :order)) } attribute = case reflection.macro when :belongs_to (reflection.respond_to?(:options) && reflection.options[:foreign_key]) || :"#{reflection.name}_id" when :has_one raise ArgumentError, ":has_one associations are not supported by f.association" else if options[:as] == :select html_options = options[:input_html] ||= {} html_options[:size] ||= 5 html_options[:multiple] = true unless html_options.key?(:multiple) end # Force the association to be preloaded for performance. if options[:preload] != false && object.respond_to?(association) target = object.send(association) target.to_a if target.respond_to?(:to_a) end :"#{reflection.name.to_s.singularize}_ids" end input(attribute, options.merge(:reflection => reflection)) end
Creates an error tag based on the given attribute, only when the attribute contains errors. All the given options are sent as :error_html.
f.error :name f.error :name, :id => "cool_error"
# File lib/simple_form/form_builder.rb, line 237 def error(attribute_name, options={}) options = options.dup options[:error_html] = options.except(:error_tag, :error_prefix, :error_method) column = find_attribute_column(attribute_name) input_type = default_input_type(attribute_name, column, options) wrapper.find(:error). render(SimpleForm::Inputs::Base.new(self, attribute_name, column, input_type, options)) end
Creates an error notification message that only appears when the form object has some error. You can give a specific message with the :message option, otherwise it will look for a message using I18n. All other options given are passed straight as html options to the html tag.
f.error_notification f.error_notification :message => 'Something went wrong' f.error_notification :id => 'user_error_message', :class => 'form_error'
# File lib/simple_form/form_builder.rb, line 327 def error_notification(options={}) SimpleForm::ErrorNotification.new(self, options).render end
Return the error but also considering its name. This is used when errors for a hidden field need to be shown.
f.full_error :token #=> <span class="error">Token is invalid</span>
# File lib/simple_form/form_builder.rb, line 254 def full_error(attribute_name, options={}) options = options.dup options[:error_prefix] ||= if object.class.respond_to?(:human_attribute_name) object.class.human_attribute_name(attribute_name.to_s) else attribute_name.to_s.humanize end error(attribute_name, options) end
Creates a hint tag for the given attribute. Accepts a symbol indicating an attribute for I18n lookup or a string. All the given options are sent as :hint_html.
f.hint :name # Do I18n lookup f.hint :name, :id => "cool_hint" f.hint "Don't forget to accept this"
# File lib/simple_form/form_builder.rb, line 276 def hint(attribute_name, options={}) options = options.dup options[:hint_html] = options.except(:hint_tag, :hint) if attribute_name.is_a?(String) options[:hint] = attribute_name attribute_name, column, input_type = nil, nil, nil else column = find_attribute_column(attribute_name) input_type = default_input_type(attribute_name, column, options) end wrapper.find(:hint). render(SimpleForm::Inputs::Base.new(self, attribute_name, column, input_type, options)) end
Basic input helper, combines all components in the stack to generate input html based on options the user define and some guesses through database column information. By default a call to input will generate label + input + hint (when defined) + errors (when exists), and all can be configured inside a wrapper html.
# Imagine @user has error "can't be blank" on name simple_form_for @user do |f| f.input :name, :hint => 'My hint' end
This is the output html (only the input portion, not the form):
<label class="string required" for="user_name"> <abbr title="required">*</abbr> Super User Name! </label> <input class="string required" id="user_name" maxlength="100" name="user[name]" size="100" type="text" value="Carlos" /> <span class="hint">My hint</span> <span class="error">can't be blank</span>
Each database type will render a default input, based on some mappings and heuristic to determine which is the best option.
You have some options for the input to enable/disable some functions:
:as => allows you to define the input type you want, for instance you can use it to generate a text field for a date column. :required => defines whether this attribute is required or not. True by default.
The fact SimpleForm is built in components allow the interface to be unified. So, for instance, if you need to disable :hint for a given input, you can pass :hint => false. The same works for :error, :label and :wrapper.
Besides the html for any component can be changed. So, if you want to change the label html you just need to give a hash to :label_html. To configure the input html, supply :input_html instead and so on.
Some inputs, as datetime, time and select allow you to give extra options, like prompt and/or include blank. Such options are given in plainly:
f.input :created_at, :include_blank => true
When playing with collections (:radio_buttons, :check_boxes and :select inputs), you have three extra options:
:collection => use to determine the collection to generate the radio or select :label_method => the method to apply on the array collection to get the label :value_method => the method to apply on the array collection to get the value
Some inputs, as :time_zone and :country accepts a :priority option. If none is given SimpleForm.time_zone_priority and SimpleForm.country_priority are used respectively.
# File lib/simple_form/form_builder.rb, line 105 def input(attribute_name, options={}, &block) options = @defaults.deep_dup.deep_merge(options) if @defaults input = find_input(attribute_name, options, &block) chosen = if name = options[:wrapper] || find_wrapper_mapping(input.input_type) name.respond_to?(:render) ? name : SimpleForm.wrapper(name) else wrapper end chosen.render input end
Creates a input tag for the given attribute. All the given options are sent as :input_html.
simple_form_for @user do |f| f.input_field :name end
This is the output html (only the input portion, not the form):
<input class="string required" id="user_name" maxlength="100" name="user[name]" size="100" type="text" value="Carlos" />
# File lib/simple_form/form_builder.rb, line 134 def input_field(attribute_name, options={}) options = options.dup options[:input_html] = options.except(:as, :collection, :label_method, :value_method) SimpleForm::Wrappers::Root.new([:input], :wrapper => false).render find_input(attribute_name, options) end
Creates a default label tag for the given attribute. You can give a label through the :label option or using i18n. All the given options are sent as :label_html.
f.label :name # Do I18n lookup f.label :name, "Name" # Same behavior as Rails, do not add required tag f.label :name, :label => "Name" # Same as above, but adds required tag f.label :name, :required => false f.label :name, :id => "cool_label"
# File lib/simple_form/form_builder.rb, line 305 def label(attribute_name, *args) return super if args.first.is_a?(String) || block_given? options = args.extract_options!.dup options[:label_html] = options.except(:label, :required, :as) column = find_attribute_column(attribute_name) input_type = default_input_type(attribute_name, column, options) SimpleForm::Inputs::Base.new(self, attribute_name, column, input_type, options).label end
The action to be used in lookup.
# File lib/simple_form/form_builder.rb, line 350 def lookup_action @lookup_action ||= begin action = template.controller.action_name return unless action action = action.to_sym ACTIONS[action] || action end end
Extract the model names from the #object_name mess, ignoring numeric and explicit child indexes.
Example:
# File lib/simple_form/form_builder.rb, line 339 def lookup_model_names @lookup_model_names ||= begin child_index = options[:child_index] names = object_name.to_s.scan(/([a-zA-Z_]+)/).flatten names.delete(child_index) if child_index names.each { |name| name.gsub!('_attributes', '') } names.freeze end end
# File lib/simple_form/form_builder.rb, line 448 def find_wrapper_mapping(input_type) SimpleForm.wrapper_mappings && SimpleForm.wrapper_mappings[input_type] end