simple_form 1.5.2 → 2.0.0.rc

data/lib/simple_form/inputs/boolean_input.rb

@@ -2,21 +2,60 @@ 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?
+          build_hidden_field_for_checkbox +
+            @builder.label(label_target, label_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(text, value, html_options)
+        @builder.check_box(attribute_name, html_options, value, nil) + text
+      end
+
+      def item_wrapper_class
+        "checkbox"
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/collection_input.rb

@@ -13,9 +13,8 @@ module SimpleForm
       end
 
       def input
-        label_method, value_method = detect_collection_methods
-        @builder.send(:"collection_#{input_type}", attribute_name, collection,
-                      value_method, label_method, input_options, input_html_options)
+        raise NotImplementedError,
+          "input should be implemented by classes inheriting from CollectionInput"
       end
 
       def input_options
@@ -27,18 +26,23 @@ module SimpleForm
       private
 
       def collection
-        @collection ||= (options.delete(:collection) || self.class.boolean_collection).to_a
+        @collection ||= begin
+          collection = options.delete(:collection) || self.class.boolean_collection
+          collection.respond_to?(:call) ? collection.call : collection.to_a
+        end
       end
 
-      # Select components does not allow the required html tag.
       def has_required?
-        super && input_type != :select
+        super && (input_options[:include_blank] || multiple?)
       end
 
       # Check if :include_blank must be included by default.
       def skip_include_blank?
-        (options.keys & [:prompt, :include_blank, :default, :selected]).any? ||
-          options[:input_html].try(:[], :multiple)
+        (options.keys & [:prompt, :include_blank, :default, :selected]).any? || multiple?
+      end
+
+      def multiple?
+        !!options[:input_html].try(:[], :multiple)
       end
 
       # Detect the right method to find the label and value for a collection.
@@ -58,10 +62,10 @@ module SimpleForm
         [label, value]
       end
 
-      def detect_common_display_methods
-        collection_classes = detect_collection_classes
+      def detect_common_display_methods(collection_classes = detect_collection_classes)
+        collection_translated = translate_collection if collection_classes == [Symbol]
 
-        if collection_classes.include?(Array)
+        if collection_translated || collection_classes.include?(Array)
           { :label => :first, :value => :last }
         elsif collection_includes_basic_objects?(collection_classes)
           { :label => :to_s, :value => :to_s }
@@ -73,8 +77,8 @@ module SimpleForm
         end
       end
 
-      def detect_collection_classes
-        collection.map { |e| e.class }.uniq
+      def detect_collection_classes(some_collection = collection)
+        some_collection.map { |e| e.class }.uniq
       end
 
       def collection_includes_basic_objects?(collection_classes)
@@ -82,6 +86,16 @@ module SimpleForm
           String, Integer, Fixnum, Bignum, Float, NilClass, Symbol, TrueClass, FalseClass
         ]).any?
       end
+
+      def translate_collection
+        if translated_collection = translate(:options)
+          @collection = collection.map do |key|
+            [translated_collection[key] || key, key]
+          end
+          true
+        end
+      end
     end
   end
 end
+

data/lib/simple_form/inputs/collection_radio_buttons_input.rb

@@ -0,0 +1,69 @@
+module SimpleForm
+  module Inputs
+    class CollectionRadioButtonsInput < CollectionInput
+      def input
+        label_method, value_method = detect_collection_methods
+
+        @builder.send("collection_#{input_type}",
+          attribute_name, collection, value_method, label_method,
+          input_options, input_html_options, &collection_block_for_nested_boolean_style
+        )
+      end
+
+      def input_options
+        options = super
+        apply_default_collection_options!(options)
+        apply_nested_boolean_collection_options!(options) if nested_boolean_style?
+        options
+      end
+
+      protected
+
+      def apply_default_collection_options!(options)
+        unless options.key?(:item_wrapper_tag)
+          options[:item_wrapper_tag] = SimpleForm.item_wrapper_tag
+        end
+        options[:item_wrapper_class] = [
+          item_wrapper_class, options[:item_wrapper_class], SimpleForm.item_wrapper_class
+        ].compact.presence
+
+        unless options.key?(:collection_wrapper_tag)
+          options[:collection_wrapper_tag] = SimpleForm.collection_wrapper_tag
+        end
+        options[:collection_wrapper_class] = [
+          options[:collection_wrapper_class], SimpleForm.collection_wrapper_class
+        ].compact.presence
+      end
+
+      # Force item wrapper to be a label when using nested boolean, to support
+      # configuring classes through :item_wrapper_class, and to maintain
+      # compatibility with :inline style and default :item_wrapper_tag.
+      def apply_nested_boolean_collection_options!(options)
+        options[:item_wrapper_tag] = :label
+      end
+
+      def collection_block_for_nested_boolean_style
+        return unless nested_boolean_style?
+
+        proc do |label_for, text, value, html_options|
+          build_nested_boolean_style_item_tag(text, value, html_options)
+        end
+      end
+
+      def build_nested_boolean_style_item_tag(text, value, html_options)
+        @builder.radio_button(attribute_name, value, html_options) + text
+      end
+
+      def item_wrapper_class
+        "radio"
+      end
+
+      # Do not attempt to generate label[for] attributes by default, unless an
+      # explicit html option is given. This avoids generating labels pointing to
+      # non existent fields.
+      def generate_label_for_attribute?
+        false
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/collection_select_input.rb

