simple_form 1.5.2 → 2.0.0

data/lib/simple_form/form_builder.rb

@@ -1,6 +1,14 @@
+require 'simple_form/core_ext/hash'
+
 module SimpleForm
   class FormBuilder < ActionView::Helpers::FormBuilder
-    attr_reader :template, :object_name, :object
+    attr_reader :template, :object_name, :object, :wrapper
+
+    # When action is create or update, we still should use new and edit
+    ACTIONS = {
+      :create => :new,
+      :update => :edit
+    }
 
     extend MapType
     include SimpleForm::Inputs
@@ -11,7 +19,10 @@ module SimpleForm
     map_type :password,                            :to => SimpleForm::Inputs::PasswordInput
     map_type :integer, :decimal, :float,           :to => SimpleForm::Inputs::NumericInput
     map_type :range,                               :to => SimpleForm::Inputs::RangeInput
-    map_type :select, :radio, :check_boxes,        :to => SimpleForm::Inputs::CollectionInput
+    map_type :check_boxes,                         :to => SimpleForm::Inputs::CollectionCheckBoxesInput
+    map_type :radio_buttons,                       :to => SimpleForm::Inputs::CollectionRadioButtonsInput
+    map_type :select,                              :to => SimpleForm::Inputs::CollectionSelectInput
+    map_type :grouped_select,                      :to => SimpleForm::Inputs::GroupedCollectionSelectInput
     map_type :date, :time, :datetime,              :to => SimpleForm::Inputs::DateTimeInput
     map_type :country, :time_zone,                 :to => SimpleForm::Inputs::PriorityInput
     map_type :boolean,                             :to => SimpleForm::Inputs::BooleanInput
@@ -20,6 +31,12 @@ module SimpleForm
       @discovery_cache ||= {}
     end
 
+    def initialize(*) #:nodoc:
+      super
+      @defaults = options[:defaults]
+      @wrapper  = SimpleForm.wrapper(options[:wrapper] || SimpleForm.default_wrapper)
+    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
@@ -71,8 +88,8 @@ module SimpleForm
     #
     # == Collection
     #
-    # When playing with collections (:radio and :select inputs), you have three extra
-    # options:
+    # 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
     #
@@ -86,14 +103,16 @@ module SimpleForm
     # given SimpleForm.time_zone_priority and SimpleForm.country_priority are used respectivelly.
     #
     def input(attribute_name, options={}, &block)
-      column     = find_attribute_column(attribute_name)
-      input_type = default_input_type(attribute_name, column, options)
+      options = @defaults.deep_dup.deep_merge(options) if @defaults
 
-      if block_given?
-        SimpleForm::Inputs::BlockInput.new(self, attribute_name, column, input_type, options, &block).render
-      else
-        find_mapping(input_type).new(self, attribute_name, column, input_type, options).render
-      end
+      chosen =
+        if name = options[:wrapper]
+          name.respond_to?(:render) ? name : SimpleForm.wrapper(name)
+        else
+          wrapper
+        end
+
+      chosen.render find_input(attribute_name, options, &block)
     end
     alias :attribute :input
 
@@ -112,12 +131,9 @@ module SimpleForm
     #        name="user[name]" size="100" type="text" value="Carlos" />
     #
     def input_field(attribute_name, options={})
-      column     = find_attribute_column(attribute_name)
-      input_type = default_input_type(attribute_name, column, options)
-
+      options = options.dup
       options[:input_html] = options.except(:as, :collection, :label_method, :value_method)
-
-      find_mapping(input_type).new(self, attribute_name, column, input_type, options).input
+      SimpleForm::Wrappers::Root.new([:input], :wrapper => false).render find_input(attribute_name, options)
     end
 
     # Helper for dealing with association selects/radios, generating the
@@ -147,6 +163,8 @@ module SimpleForm
     # From the options above, only :collection can also be supplied.
     #
     def association(association, options={}, &block)
+      options = options.dup
+
       return simple_fields_for(*[association,
         options.delete(:collection), options].compact, &block) if block_given?
 
@@ -160,7 +178,7 @@ module SimpleForm
 
       attribute = case reflection.macro
         when :belongs_to
-          reflection.options[:foreign_key] || :"#{reflection.name}_id"
+          (reflection.respond_to?(:options) && reflection.options[:foreign_key]) || :"#{reflection.name}_id"
         when :has_one
           raise ":has_one associations are not supported by f.association"
         else
