comfy_bootstrap_form 4.0.0.beta2 → 4.0.0

data/lib/bootstrap_form/bootstrap_options.rb

@@ -0,0 +1,115 @@
+module BootstrapForm
+  # Container for bootstrap specific form builder options. It controls options
+  # that define form layout and grid sizing. They are passed-in into form helper
+  # and field helpers via `:bootstrap` option. For example:
+  #
+  #   bootstrap_form_with scope: :login, url: "/login", bootstrap: {layout: :inline} do |f|
+  #      f.text_field :username, bootstrap: {label: {text: "Your username"}}
+  #   end
+  #
+  class BootstrapOptions
+
+    # Controls form layout. Can be: "vertical" (default), "horizontal" or "inline"
+    attr_reader :layout
+
+    # CSS class for label column when using horizontal form. Default: "col-sm-2"
+    attr_reader :label_col_class
+
+    # CSS class for control column when using horizontal form. Default: "col-sm-10"
+    attr_reader :control_col_class
+
+    # CSS class for label alignment in horizontal form. Default: "text-sm-right"
+    attr_reader :label_align_class
+
+    # CSS class used to space out form groups for inline forms. Default: "mr-sm-2"
+    attr_reader :inline_margin_class
+
+    # Label specific options. Default is and empty hash. Options are as follows:
+    #   text:   "Label Text"  - override automatically generated label text
+    #   hide:   true          - label only visible to screen readers
+    #   class:  "custom"      - append custom CSS class
+    # Example:
+    #
+    #   form.label :username, bootstrap: {label: {text: "Name", class: "important"}}
+    #
+    attr_reader :label
+
+    # Input groups allow prepending and appending arbitrary html. By default
+    # these are nil. Example usage:
+    #
+    #   form.text_field :dollars, bootstrap: {prepend: "$", append: ".00"}
+    #
+    # For non-text values, use hash like so:
+    #
+    #   form.text_field :search, bootstrap: {append: {html: "<button>Go</button>".html_safe}}
+    #
+    attr_reader :prepend
+    attr_reader :append
+
+    # Help text that goes under the form field. Example usage:
+    #
+    #   form.password_field :password, bootstrap: {help: "Password should be more than 8 characters in length"}
+    #
+    attr_reader :help
+
+    # Options to render checkboxes and radio buttons inline. Default is false. Example:
+    #
+    #   form.collection_radio_buttons :choices, ["yes", "no"], :to_s, :to_s, bootstrap: {check_inline: true}
+    #
+    attr_reader :check_inline
+
+    def initialize(options = {})
+      set_defaults
+      set_options(options)
+    end
+
+    def horizontal?
+      @layout.to_s == "horizontal"
+    end
+
+    def inline?
+      @layout.to_s == "inline"
+    end
+
+    def offset_col_class
+      label_col_class.sub(%r{\Acol-(\w+)-(\d+)\z}, 'offset-\1-\2')
+    end
+
+    # This will return a copy of BootstrapOptions object with new options set
+    # that don't affect original object. This way we can have options specific
+    # to a given form field. For example, we can change grid just for one field:
+    #
+    #   bootstrap_form_with scope: :login do |f|
+    #     f.text_field :email, bootstrap: {label_col_class: "col-md-6", control_col_class: "col-md-6"}
+    #     f.password_field :password
+    #   end
+    #
+    def scoped(options = {})
+      scope = clone
+      scope.set_options(options)
+      scope
+    end
+
+    def set_options(options = {})
+      options.is_a?(Hash) && options.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
+  private
+
+    def set_defaults
+      @layout               = "vertical"
+      @label_col_class      = "col-sm-2"
+      @control_col_class    = "col-sm-10"
+      @label_align_class    = "text-sm-right"
+      @inline_margin_class  = "mr-sm-2"
+      @label                = {}
+      @append               = nil
+      @prepend              = nil
+      @help                 = nil
+      @check_inline         = false
+    end
+
+  end
+end

data/lib/bootstrap_form/form_builder.rb

@@ -1,59 +1,37 @@
+require_relative "bootstrap_options"
+
 module BootstrapForm
   class FormBuilder < ActionView::Helpers::FormBuilder
 
     FIELD_HELPERS = %w[
-      color_field     file_field      phone_field   text_field
-      date_field      month_field     range_field   time_field
-      datetime_field  number_field    search_field  url_field
-      email_field     password_field  text_area     week_field
+      color_field date_field datetime_field email_field file_field month_field
+      number_field password_field phone_field range_field search_field text_area
+      text_field time_field url_field week_field
     ].freeze
 
