bootstrap_form 4.0.0 → 4.1.0

data/lib/bootstrap_form/form_builder.rb

@@ -1,19 +1,20 @@
-require_relative 'aliasing'
-require_relative 'helpers/bootstrap'
+require_relative "aliasing"
+require_relative "helpers/bootstrap"
 
 module BootstrapForm
-  class FormBuilder < ActionView::Helpers::FormBuilder
+  # TODO: Refactor this class and remove the rubocop:disable
+  class FormBuilder < ActionView::Helpers::FormBuilder # rubocop:disable Metrics/ClassLength
     extend BootstrapForm::Aliasing
     include BootstrapForm::Helpers::Bootstrap
 
     attr_reader :layout, :label_col, :control_col, :has_error, :inline_errors, :label_errors, :acts_like_form_tag
 
-    FIELD_HELPERS = %w{color_field date_field datetime_field datetime_local_field
-      email_field month_field number_field password_field phone_field
-      range_field search_field telephone_field text_area text_field time_field
-      url_field week_field}
+    FIELD_HELPERS = %w[color_field date_field datetime_field datetime_local_field
+                       email_field month_field number_field password_field phone_field
+                       range_field search_field telephone_field text_area text_field time_field
+                       url_field week_field].freeze
 
-    DATE_SELECT_HELPERS = %w{date_select time_select datetime_select}
+    DATE_SELECT_HELPERS = %w[date_select time_select datetime_select].freeze
 
     delegate :content_tag, :capture, :concat, to: :@template
 
@@ -23,10 +24,10 @@ module BootstrapForm
       @control_col = options[:control_col] || default_control_col
       @label_errors = options[:label_errors] || false
       @inline_errors = if options[:inline_errors].nil?
-        @label_errors != true
-      else
-        options[:inline_errors] != false
-      end
+                         @label_errors != true
+                       else
+                         options[:inline_errors] != false
+                       end
       @acts_like_form_tag = options[:acts_like_form_tag]
 
       super
@@ -36,7 +37,7 @@ module BootstrapForm
       with_method_name = "#{method_name}_with_bootstrap"
       without_method_name = "#{method_name}_without_bootstrap"
 
-      define_method(with_method_name) do |name, options = {}|
+      define_method(with_method_name) do |name, options={}|
         form_group_builder(name, options) do
           prepend_and_append_input(name, options) do
             send(without_method_name, name, options)
@@ -51,12 +52,10 @@ module BootstrapForm
       with_method_name = "#{method_name}_with_bootstrap"
       without_method_name = "#{method_name}_without_bootstrap"
 
-      define_method(with_method_name) do |name, options = {}, html_options = {}|
+      define_method(with_method_name) do |name, options={}, html_options={}|
         form_group_builder(name, options, html_options) do
           html_class = control_specific_class(method_name)
-          if @layout == :horizontal && !options[:skip_inline].present?
-            html_class = "#{html_class} form-inline"
-          end
+          html_class = "#{html_class} form-inline" if @layout == :horizontal && options[:skip_inline].blank?
           content_tag(:div, class: html_class) do
             input_with_error(name) do
               send(without_method_name, name, options, html_options)
@@ -68,7 +67,7 @@ module BootstrapForm
       bootstrap_method_alias method_name
     end
 
-    def file_field_with_bootstrap(name, options = {})
+    def file_field_with_bootstrap(name, options={})
       options = options.reverse_merge(control_class: "custom-file-input")
       form_group_builder(name, options) do
         content_tag(:div, class: "custom-file") do
@@ -88,7 +87,7 @@ module BootstrapForm
 
     bootstrap_method_alias :file_field
 
-    def select_with_bootstrap(method, choices = nil, options = {}, html_options = {}, &block)
+    def select_with_bootstrap(method, choices=nil, options={}, html_options={}, &block)
       form_group_builder(method, options, html_options) do
         prepend_and_append_input(method, options) do
           select_without_bootstrap(method, choices, options, html_options, &block)
@@ -98,7 +97,7 @@ module BootstrapForm
 
     bootstrap_method_alias :select
 
-    def collection_select_with_bootstrap(method, collection, value_method, text_method, options = {}, html_options = {})
+    def collection_select_with_bootstrap(method, collection, value_method, text_method, options={}, html_options={})
       form_group_builder(method, options, html_options) do
         input_with_error(method) do
           collection_select_without_bootstrap(method, collection, value_method, text_method, options, html_options)
@@ -108,17 +107,21 @@ module BootstrapForm
 
     bootstrap_method_alias :collection_select
 