@@ -188,11 +206,15 @@ module SimpleForm
     #     f.button :submit
     #   end
     #
-    # It just acts as a proxy to method name given.
+    # It just acts as a proxy to method name given. We also alias original Rails
+    # button implementation (3.2 forward (to delegate to the original when
+    # calling `f.button :button`.
     #
+    # TODO: remove if condition when supporting only Rails 3.2 forward.
+    alias_method :button_button, :button if method_defined?(:button)
     def button(type, *args, &block)
-      options = args.extract_options!
-      options[:class] = "button #{options[:class]}".strip
+      options = args.extract_options!.dup
+      options[:class] = [SimpleForm.button_class, options[:class]].compact
       args << options
       if respond_to?("#{type}_button")
         send("#{type}_button", *args, &block)
@@ -210,10 +232,13 @@ module SimpleForm
     #    f.error :name, :id => "cool_error"
     #
     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)
-      SimpleForm::Inputs::Base.new(self, attribute_name, column, input_type, options).error
+      wrapper.find(:error).
+        render(SimpleForm::Inputs::Base.new(self, attribute_name, column, input_type, options))
     end
 
     # Return the error but also considering its name. This is used
@@ -224,6 +249,8 @@ module SimpleForm
     #    f.full_error :token #=> <span class="error">Token is invalid</span>
     #
     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
@@ -244,7 +271,9 @@ module SimpleForm
     #    f.hint "Don't forget to accept this"
     #
     def hint(attribute_name, options={})
-      options[:hint_html] = options.except(:hint_tag)
+      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
@@ -252,7 +281,9 @@ module SimpleForm
         column      = find_attribute_column(attribute_name)
         input_type  = default_input_type(attribute_name, column, options)
       end
-      SimpleForm::Inputs::Base.new(self, attribute_name, column, input_type, options).hint
+
+      wrapper.find(:hint).
+        render(SimpleForm::Inputs::Base.new(self, attribute_name, column, input_type, options))
     end
 
     # Creates a default label tag for the given attribute. You can give a label
@@ -270,10 +301,10 @@ module SimpleForm
     #
     def label(attribute_name, *args)
       return super if args.first.is_a?(String) || block_given?
-      options = args.extract_options!
-      options[:label_html] = options.dup
-      options[:label]      = options.delete(:label)
-      options[:required]   = options.delete(:required)
+
+      options = args.extract_options!.dup
+      options[:label_html] = options.except(:label, :required)
+
       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
@@ -294,7 +325,53 @@ module SimpleForm
       SimpleForm::ErrorNotification.new(self, options).render
     end
 
-  private
+    # Extract the model names from the object_name mess, ignoring numeric and
+    # explicit child indexes.
+    #
+    # Example:
+    #
+    # route[blocks_attributes][0][blocks_learning_object_attributes][1][foo_attributes]
+    # ["route", "blocks", "blocks_learning_object", "foo"]
+    #
+    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
+
+    # The action to be used in lookup.
+    def lookup_action
+      @lookup_action ||= begin
+        action = template.controller.action_name
+        return unless action
+        action = action.to_sym
+        ACTIONS[action] || action
+      end
+    end
+
+    private
+
+    # Find an input based on the attribute name.
+    def find_input(attribute_name, options={}, &block) #:nodoc:
+      column     = find_attribute_column(attribute_name)
+      input_type = default_input_type(attribute_name, column, options)
+
+      if input_type == :radio
+        SimpleForm.deprecation_warn "Using `:as => :radio` as input type is " \
+          "deprecated, please change it to `:as => :radio_buttons`."
+        input_type = :radio_buttons
+      end
+
+      if block_given?
+        SimpleForm::Inputs::BlockInput.new(self, attribute_name, column, input_type, options, &block)
+      else
+        find_mapping(input_type).new(self, attribute_name, column, input_type, options)
+      end
+    end
 
     # Attempt to guess the better input type given the defined options. By
     # default alwayls fallback to the user :as option, or to a :select when a

data/lib/simple_form/helpers/autofocus.rb

@@ -0,0 +1,11 @@
+module SimpleForm
+  module Helpers
+    module Autofocus
+      private
+
+      def has_autofocus?
+        options[:autofocus] == true
+      end
+    end
+  end
+end

data/lib/simple_form/helpers/disabled.rb

@@ -0,0 +1,15 @@
+module SimpleForm
+  module Helpers
+    module Disabled
+      private
+
+      def has_disabled?
+        options[:disabled] == true
+      end
+
+      def disabled_class
+        :disabled if has_disabled?
+      end
+    end
+  end
+end