@@ -0,0 +1,14 @@
+module SimpleForm
+  module Inputs
+    class CollectionSelectInput < CollectionInput
+      def input
+        label_method, value_method = detect_collection_methods
+
+        @builder.collection_select(
+          attribute_name, collection, value_method, label_method,
+          input_options, input_html_options
+        )
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/date_time_input.rb

@@ -5,12 +5,12 @@ module SimpleForm
         @builder.send(:"#{input_type}_select", attribute_name, input_options, input_html_options)
       end
 
-      private
-
       def has_required?
         false
       end
 
+      private
+
       def label_target
         case input_type
         when :date, :datetime

data/lib/simple_form/inputs/grouped_collection_select_input.rb

@@ -0,0 +1,41 @@
+module SimpleForm
+  module Inputs
+    class GroupedCollectionSelectInput < CollectionInput
+      def input
+        label_method, value_method = detect_collection_methods
+        @builder.grouped_collection_select(attribute_name, grouped_collection,
+                      group_method, group_label_method, value_method, label_method,
+                      input_options, input_html_options)
+      end
+
+      private
+
+      def grouped_collection
+        @grouped_collection ||= begin
+          grouped_collection = options.delete(:collection)
+          grouped_collection.respond_to?(:call) ? grouped_collection.call : grouped_collection.to_a
+        end
+      end
+
+      # Sample collection
+      def collection
+        @collection ||= grouped_collection.first.try(:send, group_method)
+      end
+
+      def group_method
+        @group_method ||= options.delete(:group_method)
+      end
+
+      def group_label_method
+        label = options.delete(:group_label_method)
+
+        unless label
+          common_method_for = detect_common_display_methods(detect_collection_classes(grouped_collection))
+          label = common_method_for[:label]
+        end
+
+        label
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/hidden_input.rb

@@ -1,17 +1,14 @@
 module SimpleForm
   module Inputs
     class HiddenInput < Base
-      def render
+      disable :label, :errors, :hint, :required
+
+      def input
         @builder.hidden_field(attribute_name, input_html_options)
       end
-      alias :input :render
 
       private
 
-      def attribute_required?
-        false
-      end
-
       def required_class
         nil
       end

data/lib/simple_form/inputs/numeric_input.rb

@@ -1,72 +1,24 @@
 module SimpleForm
   module Inputs
     class NumericInput < Base
-      enable :placeholder
+      enable :placeholder, :min_max
 
       def input
         add_size!
-        if SimpleForm.html5
+        input_html_classes.unshift("numeric")
+        if html5?
           input_html_options[:type] ||= "number"
           input_html_options[:step] ||= integer? ? 1 : "any"
-          infer_attributes_from_validations!
         end
         @builder.text_field(attribute_name, input_html_options)
       end
 
-      def input_html_classes
-        super.unshift("numeric")
-      end
-
       private
 
       # Rails adds the size attr by default, if the :size key does not exist.
       def add_size!
         input_html_options[:size] ||= nil
       end
-
-      def infer_attributes_from_validations!
-        return unless has_validators?
-
-        numeric_validator = find_numericality_validator or return
-        validator_options = numeric_validator.options
-
-        input_html_options[:min] ||= minimum_value(validator_options)
-        input_html_options[:max] ||= maximum_value(validator_options)
-      end
-
-      def integer?
-        input_type == :integer
-      end
-
-      def minimum_value(validator_options)
-        if integer? && validator_options.key?(:greater_than)
-          evaluate_validator_option(validator_options[:greater_than]) + 1
-        else
-          evaluate_validator_option(validator_options[:greater_than_or_equal_to])
-        end
-      end
-
-      def maximum_value(validator_options)
-        if integer? && validator_options.key?(:less_than)
-          evaluate_validator_option(validator_options[:less_than]) - 1
-        else
-          evaluate_validator_option(validator_options[:less_than_or_equal_to])
-        end
-      end
-
-      def find_numericality_validator
-        find_validator(ActiveModel::Validations::NumericalityValidator)
-      end
-
-      def evaluate_validator_option(option)
-        if option.is_a?(Numeric)
-          option
-        elsif option.is_a?(Symbol)
-          object.send(option)
-        elsif option.respond_to?(:call)
-          option.call(object)
-        end
-      end
     end
   end
 end

data/lib/simple_form/inputs/password_input.rb

@@ -1,11 +1,10 @@
 module SimpleForm
   module Inputs
     class PasswordInput < Base
-      enable :placeholder
+      enable :placeholder, :maxlength
 
       def input
         add_size!
-        add_maxlength!
         @builder.password_field(attribute_name, input_html_options)
       end
     end

data/lib/simple_form/inputs/priority_input.rb

@@ -1,6 +1,6 @@
 module SimpleForm
   module Inputs
-    class PriorityInput < CollectionInput
+    class PriorityInput < CollectionSelectInput
       def input
         @builder.send(:"#{input_type}_select", attribute_name, input_priority,
                       input_options, input_html_options)
@@ -10,7 +10,7 @@ module SimpleForm
         options[:priority] || SimpleForm.send(:"#{input_type}_priority")
       end
 
-    protected
+      protected
 
       def has_required?
         false

data/lib/simple_form/inputs/range_input.rb

@@ -1,10 +1,8 @@
 module SimpleForm
   module Inputs
     class RangeInput < NumericInput
-      disable :placeholder
-
       def input
-        if SimpleForm.html5
+        if html5?
           input_html_options[:type] ||= "range"
           input_html_options[:step] ||= 1
         end