bootstrap_form 4.1.0 → 4.2.0

data/lib/bootstrap_form/form_group.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module BootstrapForm
+  module FormGroup
+    extend ActiveSupport::Concern
+
+    def form_group(*args, &block)
+      options = args.extract_options!
+      name = args.first
+
+      options[:class] = form_group_classes(options)
+
+      content_tag(:div, options.except(:append, :id, :label, :help, :icon,
+                                       :input_group_class, :label_col, :control_col,
+                                       :add_control_col_class, :layout, :prepend)) do
+        form_group_content(
+          generate_label(options[:id], name, options[:label], options[:label_col], options[:layout]),
+          generate_help(name, options[:help]), options, &block
+        )
+      end
+    end
+
+    private
+
+    def form_group_content_tag(name, field_name, without_field_name, options, html_options)
+      html_class = control_specific_class(field_name)
+      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_field_name, name, options, html_options)
+        end
+      end
+    end
+
+    def form_group_content(label, help_text, options, &block)
+      if group_layout_horizontal?(options[:layout])
+        concat(label).concat(content_tag(:div, capture(&block) + help_text, class: form_group_control_class(options)))
+      else
+        concat(label)
+        concat(capture(&block))
+        concat(help_text) if help_text
+      end
+    end
+
+    def form_group_control_class(options)
+      classes = [options[:control_col] || control_col]
+      classes << options[:add_control_col_class] if options[:add_control_col_class]
+      classes << offset_col(options[:label_col] || @label_col) unless options[:label]
+      classes.flatten.compact
+    end
+
+    def form_group_classes(options)
+      classes = ["form-group", options[:class].try(:split)].flatten.compact
+      classes << "row" if group_layout_horizontal?(options[:layout]) && classes.exclude?("form-row")
+      classes << "form-inline" if field_inline_override?(options[:layout])
+      classes << feedback_class if options[:icon]
+      classes
+    end
+
+    def group_layout_horizontal?(layout)
+      get_group_layout(layout) == :horizontal
+    end
+  end
+end

data/lib/bootstrap_form/form_group_builder.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module BootstrapForm
+  module FormGroupBuilder
+    extend ActiveSupport::Concern
+
+    private
+
+    def form_group_builder(method, options, html_options=nil)
+      no_wrapper = options[:wrapper] == false
+
+      options = form_group_builder_options(options, method)
+
+      form_group_options = form_group_opts(options, form_group_css_options(method, html_options.try(:symbolize_keys!), options))
+
+      options.except!(
+        :help, :icon, :label_col, :control_col, :add_control_col_class, :layout, :skip_label, :label, :label_class,
+        :hide_label, :skip_required, :label_as_placeholder, :wrapper_class, :wrapper
+      )
+
+      if no_wrapper
+        yield
+      else
+        form_group(method, form_group_options) { yield }
+      end
+    end
+
+    def form_group_builder_options(options, method)
+      options.symbolize_keys!
+      options = convert_form_tag_options(method, options) if acts_like_form_tag
+      unless options[:skip_label]
+        options[:required] = form_group_required(options) if options.key?(:skip_required)
+      end
+      options
+    end
+
+    def convert_form_tag_options(method, options={})
+      unless @options[:skip_default_ids]
+        options[:name] ||= method
+        options[:id] ||= method
+      end
+      options
+    end
+
+    def form_group_opts(options, css_options)
+      wrapper_options = options[:wrapper]
+      form_group_options = {
+        id: options[:id], help: options[:help], icon: options[:icon],
+        label_col: options[:label_col], control_col: options[:control_col],
+        add_control_col_class: options[:add_control_col_class],
+        layout: get_group_layout(options[:layout]), class: options[:wrapper_class]
+      }
+
+      form_group_options.merge!(wrapper_options) if wrapper_options.is_a?(Hash)
+      form_group_options[:label] = form_group_label(options, css_options) unless options[:skip_label]
+      form_group_options
+    end
+
+    def form_group_label(options, css_options)
+      hash = {
+        text: form_group_label_text(options[:label]),
+        class: form_group_label_class(options),
+        required: options[:required]
+      }.merge(css_options[:id].present? ? { for: css_options[:id] } : {})
+      hash
+    end
+
+    def form_group_label_text(label)
+      text = label[:text] if label.is_a?(Hash)
+      text ||= label if label.is_a?(String)
+      text
+    end
+
+    def form_group_label_class(options)
+      return hide_class if options[:hide_label] || options[:label_as_placeholder]
+
+      classes = options[:label][:class] if options[:label].is_a?(Hash)
+      classes ||= options[:label_class]
+      classes
+    end
+
+    def form_group_required(options)
+      return unless options.key?(:skip_required)
+
+      warn "`:skip_required` is deprecated, use `:required: false` instead"
+      options[:skip_required] ? false : :default
+    end
+
+    def form_group_css_options(method, html_options, options)
+      css_options = html_options || options
+      # Add control_class; allow it to be overridden by :control_class option
+      control_classes = css_options.delete(:control_class) { control_class }
+      css_options[:class] = [control_classes, css_options[:class]].compact.join(" ")
+      css_options[:class] << " is-invalid" if error?(method)
+      css_options[:placeholder] = form_group_placeholder(options, method) if options[:label_as_placeholder]
+      css_options
+    end
+
+    def form_group_placeholder(options, method)
+      form_group_label_text(options[:label]) || object.class.human_attribute_name(method)
+    end
+  end
+end