-    # Container for bootstrap specific form builder options. It controls options
-    # that define form layout and grid sizing.
-    class BootstrapOptions
-
-      attr_reader :layout,
-                  :label_col_class,
-                  :control_col_class,
-                  :label_align_class,
-                  :inline_margin_class
-
-      def initialize(options = {})
-        @layout               = options[:layout]              || "default"
-        @label_col_class      = options[:label_col_class]     || "col-sm-2"
-        @control_col_class    = options[:control_col_class]   || "col-sm-10"
-        @label_align_class    = options[:label_align_class]   || "text-sm-right"
-        @inline_margin_class  = options[:inline_margin_class] || "mr-sm-2"
-      end
-
-      def horizontal?
-        @layout.to_s == "horizontal"
-      end
-
-      def inline?
-        @layout.to_s == "inline"
-      end
-
-      def offset_col_class
-        label_col_class.sub(/\Acol-(\w+)-(\d+)\z/, 'offset-\1-\2')
-      end
-
-    end
-
     delegate :content_tag, :capture, :concat, to: :@template
 
-    attr_accessor :bootstrap
+    # Bootstrap settings set on the form itself
+    attr_accessor :form_bootstrap
 
     def initialize(object_name, object, template, options)
-      @bootstrap = BootstrapOptions.new(options.delete(:bootstrap) || {})
+      @form_bootstrap = BootstrapForm::BootstrapOptions.new(options.delete(:bootstrap))
       super(object_name, object, template, options)
     end
 
-    # Overriding default methods to forward everything to field_helper
+    # Wrapper for all field helpers. Example usage:
+    #
+    #   bootstrap_form_with model: @user do |form|
+    #     form.text_field :name
+    #   end
+    #
+    # Output of the `text_field` will be wrapped in Bootstrap markup
+    #
     FIELD_HELPERS.each do |field_helper|
       class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
         def #{field_helper}(method, options = {})
-          field_helper(method, options) do
+          bootstrap = form_bootstrap.scoped(options.delete(:bootstrap))
+          draw_form_group(bootstrap, method, options) do
             super(method, options)
           end
         end
@@ -65,8 +43,8 @@ module BootstrapForm
     #   select :choices, ["a", "b"], {}, bootstrap: {label: {text: "Custom"}}
     #
     def select(method, choices = nil, options = {}, html_options = {}, &block)
-      bootstrap_options = (html_options.delete(:bootstrap) || {})
-      draw_form_group(bootstrap_options, method, html_options) do
+      bootstrap = form_bootstrap.scoped(options.delete(:bootstrap))
+      draw_form_group(bootstrap, method, html_options) do
         super(method, choices, options, html_options, &block)
       end
     end
@@ -76,17 +54,16 @@ module BootstrapForm
     #   checkbox :agree, bootstrap: {label: {text: "Do you agree?"}}
     #
     def check_box(method, options = {}, checked_value = "1", unchecked_value = "0")
-      bootstrap_options       = options.delete(:bootstrap) || {}
-      bootstrap_label_options = bootstrap_options[:label] || {}
+      bootstrap = form_bootstrap.scoped(options.delete(:bootstrap))
 
-      help_text = draw_help(bootstrap_options[:help])
+      help_text = draw_help(bootstrap.help)
       errors    = draw_errors(method)
 
       add_css_class!(options, "form-check-input")
       add_css_class!(options, "is-invalid") if errors.present?
 
       label_text = nil
-      if (custom_text = bootstrap_label_options[:text]).present?
+      if (custom_text = bootstrap.label[:text]).present?
         label_text = custom_text
       end
 
@@ -95,7 +72,7 @@ module BootstrapForm
       fieldset_css_class << " #{bootstrap.inline_margin_class}" if bootstrap.inline?
 
       content_tag(:fieldset, class: fieldset_css_class) do
-        draw_control_column(offset: true) do
+        draw_control_column(bootstrap, offset: true) do
           content_tag(:div, class: "form-check") do
             concat super(method, options, checked_value, unchecked_value)
             concat label(method, label_text, class: "form-check-label")
@@ -118,9 +95,9 @@ module BootstrapForm
     #   label: {hide: true}     - to not render label at all
     #
     def collection_radio_buttons(method, collection, value_method, text_method, options = {}, html_options = {})
-      bootstrap_options = (options.delete(:bootstrap) || {})
+      bootstrap = form_bootstrap.scoped(options.delete(:bootstrap))
 