-    def grouped_collection_select_with_bootstrap(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
+    def grouped_collection_select_with_bootstrap(method, collection, group_method,
+                                                 group_label_method, option_key_method,
+                                                 option_value_method, options={}, html_options={})
       form_group_builder(method, options, html_options) do
         input_with_error(method) do
-          grouped_collection_select_without_bootstrap(method, collection, group_method, group_label_method, option_key_method, option_value_method, options, html_options)
+          grouped_collection_select_without_bootstrap(method, collection, group_method,
+                                                      group_label_method, option_key_method,
+                                                      option_value_method, options, html_options)
         end
       end
     end
 
     bootstrap_method_alias :grouped_collection_select
 
-    def time_zone_select_with_bootstrap(method, priority_zones = nil, options = {}, html_options = {})
+    def time_zone_select_with_bootstrap(method, priority_zones=nil, options={}, html_options={})
       form_group_builder(method, options, html_options) do
         input_with_error(method) do
           time_zone_select_without_bootstrap(method, priority_zones, options, html_options)
@@ -128,9 +131,10 @@ module BootstrapForm
 
     bootstrap_method_alias :time_zone_select
 
-    def check_box_with_bootstrap(name, options = {}, checked_value = "1", unchecked_value = "0", &block)
+    def check_box_with_bootstrap(name, options={}, checked_value="1", unchecked_value="0", &block)
       options = options.symbolize_keys!
-      check_box_options = options.except(:label, :label_class, :error_message, :help, :inline, :custom, :hide_label, :skip_label, :wrapper_class)
+      check_box_options = options.except(:label, :label_class, :error_message, :help,
+                                         :inline, :custom, :hide_label, :skip_label, :wrapper_class)
       check_box_classes = [check_box_options[:class]]
       check_box_classes << "position-static" if options[:skip_label] || options[:hide_label]
       check_box_classes << "is-invalid" if has_error?(name)
@@ -139,12 +143,12 @@ module BootstrapForm
       label_classes << hide_class if options[:hide_label]
 
       if options[:custom]
-        check_box_options[:class] = (["custom-control-input"] + check_box_classes).compact.join(' ')
+        check_box_options[:class] = (["custom-control-input"] + check_box_classes).compact.join(" ")
         wrapper_class = ["custom-control", "custom-checkbox"]
         wrapper_class.append("custom-control-inline") if layout_inline?(options[:inline])
         label_class = label_classes.prepend("custom-control-label").compact.join(" ")
       else
-        check_box_options[:class] = (["form-check-input"] + check_box_classes).compact.join(' ')
+        check_box_options[:class] = (["form-check-input"] + check_box_classes).compact.join(" ")
         wrapper_class = ["form-check"]
         wrapper_class.append("form-check-inline") if layout_inline?(options[:inline])
         label_class = label_classes.prepend("form-check-label").compact.join(" ")
@@ -160,7 +164,7 @@ module BootstrapForm
       # https://github.com/rails/rails/blob/5-0-stable/actionview/lib/action_view/helpers/tags/base.rb#L123-L125
       if options[:multiple]
         label_name =
-          "#{name}_#{checked_value.to_s.gsub(/\s/, "_").gsub(/[^-[[:word:]]]/, "").mb_chars.downcase.to_s}"
+          "#{name}_#{checked_value.to_s.gsub(/\s/, '_').gsub(/[^-[[:word:]]]/, '').mb_chars.downcase}"
       end
 
       label_options = { class: label_class }
@@ -170,10 +174,10 @@ module BootstrapForm
 
       content_tag(:div, class: wrapper_class.compact.join(" ")) do
         html = if options[:skip_label]
-          checkbox_html
-        else
-          checkbox_html.concat(label(label_name, label_description, label_options))
-        end
+                 checkbox_html
+               else
+                 checkbox_html.concat(label(label_name, label_description, label_options))
+               end
         html.concat(generate_error(name)) if options[:error_message]
         html
       end
@@ -183,21 +187,23 @@ module BootstrapForm
 
     def radio_button_with_bootstrap(name, value, *args)
       options = args.extract_options!.symbolize_keys!
-      radio_options = options.except(:label, :label_class, :error_message, :help, :inline, :custom, :hide_label, :skip_label, :wrapper_class)
+      radio_options = options.except(:label, :label_class, :error_message, :help,
+                                     :inline, :custom, :hide_label, :skip_label,
+                                     :wrapper_class)
       radio_classes = [options[:class]]
       radio_classes << "position-static" if options[:skip_label] || options[:hide_label]
       radio_classes << "is-invalid" if has_error?(name)
 
-      label_classes  = [options[:label_class]]
+      label_classes = [options[:label_class]]
       label_classes << hide_class if options[:hide_label]
 
       if options[:custom]
-        radio_options[:class] = radio_classes.prepend("custom-control-input").compact.join(' ')
+        radio_options[:class] = radio_classes.prepend("custom-control-input").compact.join(" ")
         wrapper_class = ["custom-control", "custom-radio"]
         wrapper_class.append("custom-control-inline") if layout_inline?(options[:inline])
         label_class = label_classes.prepend("custom-control-label").compact.join(" ")
       else
-        radio_options[:class] = radio_classes.prepend("form-check-input").compact.join(' ')
+        radio_options[:class] = radio_classes.prepend("form-check-input").compact.join(" ")
         wrapper_class = ["form-check"]
         wrapper_class.append("form-check-inline") if layout_inline?(options[:inline])
         wrapper_class.append("disabled") if options[:disabled]
@@ -212,10 +218,10 @@ module BootstrapForm
 
       content_tag(:div, class: wrapper_class.compact.join(" ")) do
         html = if options[:skip_label]
-          radio_html
-        else
-          radio_html.concat(label(name, options[:label], label_options))
-        end
+                 radio_html
+               else
+                 radio_html.concat(label(name, options[:label], label_options))
+               end
         html.concat(generate_error(name)) if options[:error_message]
         html
       end
@@ -228,7 +234,7 @@ module BootstrapForm
         options[:multiple] = true
         check_box(name, options, value, nil)
       end
-      hidden_field(args.first,{value: "", multiple: true}).concat(html)
+      hidden_field(args.first, value: "", multiple: true).concat(html)
     end
 
     bootstrap_method_alias :collection_check_boxes
@@ -245,13 +251,15 @@ module BootstrapForm
       options = args.extract_options!
       name = args.first
 
-      options[:class] = ["form-group", options[:class]].compact.join(' ')
+      options[:class] = ["form-group", options[:class]].compact.join(" ")
       options[:class] << " row" if get_group_layout(options[:layout]) == :horizontal &&
                                    !options[:class].split.include?("form-row")
       options[:class] << " form-inline" if field_inline_override?(options[:layout])
       options[:class] << " #{feedback_class}" if options[:icon]
 
-      content_tag(:div, options.except(:append, :id, :label, :help, :icon, :input_group_class, :label_col, :control_col, :layout, :prepend)) do
+      content_tag(:div, options.except(:append, :id, :label, :help, :icon,
+                                       :input_group_class, :label_col, :control_col,
+                                       :add_control_col_class, :layout, :prepend)) do
         label = generate_label(options[:id], name, options[:label], options[:label_col], options[:layout]) if options[:label]
         control = capture(&block)
 
@@ -260,6 +268,7 @@ module BootstrapForm
 
         if get_group_layout(options[:layout]) == :horizontal
           control_class = options[:control_col] || control_col
+          control_class = [control_class, options[:add_control_col_class]].compact.join(" ") if options[:add_control_col_class]
           unless options[:label]
             control_offset = offset_col(options[:label_col] || @label_col)
             control_class = "#{control_class} #{control_offset}"
@@ -272,13 +281,13 @@ module BootstrapForm
       end
     end
 
-    def fields_for_with_bootstrap(record_name, record_object = nil, fields_options = {}, &block)
+    def fields_for_with_bootstrap(record_name, record_object=nil, fields_options={}, &block)
       if record_object.is_a?(Hash) && record_object.extractable_options?
         fields_options = record_object
         record_object = nil
       end
       fields_options[:layout] ||= options[:layout]
-      fields_options[:label_col] = fields_options[:label_col].present? ? "#{fields_options[:label_col]}" : options[:label_col]
+      fields_options[:label_col] = fields_options[:label_col].present? ? (fields_options[:label_col]).to_s : options[:label_col]
       fields_options[:control_col] ||= options[:control_col]
       fields_options[:inline_errors] ||= options[:inline_errors]
       fields_options[:label_errors] ||= options[:label_errors]
@@ -293,19 +302,19 @@ module BootstrapForm
 
     private
 
-    def layout_default?(field_layout = nil)
+    def layout_default?(field_layout=nil)
       [:default, nil].include? layout_in_effect(field_layout)
     end
 
-    def layout_horizontal?(field_layout = nil)
+    def layout_horizontal?(field_layout=nil)
       layout_in_effect(field_layout) == :horizontal
     end
 
-    def layout_inline?(field_layout = nil)
+    def layout_inline?(field_layout=nil)
       layout_in_effect(field_layout) == :inline
     end
 
-    def field_inline_override?(field_layout = nil)
+    def field_inline_override?(field_layout=nil)
       field_layout == :inline && layout != :inline
     end
 
@@ -346,7 +355,7 @@ module BootstrapForm
     end
 
     def control_specific_class(method)
-      "rails-bootstrap-forms-#{method.gsub(/_/, "-")}"
+      "rails-bootstrap-forms-#{method.tr('_', '-')}"
     end
 
     def has_error?(name)
@@ -354,10 +363,9 @@ module BootstrapForm
     end
 
     def required_attribute?(obj, attribute)
+      return false unless obj && attribute
 
-      return false unless obj and attribute
-
-      target = (obj.class == Class) ? obj : obj.class
+      target = obj.class == Class ? obj : obj.class
 
       target_validators = if target.respond_to? :validators_on
                             target.validators_on(attribute).map(&:class)
@@ -366,17 +374,20 @@ module BootstrapForm
                           end
 
       has_presence_validator = target_validators.include?(
-                                 ActiveModel::Validations::PresenceValidator)
+        ActiveModel::Validations::PresenceValidator
+      )
 
       if defined? ActiveRecord::Validations::PresenceValidator
         has_presence_validator |= target_validators.include?(
-                                    ActiveRecord::Validations::PresenceValidator)
+          ActiveRecord::Validations::PresenceValidator
+        )
       end
 
       has_presence_validator
     end
 