data/lib/bootstrap_form/helpers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module BootstrapForm
+  module Helpers
+    extend ActiveSupport::Autoload
+
+    autoload :Bootstrap
+  end
+end

data/lib/bootstrap_form/helpers/bootstrap.rb

@@ -24,35 +24,34 @@ module BootstrapForm
 
       def alert_message(title, options={})
         css = options[:class] || "alert alert-danger"
+        return unless object.respond_to?(:errors) && object.errors.full_messages.any?
 
-        if object.respond_to?(:errors) && object.errors.full_messages.any?
-          content_tag :div, class: css do
-            concat content_tag :p, title
-            concat error_summary unless options[:error_summary] == false
-          end
+        content_tag :div, class: css do
+          concat content_tag :p, title
+          concat error_summary unless options[:error_summary] == false
         end
       end
 
       def error_summary
-        if object.errors.any?
-          content_tag :ul, class: "rails-bootstrap-forms-error-summary" do
-            object.errors.full_messages.each do |error|
-              concat content_tag(:li, error)
-            end
+        return unless object.errors.any?
+
+        content_tag :ul, class: "rails-bootstrap-forms-error-summary" do
+          object.errors.full_messages.each do |error|
+            concat content_tag(:li, error)
           end
         end
       end
 
       def errors_on(name, options={})
-        if has_error?(name)
-          hide_attribute_name = options[:hide_attribute_name] || false
-
-          content_tag :div, class: "alert alert-danger" do
-            if hide_attribute_name
-              object.errors[name].join(", ")
-            else
-              object.errors.full_messages_for(name).join(", ")
-            end
+        return unless error?(name)
+
+        hide_attribute_name = options[:hide_attribute_name] || false
+
+        content_tag :div, class: "alert alert-danger" do
+          if hide_attribute_name
+            object.errors[name].join(", ")
+          else
+            object.errors.full_messages_for(name).join(", ")
           end
         end
       end
@@ -63,7 +62,7 @@ module BootstrapForm
 
         static_options = options.merge(
           readonly: true,
-          control_class: [options[:control_class], static_class].compact.join(" ")
+          control_class: [options[:control_class], static_class].compact
         )
 
         static_options[:value] = object.send(name) unless static_options.key?(:value)
@@ -80,14 +79,13 @@ module BootstrapForm
 
       def prepend_and_append_input(name, options, &block)
         options = options.extract!(:prepend, :append, :input_group_class)
-        input_group_class = ["input-group", options[:input_group_class]].compact.join(" ")
 
-        input = capture(&block) || "".html_safe
+        input = capture(&block) || ActiveSupport::SafeBuffer.new
 
-        input = content_tag(:div, input_group_content(options[:prepend]), class: "input-group-prepend") + input if options[:prepend]
-        input << content_tag(:div, input_group_content(options[:append]), class: "input-group-append") if options[:append]
-        input << generate_error(name)
-        input = content_tag(:div, input, class: input_group_class) unless options.empty?
+        input = prepend_input(options) + input + append_input(options)
+        input += generate_error(name)
+        options.present? &&
+          input = content_tag(:div, input, class: ["input-group", options[:input_group_class]].compact)
         input
       end
 
@@ -108,13 +106,23 @@ module BootstrapForm
 
       private
 
+      def append_input(options)
+        html = content_tag(:div, input_group_content(options[:append]), class: "input-group-append") if options[:append]
+        html || ActiveSupport::SafeBuffer.new
+      end
+
+      def prepend_input(options)
+        html = content_tag(:div, input_group_content(options[:prepend]), class: "input-group-prepend") if options[:prepend]
+        html || ActiveSupport::SafeBuffer.new
+      end
+
       def setup_css_class(the_class, options={})
-        unless options.key? :class
-          if (extra_class = options.delete(:extra_class))
-            the_class = "#{the_class} #{extra_class}"
-          end
-          options[:class] = the_class
+        return if options.key? :class
+
+        if (extra_class = options.delete(:extra_class))
+          the_class = "#{the_class} #{extra_class}"
         end
+        options[:class] = the_class
       end
     end
   end