data/lib/simple_form/helpers/readonly.rb

@@ -0,0 +1,15 @@
+module SimpleForm
+  module Helpers
+    module Readonly
+      private
+
+      def readonly_class
+        :readonly if has_readonly?
+      end
+
+      def has_readonly?
+        options[:readonly] == true
+      end
+    end
+  end
+end

data/lib/simple_form/helpers/required.rb

@@ -3,7 +3,7 @@ module SimpleForm
     module Required
       private
 
-      def attribute_required?
+      def required_field?
         @required
       end
 
@@ -11,26 +11,25 @@ module SimpleForm
         if !options[:required].nil?
           options[:required]
         elsif has_validators?
-          (attribute_validators + reflection_validators).any? do |v|
-            v.kind == :presence && valid_validator?(v)
-          end
+          required_by_validators?
         else
-          attribute_required_by_default?
+          required_by_default?
         end
       end
 
-      # Whether this input is valid for HTML 5 required attribute.
-      def has_required?
-        attribute_required? && SimpleForm.html5 && SimpleForm.browser_validations
+      def required_by_validators?
+        (attribute_validators + reflection_validators).any? { |v| v.kind == :presence && valid_validator?(v) }
       end
 
-      def attribute_required_by_default?
+      def required_by_default?
         SimpleForm.required_by_default
       end
 
+      # Do not use has_required? because we want to add the class
+      # regardless of the required option.
       def required_class
-        attribute_required? ? :required : :optional
+        required_field? ? :required : :optional
       end
     end
   end
-end
+end

data/lib/simple_form/helpers/validators.rb

@@ -1,12 +1,12 @@
 module SimpleForm
   module Helpers
     module Validators
-      private
-
       def has_validators?
-        attribute_name && object.class.respond_to?(:validators_on)
+        @has_validators ||= attribute_name && object.class.respond_to?(:validators_on)
       end
 
+      private
+
       def attribute_validators
         object.class.validators_on(attribute_name)
       end
@@ -37,7 +37,7 @@ module SimpleForm
       end
 
       def find_validator(validator)
-        attribute_validators.find { |v| validator === v }
+        attribute_validators.find { |v| validator === v } if has_validators?
       end
     end
   end

data/lib/simple_form/helpers.rb

@@ -1,9 +1,12 @@
 module SimpleForm
+  # Helpers are made of several helpers that cannot be turned on automatically.
+  # For instance, disabled cannot be turned on automatically, it requires the
+  # user to explicitly pass the option :disabled => true so it may work.
   module Helpers
-    autoload :HasErrors,    'simple_form/helpers/has_errors'
-    autoload :Maxlength,    'simple_form/helpers/maxlength'
-    autoload :Pattern,      'simple_form/helpers/pattern'
-    autoload :Validators,   'simple_form/helpers/validators'
+    autoload :Autofocus,    'simple_form/helpers/autofocus'
+    autoload :Disabled,     'simple_form/helpers/disabled'
+    autoload :Readonly,     'simple_form/helpers/readonly'
     autoload :Required,     'simple_form/helpers/required'
+    autoload :Validators,   'simple_form/helpers/validators'
   end
 end

data/lib/simple_form/inputs/base.rb

@@ -3,49 +3,71 @@ module SimpleForm
     class Base
       extend I18nCache
 
-      # When action is create or update, we still should use new and edit
-      ACTIONS = {
-        :create => :new,
-        :update => :edit
-      }
-
+      include SimpleForm::Helpers::Autofocus
+      include SimpleForm::Helpers::Disabled
+      include SimpleForm::Helpers::Readonly
       include SimpleForm::Helpers::Required
       include SimpleForm::Helpers::Validators
-      include SimpleForm::Helpers::Maxlength
-      include SimpleForm::Helpers::Pattern
 
       include SimpleForm::Components::Errors
       include SimpleForm::Components::Hints
+      include SimpleForm::Components::HTML5
       include SimpleForm::Components::LabelInput
+      include SimpleForm::Components::Maxlength
+      include SimpleForm::Components::MinMax
+      include SimpleForm::Components::Pattern
       include SimpleForm::Components::Placeholders
-      include SimpleForm::Components::Wrapper
+      include SimpleForm::Components::Readonly
+
+      attr_reader :attribute_name, :column, :input_type, :reflection,
+                  :options, :input_html_options, :input_html_classes, :html_classes
+
+      delegate :template, :object, :object_name, :lookup_model_names, :lookup_action, :to => :@builder
 
