simple_form 3.0.1 → 3.1.0.rc2

data/lib/simple_form/form_builder.rb

@@ -8,8 +8,8 @@ module SimpleForm
 
     # When action is create or update, we still should use new and edit
     ACTIONS = {
-      create: :new,
-      update: :edit
+      'create' => 'new',
+      'update' => 'edit'
     }
 
     ATTRIBUTE_COMPONENTS = [:html5, :min_max, :maxlength, :placeholder, :pattern, :readonly]
@@ -17,19 +17,19 @@ module SimpleForm
     extend MapType
     include SimpleForm::Inputs
 
-    map_type :text,                                to: SimpleForm::Inputs::TextInput
-    map_type :file,                                to: SimpleForm::Inputs::FileInput
-    map_type :string, :email, :search, :tel, :url, to: SimpleForm::Inputs::StringInput
-    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 :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
+    map_type :text,                                       to: SimpleForm::Inputs::TextInput
+    map_type :file,                                       to: SimpleForm::Inputs::FileInput
+    map_type :string, :email, :search, :tel, :url, :uuid, to: SimpleForm::Inputs::StringInput
+    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 :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
 
     def self.discovery_cache
       @discovery_cache ||= {}
@@ -106,18 +106,13 @@ module SimpleForm
     # 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.
     #
-    def input(attribute_name, options={}, &block)
+    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
+      input   = find_input(attribute_name, options, &block)
+      wrapper = find_wrapper(input.input_type, options)
 
-      chosen.render input
+      wrapper.render input
     end
     alias :attribute :input
 
@@ -135,12 +130,17 @@ module SimpleForm
     #     <input class="string required" id="user_name" maxlength="100"
     #        name="user[name]" type="text" value="Carlos" />
     #
-    def input_field(attribute_name, options={})
+    def input_field(attribute_name, options = {})
       options = options.dup
-      options[:input_html] = options.except(:as, :collection, :label_method, :value_method, *ATTRIBUTE_COMPONENTS)
+      options[:input_html] = options.except(:as, :boolean_style, :collection, :label_method, :value_method, *ATTRIBUTE_COMPONENTS)
       options = @defaults.deep_dup.deep_merge(options) if @defaults
 
-      SimpleForm::Wrappers::Root.new(ATTRIBUTE_COMPONENTS + [:input], wrapper: false).render find_input(attribute_name, options)
+      input      = find_input(attribute_name, options)
+      wrapper    = find_wrapper(input.input_type, options)
+      components = (wrapper.components.map(&:namespace) & ATTRIBUTE_COMPONENTS) + [:input]
+      components = components.map { |component| SimpleForm::Wrappers::Leaf.new(component) }
+
+      SimpleForm::Wrappers::Root.new(components, wrapper.options.merge(wrapper: false)).render input
     end
 
     # Helper for dealing with association selects/radios, generating the
@@ -171,7 +171,7 @@ module SimpleForm
     #
     # Please note that the association helper is currently only tested with Active Record. Depending on the ORM you are using your mileage may vary.
     #