-    def form_group_builder(method, options, html_options = nil)
+    # TODO: Refactor this method and remove the rubocop:disable
+    def form_group_builder(method, options, html_options=nil) # rubocop:disable Metrics/MethodLength
       options.symbolize_keys!
 
       wrapper_class = options.delete(:wrapper_class)
@@ -396,6 +407,7 @@ module BootstrapForm
       icon = options.delete(:icon)
       label_col = options.delete(:label_col)
       control_col = options.delete(:control_col)
+      add_control_col_class = options.delete(:add_control_col_class)
       layout = get_group_layout(options.delete(:layout))
       form_group_options = {
         id: options[:id],
@@ -403,13 +415,12 @@ module BootstrapForm
         icon: icon,
         label_col: label_col,
         control_col: control_col,
+        add_control_col_class: add_control_col_class,
         layout: layout,
         class: wrapper_class
       }
 
-      if wrapper_options.is_a?(Hash)
-        form_group_options.merge!(wrapper_options)
-      end
+      form_group_options.merge!(wrapper_options) if wrapper_options.is_a?(Hash)
 
       unless options.delete(:skip_label)
         if options[:label].is_a?(Hash)
@@ -420,27 +431,32 @@ module BootstrapForm
         label_class ||= options.delete(:label_class)
         label_class = hide_class if options.delete(:hide_label) || options[:label_as_placeholder]
 