-      # Enables certain components support to the given input.
-      def self.enable(*args)
-        args.each { |m| alias_method m, :"enabled_#{m}" }
+      class_attribute :default_options
+      self.default_options = {}
+
+      def self.enable(*keys)
+        options = self.default_options.dup
+        keys.each { |key| options.delete(key) }
+        self.default_options = options
       end
 
-      def self.disable(*args)
-        args.each { |m| alias_method m, :"disabled_#{m}" }
+      def self.disable(*keys)
+        options = self.default_options.dup
+        keys.each { |key| options[key] = false }
+        self.default_options = options
       end
 
-      attr_reader :attribute_name, :column, :input_type, :reflection,
-                  :options, :input_html_options
+      # Always enabled.
+      enable :hint
 
-      delegate :template, :object, :object_name, :to => :@builder
+      # Usually disabled, needs to be enabled explicitly passing true as option.
+      disable :maxlength, :placeholder, :pattern, :min_max
 
       def initialize(builder, attribute_name, column, input_type, options = {})
+        super
+
         @builder            = builder
         @attribute_name     = attribute_name
         @column             = column
         @input_type         = input_type
         @reflection         = options.delete(:reflection)
-        @options            = options
+        @options            = options.reverse_merge!(self.class.default_options)
         @required           = calculate_required
+
+        # Notice that html_options_for receives a reference to input_html_classes.
+        # This means that classes added dynamically to input_html_classes will
+        # still propagate to input_html_options.
+        @html_classes = SimpleForm.additional_classes_for(:input) {
+          [input_type, required_class, readonly_class, disabled_class].compact
+        }
+
+        @input_html_classes = @html_classes.dup
         @input_html_options = html_options_for(:input, input_html_classes).tap do |o|
-          o[:required]  = true if has_required?
-          o[:disabled]  = true if disabled?
-          o[:autofocus] = true if has_autofocus? && SimpleForm.html5
+          o[:readonly]  = true if has_readonly?
+          o[:disabled]  = true if has_disabled?
+          o[:autofocus] = true if has_autofocus?
         end
       end
 
@@ -57,20 +79,6 @@ module SimpleForm
         options
       end
 
-      def input_html_classes
-        [input_type, required_class]
-      end
-
-      def render
-        content = "".html_safe
-        components_list.each do |component|
-          next if options[component] == false
-          rendered = send(component)
-          content.safe_concat rendered.to_s if rendered
-        end
-        wrap(content)
-      end
-
       private
 
       def add_size!
@@ -81,17 +89,8 @@ module SimpleForm
         column && column.limit
       end
 
-      def components_list
-        if components = options[:components]
-          ActiveSupport::Deprecation.warn "The option :components of f.input is deprecated. Please turn off each component individually instead."
-          components
-        else
-          SimpleForm.components
-        end
-      end
-
-      def has_autofocus?
-        options[:autofocus]
+      def nested_boolean_style?
+        options.fetch(:boolean_style, SimpleForm.boolean_style) == :nested
       end
 
       # Find reflection name when available, otherwise use attribute
@@ -100,22 +99,19 @@ module SimpleForm
       end
 
       # Retrieve options for the given namespace from the options hash
-      def html_options_for(namespace, extra)
+      def html_options_for(namespace, css_classes)
         html_options = options[:"#{namespace}_html"] || {}
-        html_options[:class] = (extra << html_options[:class]).join(' ').strip if extra.present?
+        css_classes << html_options[:class] if html_options.key?(:class)
+        html_options[:class] = css_classes
         html_options
       end
 
-      def disabled?
-        options[:disabled] == true
-      end
-
       # Lookup translations for the given namespace using I18n, based on object name,
       # actual action and attribute name. Lookup priority as follows:
       #
       #   simple_form.{namespace}.{model}.{action}.{attribute}
       #   simple_form.{namespace}.{model}.{attribute}
-      #   simple_form.{namespace}.{attribute}
+      #   simple_form.{namespace}.defaults.{attribute}
       #
       #  Namespace is used for :labels and :hints.
       #
@@ -130,7 +126,7 @@ module SimpleForm
       #   simple_form.{namespace}.{model}.{nested}.{attribute}
       #   simple_form.{namespace}.{nested}.{action}.{attribute}
       #   simple_form.{namespace}.{nested}.{attribute}
-      #   simple_form.{namespace}.{attribute}
+      #   simple_form.{namespace}.defaults.{attribute}
       #
       #  Example:
       #