-      args = [bootstrap_options, method, collection, value_method, text_method, options, html_options]
+      args = [bootstrap, method, collection, value_method, text_method, options, html_options]
       draw_choices(*args) do |m, v, opts|
         radio_button(m, v, opts)
       end
@@ -132,14 +109,14 @@ module BootstrapForm
     #   collection_check_boxes :choices, Choice.all, :id, :label
     #
     def collection_check_boxes(method, collection, value_method, text_method, options = {}, html_options = {})
-      bootstrap_options = (options.delete(:bootstrap) || {})
+      bootstrap = form_bootstrap.scoped(options.delete(:bootstrap))
 
       content = "".html_safe
       unless options[:include_hidden] == false
         content << hidden_field(method, multiple: true, value: "")
       end
 
-      args = [bootstrap_options, method, collection, value_method, text_method, options, html_options]
+      args = [bootstrap, method, collection, value_method, text_method, options, html_options]
       content << draw_choices(*args) do |m, v, opts|
         opts[:multiple]       = true
         opts[:include_hidden] = false
@@ -152,8 +129,8 @@ module BootstrapForm
     #   plaintext(:value)
     #
     def plaintext(method, options = {})
-      bootstrap_options = (options.delete(:bootstrap) || {})
-      draw_form_group(bootstrap_options, method, options) do
+      bootstrap = form_bootstrap.scoped(options.delete(:bootstrap))
+      draw_form_group(bootstrap, method, options) do
         remove_css_class!(options, "form-control")
         add_css_class!(options, "form-control-plaintext")
         options[:readonly] = true
@@ -174,14 +151,20 @@ module BootstrapForm
     #   end
     #
     def submit(value = nil, options = {}, &block)
-      value, options = nil, value if value.is_a?(Hash)
+      if value.is_a?(Hash)
+        options = value
+        value   = nil
+      end
+
+      bootstrap = form_bootstrap.scoped(options.delete(:bootstrap))
+
       add_css_class!(options, "btn")
 
       form_group_class = "form-group"
       form_group_class << " row" if bootstrap.horizontal?
 
       content_tag(:div, class: form_group_class) do
-        draw_control_column(offset: true) do
+        draw_control_column(bootstrap, offset: true) do
           out = super(value, options)
           out << capture(&block) if block_given?
           out
@@ -202,27 +185,27 @@ module BootstrapForm
     #     "Some content"
     #   end
     #
-    def form_group(options = {}, &block)
-      bootstrap_options       = options.delete(:bootstrap) || {}
-      bootstrap_label_options = bootstrap_options.delete(:label) || {}
-
-      label_text = bootstrap_label_options[:text]
-
-      label = if label_text.present?
-        label_options = {}
-        add_css_class!(label_options, bootstrap_label_options[:class])
+    def form_group(options = {})
+      bootstrap = form_bootstrap.scoped(options.delete(:bootstrap))
+
+      label_text = bootstrap.label[:text]
+
+      label =
+        if label_text.present?
+          label_options = {}
+          add_css_class!(label_options, bootstrap.label[:class])
+
+          if bootstrap.horizontal?
+            add_css_class!(label_options, "col-form-label")
+            add_css_class!(label_options, bootstrap.label_col_class)
+            add_css_class!(label_options, bootstrap.label_align_class)
+          elsif bootstrap.inline?
+            add_css_class!(label_options, bootstrap.inline_margin_class)
+          end
 
-        if bootstrap.horizontal?
-          add_css_class!(label_options, "col-form-label")
-          add_css_class!(label_options, bootstrap.label_col_class)
-          add_css_class!(label_options, bootstrap.label_align_class)
-        elsif bootstrap.inline?
-          add_css_class!(label_options, bootstrap.inline_margin_class)
+          content_tag(:label, label_text, label_options)
         end
 
-        content_tag(:label, label_text, label_options)
-      end
-
       form_group_class = "form-group"
       form_group_class << " row"      if bootstrap.horizontal?
       form_group_class << " mr-sm-2"  if bootstrap.inline?
@@ -230,7 +213,7 @@ module BootstrapForm
       content_tag(:div, class: form_group_class) do
         content = "".html_safe
         content << label if label.present?
-        content << draw_control_column(offset: label.blank?) do
+        content << draw_control_column(bootstrap, offset: label.blank?) do
           yield
         end
       end
@@ -238,27 +221,12 @@ module BootstrapForm
 
   private
 