-        if options[:label].is_a?(String)
-          label_text ||= options.delete(:label)
+        label_text ||= options.delete(:label) if options[:label].is_a?(String)
+
+        if options.key?(:skip_required)
+          warn "`:skip_required` is deprecated, use `:required: false` instead"
+          options[:required] = options.delete(:skip_required) ? false : :default
         end
 
         form_group_options[:label] = {
           text: label_text,
           class: label_class,
-          skip_required: options.delete(:skip_required)
+          required: options[:required]
         }.merge(css_options[:id].present? ? { for: css_options[:id] } : {})
 
-        if options.delete(:label_as_placeholder)
-          css_options[:placeholder] = label_text || object.class.human_attribute_name(method)
-        end
+        css_options[:placeholder] = label_text || object.class.human_attribute_name(method) if options.delete(:label_as_placeholder)
       end
 
-      form_group(method, form_group_options) do
+      if wrapper_options == false
         yield
+      else
+        form_group(method, form_group_options) do
+          yield
+        end
       end
     end
 
-    def convert_form_tag_options(method, options = {})
+    def convert_form_tag_options(method, options={})
       unless @options[:skip_default_ids]
         options[:name] ||= method
         options[:id] ||= method
@@ -463,7 +479,10 @@ module BootstrapForm
         classes << "mr-sm-2"
       end
 
-      unless options.delete(:skip_required)
+      case options.delete(:required)
+      when true
+        classes << "required"
+      when nil, :default
         classes << "required" if required_attribute?(object, name)
       end
 