@@ -144,9 +140,7 @@ module SimpleForm
       #
       #  Take a look at our locale example file.
       def translate(namespace, default='')
-        return nil unless SimpleForm.translate
-
-        model_names = lookup_model_names
+        model_names = lookup_model_names.dup
         lookups     = []
 
         while !model_names.empty?
@@ -156,34 +150,12 @@ module SimpleForm
           lookups << :"#{joined_model_names}.#{lookup_action}.#{reflection_or_attribute_name}"
           lookups << :"#{joined_model_names}.#{reflection_or_attribute_name}"
         end
-        lookups << :"#{reflection_or_attribute_name}"
+        lookups << :"defaults.#{lookup_action}.#{reflection_or_attribute_name}"
+        lookups << :"defaults.#{attribute_name}"
         lookups << default
 
         I18n.t(lookups.shift, :scope => :"simple_form.#{namespace}", :default => lookups).presence
       end
-
-      # Extract the model names from the object_name mess, ignoring numeric and
-      # explicit child indexes.
-      #
-      # Example:
-      #
-      # route[blocks_attributes][0][blocks_learning_object_attributes][1][foo_attributes]
-      # ["route", "blocks", "blocks_learning_object", "foo"]
-      #
-      def lookup_model_names
-        child_index = @builder.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', '') }
-      end
-
-      # The action to be used in lookup.
-      def lookup_action
-        action = template.controller.action_name
-        return unless action
-        action = action.to_sym
-        ACTIONS[action] || action
-      end
     end
   end
 end

data/lib/simple_form/inputs/boolean_input.rb

@@ -2,21 +2,63 @@ module SimpleForm
   module Inputs
     class BooleanInput < Base
       def input
-        @builder.check_box(attribute_name, input_html_options)
+        if nested_boolean_style?
+          build_hidden_field_for_checkbox +
+            template.label_tag(nil, :class => "checkbox") {
+              build_check_box_without_hidden_field
+            }
+        else
+          build_check_box
+        end
       end
 
       def label_input
-        input + (options[:label] == false ? "" : label)
+        if options[:label] == false
+          input
+        elsif nested_boolean_style?
+          html_options = label_html_options.dup
+          html_options[:class].push(:checkbox)
+
+          build_hidden_field_for_checkbox +
+            @builder.label(label_target, html_options) {
+              build_check_box_without_hidden_field + label_text
+            }
+        else
+          input + label
+        end
       end
 
       private
 
+      # Build a checkbox tag using default unchecked value. This allows us to
+      # reuse the method for nested boolean style, but with no unchecked value,
+      # which won't generate the hidden checkbox. This is the default functionality
+      # in Rails > 3.2.1, and is backported in SimpleForm AV helpers.
+      def build_check_box(unchecked_value='0')
+        @builder.check_box(attribute_name, input_html_options, '1', unchecked_value)
+      end
+
+      # Build a checkbox without generating the hidden field. See
+      # #build_hidden_field_for_checkbox for more info.
+      def build_check_box_without_hidden_field
+        build_check_box(nil)
+      end
+
+      # Create a hidden field for the current checkbox, so we can simulate Rails
+      # functionality with hidden + checkbox, but under a nested context, where
+      # we need the hidden field to be *outside* the label (otherwise it
+      # generates invalid html - html5 only).
+      def build_hidden_field_for_checkbox
+        @builder.hidden_field(attribute_name, :value => '0', :id => nil,
+                              :disabled => input_html_options[:disabled])
+      end
+
       # Booleans are not required by default because in most of the cases
       # it makes no sense marking them as required. The only exception is
       # Terms of Use usually presented at most sites sign up screen.
-      def attribute_required_by_default?
+      def required_by_default?
         false
       end
     end
   end
-end
+end

data/lib/simple_form/inputs/collection_check_boxes_input.rb

@@ -0,0 +1,21 @@
+module SimpleForm
+  module Inputs
+    class CollectionCheckBoxesInput < CollectionRadioButtonsInput
+      protected
+
+      # Checkbox components do not use the required html tag.
+      # More info: https://github.com/plataformatec/simple_form/issues/340#issuecomment-2871956
+      def has_required?
+        false
+      end
+
+      def build_nested_boolean_style_item_tag(collection_builder)
+        collection_builder.check_box + collection_builder.text
+      end
+
+      def item_wrapper_class
+        "checkbox"
+      end
+    end
+  end
+end