-    def association(association, options={}, &block)
+    def association(association, options = {}, &block)
       options = options.dup
 
       return simple_fields_for(*[association,
@@ -183,31 +183,9 @@ module SimpleForm
       raise "Association #{association.inspect} not found" unless reflection
 
       options[:as] ||= :select
-      options[:collection] ||= options.fetch(:collection) {
-        conditions = reflection.options[:conditions]
-        conditions = conditions.call if conditions.respond_to?(:call)
-        reflection.klass.where(conditions).order(reflection.options[: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[: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
+      options[:collection] ||= fetch_association_collection(reflection, options)
+
+      attribute = build_association_attribute(reflection, association, options)
 
       input(attribute, options.merge(reflection: reflection))
     end
@@ -242,7 +220,7 @@ module SimpleForm
     #    f.error :name
     #    f.error :name, id: "cool_error"
     #
-    def error(attribute_name, options={})
+    def error(attribute_name, options = {})
       options = options.dup
 
       options[:error_html] = options.except(:error_tag, :error_prefix, :error_method)
@@ -259,7 +237,7 @@ module SimpleForm
     #
     #    f.full_error :token #=> <span class="error">Token is invalid</span>
     #
-    def full_error(attribute_name, options={})
+    def full_error(attribute_name, options = {})
       options = options.dup
 
       options[:error_prefix] ||= if object.class.respond_to?(:human_attribute_name)
@@ -281,7 +259,7 @@ module SimpleForm
     #    f.hint :name, id: "cool_hint"
     #    f.hint "Don't forget to accept this"
     #
-    def hint(attribute_name, options={})
+    def hint(attribute_name, options = {})
       options = options.dup
 
       options[:hint_html] = options.except(:hint_tag, :hint)
@@ -332,7 +310,7 @@ module SimpleForm
     #    f.error_notification message: 'Something went wrong'
     #    f.error_notification id: 'user_error_message', class: 'form_error'
     #
-    def error_notification(options={})
+    def error_notification(options = {})
       SimpleForm::ErrorNotification.new(self, options).render
     end
 
@@ -464,15 +442,56 @@ module SimpleForm
       @lookup_action ||= begin
         action = template.controller && template.controller.action_name
         return unless action
-        action = action.to_sym
+        action = action.to_s
         ACTIONS[action] || action
       end
     end
 
     private
 
+    def fetch_association_collection(reflection, options)
+      options.fetch(:collection) do
+        relation = reflection.klass.all
+
+        if reflection.respond_to?(:scope) && reflection.scope
+          relation = reflection.klass.instance_exec(&reflection.scope)
+        else
+          order = reflection.options[:order]
+          conditions = reflection.options[:conditions]
+          conditions = object.instance_exec(&conditions) if conditions.respond_to?(:call)
+
+          relation = relation.where(conditions)
+          relation = relation.order(order) if relation.respond_to?(:order)
+        end
+
+        relation
+      end
+    end
+
+    def build_association_attribute(reflection, association, options)
+      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[: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
+    end
+
     # Find an input based on the attribute name.
-    def find_input(attribute_name, options={}, &block) #:nodoc:
+    def find_input(attribute_name, options = {}, &block)
       column     = find_attribute_column(attribute_name)
       input_type = default_input_type(attribute_name, column, options)
 
@@ -486,7 +505,7 @@ module SimpleForm
     # 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
     # collection is given.
-    def default_input_type(attribute_name, column, options) #:nodoc:
+    def default_input_type(attribute_name, column, options)
       return options[:as].to_sym if options[:as]
       return :select             if options[:collection]
       custom_type = find_custom_type(attribute_name.to_s) and return custom_type
@@ -511,24 +530,24 @@ module SimpleForm
       end
     end
 
-    def find_custom_type(attribute_name) #:nodoc:
+    def find_custom_type(attribute_name)
       SimpleForm.input_mappings.find { |match, type|
         attribute_name =~ match
       }.try(:last) if SimpleForm.input_mappings
     end
 
-    def file_method?(attribute_name) #:nodoc:
+    def file_method?(attribute_name)
       file = @object.send(attribute_name) if @object.respond_to?(attribute_name)
       file && SimpleForm.file_methods.any? { |m| file.respond_to?(m) }
     end
 
-    def find_attribute_column(attribute_name) #:nodoc:
+    def find_attribute_column(attribute_name)
       if @object.respond_to?(:column_for_attribute)
         @object.column_for_attribute(attribute_name)
       end
     end
 
-    def find_association_reflection(association) #:nodoc:
+    def find_association_reflection(association)
       if @object.class.respond_to?(:reflect_on_association)
         @object.class.reflect_on_association(association)
       end
@@ -541,24 +560,42 @@ module SimpleForm
     #    b) Or use the found mapping
     # 2) If not, fallbacks to #{input_type}Input
     # 3) If not, fallbacks to SimpleForm::Inputs::#{input_type}Input
-    def find_mapping(input_type) #:nodoc:
+    def find_mapping(input_type)
       discovery_cache[input_type] ||=
         if mapping = self.class.mappings[input_type]
           mapping_override(mapping) || mapping
         else
           camelized = "#{input_type.to_s.camelize}Input"
-          attempt_mapping(camelized, Object) || attempt_mapping(camelized, self.class) ||
+          attempt_mapping_with_custom_namespace(camelized) ||
+            attempt_mapping(camelized, Object) ||
+            attempt_mapping(camelized, self.class) ||
             raise("No input found for #{input_type}")
         end
     end
 
-    def find_wrapper_mapping(input_type) #:nodoc:
-      SimpleForm.wrapper_mappings && SimpleForm.wrapper_mappings[input_type]
+    # Attempts to find a wrapper mapping. It follows the following rules:
+    #
+    # 1) It tries to find a wrapper for the current form
+    # 2) If not, it tries to find a config
+    def find_wrapper_mapping(input_type)
+      if options[:wrapper_mappings] && options[:wrapper_mappings][input_type]
+        options[:wrapper_mappings][input_type]
+      else
+        SimpleForm.wrapper_mappings && SimpleForm.wrapper_mappings[input_type]
+      end
+    end
+
+    def find_wrapper(input_type, options)
+      if name = options[:wrapper] || find_wrapper_mapping(input_type)
+        name.respond_to?(:render) ? name : SimpleForm.wrapper(name)
+      else
+        wrapper
+      end
     end
 
     # If cache_discovery is enabled, use the class level cache that persists
     # between requests, otherwise use the instance one.
-    def discovery_cache #:nodoc:
+    def discovery_cache
       if SimpleForm.cache_discovery
         self.class.discovery_cache
       else
@@ -566,14 +603,16 @@ module SimpleForm
       end
     end
 
-    def mapping_override(klass) #:nodoc:
+    def mapping_override(klass)
       name = klass.name
       if name =~ /^SimpleForm::Inputs/
-        attempt_mapping name.split("::").last, Object
+        input_name = name.split("::").last
+        attempt_mapping_with_custom_namespace(input_name) ||
+          attempt_mapping(input_name, Object)
       end
     end
 
-    def attempt_mapping(mapping, at) #:nodoc:
+    def attempt_mapping(mapping, at)
       return if SimpleForm.inputs_discovery == false && at == Object
 
       begin
@@ -582,5 +621,15 @@ module SimpleForm
         raise if e.message !~ /#{mapping}$/
       end
     end
+
+    def attempt_mapping_with_custom_namespace(input_name)
+      SimpleForm.custom_inputs_namespaces.each do |namespace|
+        if (mapping = attempt_mapping(input_name, namespace.constantize))
+          return mapping
+        end
+      end
+
+      nil
+    end
   end
 end

data/lib/simple_form/helpers.rb

@@ -3,10 +3,10 @@ module SimpleForm
   # 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 :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'
+    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

@@ -1,10 +1,12 @@
 require 'simple_form/i18n_cache'
 require 'active_support/core_ext/string/output_safety'
+require 'action_view/helpers'
 
 module SimpleForm
   module Inputs
     class Base
       include ERB::Util
+      include ActionView::Helpers::TranslationHelper
 
       extend I18nCache
 
@@ -53,14 +55,14 @@ module SimpleForm
       def initialize(builder, attribute_name, column, input_type, options = {})
         super
 
-        options             = options.dup
-        @builder            = builder
-        @attribute_name     = attribute_name
-        @column             = column
-        @input_type         = input_type
-        @reflection         = options.delete(:reflection)
-        @options            = options.reverse_merge!(self.class.default_options)
-        @required           = calculate_required
+        options         = options.dup
+        @builder        = builder
+        @attribute_name = attribute_name
+        @column         = column
+        @input_type     = input_type
+        @reflection     = options.delete(:reflection)
+        @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
@@ -79,7 +81,7 @@ module SimpleForm
         end
       end
 
-      def input
+      def input(wrapper_options = nil)
         raise NotImplementedError
       end
 
@@ -167,7 +169,7 @@ module SimpleForm
       #            email: 'E-mail.'
       #
       #  Take a look at our locale example file.
-      def translate(namespace, default='')
+      def translate_from_namespace(namespace, default = '')
         model_names = lookup_model_names.dup
         lookups     = []
 
@@ -176,13 +178,33 @@ module SimpleForm
           model_names.shift
 
           lookups << :"#{joined_model_names}.#{lookup_action}.#{reflection_or_attribute_name}"
+          lookups << :"#{joined_model_names}.#{lookup_action}.#{reflection_or_attribute_name}_html"
           lookups << :"#{joined_model_names}.#{reflection_or_attribute_name}"
+          lookups << :"#{joined_model_names}.#{reflection_or_attribute_name}_html"
         end
         lookups << :"defaults.#{lookup_action}.#{reflection_or_attribute_name}"
+        lookups << :"defaults.#{lookup_action}.#{reflection_or_attribute_name}_html"
         lookups << :"defaults.#{reflection_or_attribute_name}"
+        lookups << :"defaults.#{reflection_or_attribute_name}_html"
         lookups << default
 
-        I18n.t(lookups.shift, scope: :"simple_form.#{namespace}", default: lookups).presence
+        t(lookups.shift, scope: :"#{i18n_scope}.#{namespace}", default: lookups).presence
+      end
+
+      def merge_wrapper_options(options, wrapper_options)
+        if wrapper_options
+          options.merge(wrapper_options) do |_, oldval, newval|
+            if Array === oldval
+              oldval + Array(newval)
+            end
+          end
+        else
+          options
+        end
+      end
+
+      def i18n_scope
+        SimpleForm.i18n_scope
       end
     end
   end

data/lib/simple_form/inputs/block_input.rb

@@ -6,7 +6,7 @@ module SimpleForm
         @block = block
       end
 
-      def input
+      def input(wrapper_options = nil)
         template.capture(&@block)
       end
     end

data/lib/simple_form/inputs/boolean_input.rb

@@ -1,31 +1,36 @@
 module SimpleForm
   module Inputs
     class BooleanInput < Base
-      def input
+      def input(wrapper_options = nil)
+        merged_input_options = merge_wrapper_options(input_html_options, wrapper_options)
+
         if nested_boolean_style?
           build_hidden_field_for_checkbox +
-            template.label_tag(nil, class: "checkbox") {
-              build_check_box_without_hidden_field + inline_label
+            template.label_tag(nil, class: SimpleForm.boolean_label_class) {
+              build_check_box_without_hidden_field(merged_input_options) +
+                inline_label
             }
         else
-          build_check_box
+          build_check_box(unchecked_value, merged_input_options)
         end
       end
 
-      def label_input
-        if options[:label] == false
-          input
+      def label_input(wrapper_options = nil)
+        if options[:label] == false || inline_label?
+          input(wrapper_options)
         elsif nested_boolean_style?
           html_options = label_html_options.dup
           html_options[:class] ||= []
-          html_options[:class].push(:checkbox)
+          html_options[:class].push(SimpleForm.boolean_label_class) if SimpleForm.boolean_label_class
+
+          merged_input_options = merge_wrapper_options(input_html_options, wrapper_options)
 
           build_hidden_field_for_checkbox +
             @builder.label(label_target, html_options) {
-              build_check_box_without_hidden_field + label_text
+              build_check_box_without_hidden_field(merged_input_options) + label_text
             }
         else
-          input + label
+          input(wrapper_options) + label(wrapper_options)
         end
       end
 
@@ -35,14 +40,14 @@ module SimpleForm
       # 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 = unchecked_value)
+      def build_check_box(unchecked_value, options)
         @builder.check_box(attribute_name, input_html_options, checked_value, 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)
+      def build_check_box_without_hidden_field(options)
+        build_check_box(nil, options)
       end
 
       # Create a hidden field for the current checkbox, so we can simulate Rails
@@ -56,9 +61,17 @@ module SimpleForm
         @builder.hidden_field(attribute_name, options)
       end
 
+      def inline_label?
+        nested_boolean_style? && options[:inline_label]
+      end
+
       def inline_label
         inline_option = options[:inline_label]
-        inline_option == true ? label_text : inline_option
+
+        if inline_option
+          label = inline_option == true ? label_text : html_escape(inline_option)
+          " #{label}".html_safe
+        end
       end
 
       # Booleans are not required by default because in most of the cases

data/lib/simple_form/inputs/collection_input.rb

@@ -12,14 +12,20 @@ module SimpleForm
         end
       end
 
-      def input
+      def input(wrapper_options = nil)
         raise NotImplementedError,
           "input should be implemented by classes inheriting from CollectionInput"
       end
 
       def input_options
         options = super
+
         options[:include_blank] = true unless skip_include_blank?
+
+        [:prompt, :include_blank].each do |key|
+          translate_option options, key
+        end
+
         options
       end
 
@@ -33,7 +39,7 @@ module SimpleForm
       end
 
       def has_required?
-        super && (input_options[:include_blank] || multiple?)
+        super && (input_options[:include_blank] || input_options[:prompt] || multiple?)
       end
 
       # Check if :include_blank must be included by default.
@@ -70,13 +76,17 @@ module SimpleForm
         elsif collection_includes_basic_objects?(collection_classes)
           { label: :to_s, value: :to_s }
         else
-          sample = collection.first || collection.last
-
-          { label: SimpleForm.collection_label_methods.find { |m| sample.respond_to?(m) },
-            value: SimpleForm.collection_value_methods.find { |m| sample.respond_to?(m) } }
+          detect_method_from_class(collection_classes)
         end
       end
 
+      def detect_method_from_class(collection_classes)
+        sample = collection.first || collection.last
+
+        { label: SimpleForm.collection_label_methods.find { |m| sample.respond_to?(m) },
+          value: SimpleForm.collection_value_methods.find { |m| sample.respond_to?(m) } }
+      end
+
       def detect_collection_classes(some_collection = collection)
         some_collection.map { |e| e.class }.uniq
       end
@@ -88,14 +98,27 @@ module SimpleForm
       end
 
       def translate_collection
-        if translated_collection = translate(:options)
+        if translated_collection = translate_from_namespace(:options)
           @collection = collection.map do |key|
-            [translated_collection[key] || key, key]
+            html_key = "#{key}_html".to_sym
+
+            if translated_collection[html_key]
+              [translated_collection[html_key].html_safe || key, key.to_s]
+            else
+              [translated_collection[key] || key, key.to_s]
+            end
           end
           true
         end
       end
+
+      def translate_option(options, key)
+        if options[key] == :translate
+          namespace = key.to_s.pluralize
+
+          options[key] = translate_from_namespace(namespace, true)
+        end
+      end
     end
   end
 end
-

data/lib/simple_form/inputs/collection_radio_buttons_input.rb

@@ -1,19 +1,21 @@
 module SimpleForm
   module Inputs
     class CollectionRadioButtonsInput < CollectionInput
-      def input
+      def input(wrapper_options = nil)
         label_method, value_method = detect_collection_methods
 
+        merged_input_options = merge_wrapper_options(input_html_options, wrapper_options)
+
         @builder.send("collection_#{input_type}",
           attribute_name, collection, value_method, label_method,
-          input_options, input_html_options, &collection_block_for_nested_boolean_style
+          input_options, merged_input_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
 
@@ -23,7 +25,7 @@ module SimpleForm
         options[:item_wrapper_tag] ||= options.fetch(:item_wrapper_tag, SimpleForm.item_wrapper_tag)
         options[:item_wrapper_class] = [
           item_wrapper_class, options[:item_wrapper_class], SimpleForm.item_wrapper_class
-        ].compact.presence
+        ].compact.presence if SimpleForm.include_default_input_wrapper_class
 
         options[:collection_wrapper_tag] ||= options.fetch(:collection_wrapper_tag, SimpleForm.collection_wrapper_tag)
         options[:collection_wrapper_class] = [
@@ -31,13 +33,6 @@ module SimpleForm
         ].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?