data/lib/bootstrap_form/inputs.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module BootstrapForm
+  module Inputs
+    extend ActiveSupport::Autoload
+
+    autoload :Base
+    autoload :InputsCollection
+    autoload :CheckBox
+    autoload :CollectionCheckBoxes
+    autoload :CollectionRadioButtons
+    autoload :CollectionSelect
+    autoload :ColorField
+    autoload :DateField
+    autoload :DateSelect
+    autoload :DatetimeField
+    autoload :DatetimeLocalField
+    autoload :DatetimeSelect
+    autoload :EmailField
+    autoload :FileField
+    autoload :GroupedCollectionSelect
+    autoload :MonthField
+    autoload :NumberField
+    autoload :PasswordField
+    autoload :PhoneField
+    autoload :RadioButton
+    autoload :RangeField
+    autoload :RichTextArea if Rails::VERSION::MAJOR >= 6
+    autoload :SearchField
+    autoload :Select
+    autoload :TelephoneField
+    autoload :TextArea
+    autoload :TextField
+    autoload :TimeField
+    autoload :TimeSelect
+    autoload :TimeZoneSelect
+    autoload :UrlField
+    autoload :WeekField
+  end
+end

data/lib/bootstrap_form/inputs/base.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module BootstrapForm
+  module Inputs
+    module Base
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def bootstrap_field(field_name)
+          define_method "#{field_name}_with_bootstrap" do |name, options={}|
+            form_group_builder(name, options) do
+              prepend_and_append_input(name, options) do
+                send("#{field_name}_without_bootstrap".to_sym, name, options)
+              end
+            end
+          end
+
+          bootstrap_alias field_name
+        end
+
+        def bootstrap_select_group(field_name)
+          with_field_name = "#{field_name}_with_bootstrap"
+          without_field_name = "#{field_name}_without_bootstrap"
+          define_method(with_field_name) do |name, options={}, html_options={}|
+            form_group_builder(name, options, html_options) do
+              form_group_content_tag(name, field_name, without_field_name, options, html_options)
+            end
+          end
+
+          bootstrap_alias field_name
+        end
+
+        def bootstrap_alias(field_name)
+          alias_method "#{field_name}_without_bootstrap".to_sym, field_name
+          alias_method field_name, "#{field_name}_with_bootstrap".to_sym
+        end
+      end
+    end
+  end
+end

data/lib/bootstrap_form/inputs/check_box.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module BootstrapForm
+  module Inputs
+    module CheckBox
+      extend ActiveSupport::Concern
+      include Base
+
+      included do
+        def check_box_with_bootstrap(name, options={}, checked_value="1", unchecked_value="0", &block)
+          options = options.symbolize_keys!
+          check_box_options = options.except(:class, :label, :label_class, :error_message, :help,
+                                             :inline, :custom, :hide_label, :skip_label, :wrapper_class)
+          check_box_options[:class] = check_box_classes(name, options)
+
+          content_tag(:div, class: check_box_wrapper_class(options)) do
+            html = check_box_without_bootstrap(name, check_box_options, checked_value, unchecked_value)
+            html.concat(check_box_label(name, options, checked_value, &block)) unless options[:skip_label]
+            html.concat(generate_error(name)) if options[:error_message]
+            html
+          end
+        end
+
+        bootstrap_alias :check_box
+      end
+
+      private
+
+      def check_box_label(name, options, checked_value, &block)
+        label_name = if options[:multiple]
+                       check_box_value(name, checked_value)
+                     else
+                       name
+                     end
+        label_options = { class: check_box_label_class(options) }
+        label_options[:for] = options[:id] if options[:id].present?
+        label(label_name, check_box_description(name, options, &block), label_options)
+      end
+
+      def check_box_description(name, options, &block)
+        content = block_given? ? capture(&block) : options[:label]
+        content || (object && object.class.human_attribute_name(name)) || name.to_s.humanize
+      end
+
+      def check_box_value(name, value)
+        # label's `for` attribute needs to match checkbox tag's id,
+        # IE sanitized value, IE
+        # https://github.com/rails/rails/blob/5-0-stable/actionview/lib/action_view/helpers/tags/base.rb#L123-L125
+        "#{name}_#{value.to_s.gsub(/\s/, '_').gsub(/[^-[[:word:]]]/, '').mb_chars.downcase}"
+      end
+
+      def check_box_classes(name, options)
+        classes = [options[:class]]
+        classes << (options[:custom] ? "custom-control-input" : "form-check-input")
+        classes << "is-invalid" if error?(name)
+        classes << "position-static" if options[:skip_label] || options[:hide_label]
+        classes.flatten.compact
+      end
+
+      def check_box_label_class(options)
+        classes = []
+        classes << (options[:custom] ? "custom-control-label" : "form-check-label")
+        classes << options[:label_class]
+        classes << hide_class if options[:hide_label]
+        classes.flatten.compact
+      end
+
+      def check_box_wrapper_class(options)
+        classes = []
+        if options[:custom]
+          classes << custom_check_box_wrapper_class(options)
+        else
+          classes << "form-check"
+          classes << "form-check-inline" if layout_inline?(options[:inline])
+        end
+        classes << options[:wrapper_class] if options[:wrapper_class].present?
+        classes.flatten.compact
+      end
+
+      def custom_check_box_wrapper_class(options)
+        classes = []
+        classes << "custom-control"
+        classes << (options[:custom] == :switch ? "custom-switch" : "custom-checkbox")
+        classes << "custom-control-inline" if layout_inline?(options[:inline])
+        classes
+      end
+    end
+  end
+end