-    # Wrapper for all field helpers. Example usage:
-    #
-    #   bootstrap_form_with model: @user do |form|
-    #     form.text_field :name
-    #   end
-    #
-    # Output of the `text_field` will be wrapped in Bootstrap markup
-    #
-    def field_helper(method, options, &block)
-      bootstrap_options = (options.delete(:bootstrap) || {})
-      draw_form_group(bootstrap_options, method, options) do
-        yield
-      end
-    end
-
     # form group wrapper for input fields
-    def draw_form_group(bootstrap_options, method, options, &block)
-      label  = draw_label(bootstrap_options, method)
+    def draw_form_group(bootstrap, method, options)
+      label  = draw_label(bootstrap, method)
       errors = draw_errors(method)
 
-      control = draw_control(bootstrap_options, errors, method, options) do
+      control = draw_control(bootstrap, errors, method, options) do
         yield
       end
 
@@ -290,18 +258,16 @@ module BootstrapForm
     #
     #   text_field(:value, bootstrap: {label: {text: "Custom", class: "custom"}})
     #
-    def draw_label(bootstrap_options, method)
-      bootstrap_label_options = bootstrap_options[:label] || {}
-
+    def draw_label(bootstrap, method)
       text    = nil
       options = {}
 
-      if (custom_text = bootstrap_label_options[:text]).present?
+      if (custom_text = bootstrap.label[:text]).present?
         text = custom_text
       end
 
-      add_css_class!(options, bootstrap_label_options[:class])
-      add_css_class!(options, "sr-only") if bootstrap_label_options[:hide]
+      add_css_class!(options, bootstrap.label[:class])
+      add_css_class!(options, "sr-only") if bootstrap.label[:hide]
       add_css_class!(options, bootstrap.inline_margin_class) if bootstrap.inline?
 
       if bootstrap.horizontal?
@@ -314,16 +280,12 @@ module BootstrapForm
     end
 
     # Renders control for a given field
-    def draw_control(bootstrap_options, errors, method, options, &block)
-      bootstrap_label_options  = bootstrap_options[:label] || {}
-
+    def draw_control(bootstrap, errors, _method, options)
       add_css_class!(options, "form-control")
       add_css_class!(options, "is-invalid") if errors.present?
 
-      offset = !!bootstrap_label_options[:hide]
-
-      draw_control_column(offset: offset) do
-        draw_input_group(bootstrap_options, errors) do
+      draw_control_column(bootstrap, offset: bootstrap.label[:hide]) do
+        draw_input_group(bootstrap, errors) do
           yield
         end
       end
@@ -331,9 +293,9 @@ module BootstrapForm
 
     # Wrapping in control in column wrapper
     #
-    def draw_control_column(offset:, &block)
+    def draw_control_column(bootstrap, offset:)
       return yield unless bootstrap.horizontal?
-      css_class = "#{bootstrap.control_col_class}"
+      css_class = bootstrap.control_col_class.to_s
       css_class << " #{bootstrap.offset_col_class}" if offset
       content_tag(:div, class: css_class) do
         yield
@@ -346,11 +308,11 @@ module BootstrapForm
     #   text_field(:value, bootstrap: {prepend: "$.$$"}})
     #   text_field(:value, bootstrap: {append: {html: "<button>Go</button>"}}})
     #
-    def draw_input_group(bootstrap_options, errors, &block)
-      prepend_html  = draw_input_group_content(bootstrap_options, :prepend)
-      append_html   = draw_input_group_content(bootstrap_options, :append)
+    def draw_input_group(bootstrap, errors, &block)
+      prepend_html  = draw_input_group_content(bootstrap, :prepend)
+      append_html   = draw_input_group_content(bootstrap, :append)
 
-      help_text = draw_help(bootstrap_options[:help])
+      help_text = draw_help(bootstrap.help)
 
       # Not prepending or appending anything. Bail.
       if prepend_html.blank? && append_html.blank?
@@ -360,17 +322,19 @@ module BootstrapForm
         return content
       end
 
-      content_tag(:div, class: "input-group") do
+      content = "".html_safe
+      content << content_tag(:div, class: "input-group") do
         concat prepend_html if prepend_html.present?
         concat capture(&block)
         concat append_html  if append_html.present?
         concat errors       if errors.present?
-        concat help_text    if help_text.present?
       end
+      content << help_text if help_text.present?
+      content
     end
 
-    def draw_input_group_content(bootstrap_options, type)
-      value = bootstrap_options[type]
+    def draw_input_group_content(bootstrap, type)
+      value = bootstrap.send(type)
       return unless value.present?
 
       content_tag(:div, class: "input-group-#{type}") do