@@ -487,7 +506,7 @@ module BootstrapForm
     def generate_error(name)
       if has_inline_error?(name)
         help_text = get_error_messages(name)
-        help_klass = 'invalid-feedback'
+        help_klass = "invalid-feedback"
         help_tag = :div
 
         content_tag(help_tag, help_text, class: help_klass)
@@ -497,7 +516,7 @@ module BootstrapForm
     def generate_help(name, help_text)
       return if help_text == false || has_inline_error?(name)
 
-      help_klass ||= 'form-text text-muted'
+      help_klass ||= "form-text text-muted"
       help_text ||= get_help_text_by_i18n_key(name)
       help_tag ||= :small
 
@@ -508,7 +527,7 @@ module BootstrapForm
       object.errors[name].join(", ")
     end
 
-    def inputs_collection(name, collection, value, text, options = {}, &block)
+    def inputs_collection(name, collection, value, text, options={})
       options[:inline] ||= layout_inline?(options[:layout])
       form_group_builder(name, options) do
         inputs = ""
@@ -517,7 +536,7 @@ module BootstrapForm
           input_options = options.merge(label: text.respond_to?(:call) ? text.call(obj) : obj.send(text))
 
           input_value = value.respond_to?(:call) ? value.call(obj) : obj.send(value)
-          if checked = input_options[:checked]
+          if (checked = input_options[:checked])
             input_options[:checked] = checked == input_value                     ||
                                       Array(checked).try(:include?, input_value) ||
                                       checked == obj                             ||
@@ -525,7 +544,7 @@ module BootstrapForm
           end
 
           input_options.delete(:class)
-          inputs << block.call(name, input_value, input_options.merge(error_message: i == collection.size - 1))
+          inputs << yield(name, input_value, input_options.merge(error_message: i == collection.size - 1))
         end
 
         inputs.html_safe
@@ -535,27 +554,29 @@ module BootstrapForm
     def get_help_text_by_i18n_key(name)
       if object
 
-        if object.class.respond_to?(:model_name)
-          partial_scope = object.class.model_name.name
-        else
-          partial_scope = object.class.name
-        end
+        partial_scope = if object.class.respond_to?(:model_name)
+                          object.class.model_name.name
+                        else
+                          object.class.name
+                        end
 
         underscored_scope = "activerecord.help.#{partial_scope.underscore}"
         downcased_scope = "activerecord.help.#{partial_scope.downcase}"
-        # First check for a subkey :html, as it is also accepted by i18n, and the simple check for name would return an hash instead of a string (both with .presence returning true!)
-        help_text = I18n.t("#{name}.html", scope: underscored_scope, default: '').html_safe.presence
-        help_text ||= if text = I18n.t("#{name}.html", scope: downcased_scope, default: '').html_safe.presence
+        # First check for a subkey :html, as it is also accepted by i18n, and the
+        # simple check for name would return an hash instead of a string (both
+        # with .presence returning true!)
+        help_text = I18n.t("#{name}.html", scope: underscored_scope, default: "").html_safe.presence
+        help_text ||= if (text = I18n.t("#{name}.html", scope: downcased_scope, default: "").html_safe.presence)
                         warn "I18n key '#{downcased_scope}.#{name}' is deprecated, use '#{underscored_scope}.#{name}' instead"
                         text
                       end
-        help_text ||= I18n.t(name, scope: underscored_scope, default: '').presence
-        help_text ||= if text = I18n.t(name, scope: downcased_scope, default: '').presence
+        help_text ||= I18n.t(name, scope: underscored_scope, default: "").presence
+        help_text ||= if (text = I18n.t(name, scope: downcased_scope, default: "").presence)
                         warn "I18n key '#{downcased_scope}.#{name}' is deprecated, use '#{underscored_scope}.#{name}' instead"
                         text
                       end
-        help_text ||= I18n.t("#{name}_html", scope: underscored_scope, default: '').html_safe.presence
-        help_text ||= if text = I18n.t("#{name}_html", scope: downcased_scope, default: '').html_safe.presence
+        help_text ||= I18n.t("#{name}_html", scope: underscored_scope, default: "").html_safe.presence
+        help_text ||= if (text = I18n.t("#{name}_html", scope: downcased_scope, default: "").html_safe.presence)
                         warn "I18n key '#{downcased_scope}.#{name}' is deprecated, use '#{underscored_scope}.#{name}' instead"
                         text
                       end