@@ -392,16 +356,15 @@ module BootstrapForm
     end
 
     # Rendering of choices for checkboxes and radio buttons
-    def draw_choices(bootstrap_options, method, collection, value_method, text_method, options, html_options, &input)
+    def draw_choices(bootstrap, method, collection, value_method, text_method, _options, html_options)
       add_css_class!(html_options, "form-check-input")
 
-      draw_form_group_fieldset(bootstrap_options, method, html_options) do
-
+      draw_form_group_fieldset(bootstrap, method, html_options) do
         form_check_css_class = "form-check"
-        form_check_css_class << " form-check-inline" if bootstrap_options[:inline]
+        form_check_css_class << " form-check-inline" if bootstrap.check_inline
 
         errors    = draw_errors(method)
-        help_text = draw_help(bootstrap_options[:help])
+        help_text = draw_help(bootstrap.help)
 
         add_css_class!(html_options, "is-invalid") if errors.present?
 
@@ -411,16 +374,16 @@ module BootstrapForm
           item_text   = item.send(text_method)
 
           content << content_tag(:div, class: form_check_css_class) do
-            concat input.call(method, item_value, html_options)
+            concat yield method, item_value, html_options
             concat label(method, item_text, value: item_value, class: "form-check-label")
-            if ((collection.count - 1) == index) && !bootstrap_options[:inline]
+            if ((collection.count - 1) == index) && !bootstrap.check_inline
               concat errors     if errors.present?
               concat help_text  if help_text.present?
             end
           end
         end
 
-        if bootstrap_options[:inline]
+        if bootstrap.check_inline
           content << errors     if errors.present?
           content << help_text  if help_text.present?
         end
@@ -430,22 +393,23 @@ module BootstrapForm
     end
 
     # Wrapper for collections of radio buttons and checkboxes
-    def draw_form_group_fieldset(bootstrap_options, method, options, &block)
-      bootstrap_label_options = bootstrap_options[:label] || {}
+    def draw_form_group_fieldset(bootstrap, method, _html_options)
+      options = {}
 
-      unless bootstrap_label_options[:hide]
-        label_text = bootstrap_label_options.delete(:text)
+      unless bootstrap.label[:hide]
+        label_text = bootstrap.label[:text]
         label_text ||= ActionView::Helpers::Tags::Label::LabelBuilder
           .new(@template, @object_name.to_s, method, @object, nil).translation
 
-        add_css_class!(bootstrap_label_options, "col-form-label pt-0")
+        add_css_class!(options, "col-form-label pt-0")
+        add_css_class!(options, bootstrap.label[:class])
 
         if bootstrap.horizontal?
-          add_css_class!(bootstrap_label_options, bootstrap.label_col_class)
-          add_css_class!(bootstrap_label_options, bootstrap.label_align_class)
+          add_css_class!(options, bootstrap.label_col_class)
+          add_css_class!(options, bootstrap.label_align_class)
         end
 
-        label = content_tag(:legend, bootstrap_label_options) do
+        label = content_tag(:legend, options) do
           label_text
         end
       end
@@ -453,7 +417,7 @@ module BootstrapForm
       content_tag(:fieldset, class: "form-group") do
         content = "".html_safe
         content << label if label.present?
-        content << draw_control_column(offset: bootstrap_label_options[:hide]) do
+        content << draw_control_column(bootstrap, offset: bootstrap.label[:hide]) do
           yield
         end
 
@@ -477,5 +441,4 @@ module BootstrapForm
     end
 
   end
-
 end

data/lib/bootstrap_form/version.rb

@@ -1,3 +1,5 @@
 module BootstrapForm
-  VERSION = "4.0.0.beta2".freeze
+
+  VERSION = "4.0.0".freeze
+
 end

data/lib/bootstrap_form/view_helper.rb

@@ -24,10 +24,11 @@ module BootstrapForm
     # Bootstrap specific markup. So we need to bypass this.
     def supress_field_errors
       original_proc = ActionView::Base.field_error_proc
-      ActionView::Base.field_error_proc = proc { |input, instance| input }
+      ActionView::Base.field_error_proc = proc { |input, _instance| input }
       yield
     ensure
       ActionView::Base.field_error_proc = original_proc
     end
+
   end
 end

data/lib/bootstrap_form.rb

@@ -1,5 +1,5 @@
-require 'bootstrap_form/form_builder'
-require 'bootstrap_form/view_helper'
+require "bootstrap_form/form_builder"
+require "bootstrap_form/view_helper"
 
 module BootstrapForm
   module Rails