rails_bootstrap_form 0.9.7 → 0.9.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ffc0cdcd818f57b7e0b683ec59b2ac3a59b80edab6e40f9eebe1da8d32cd376
-  data.tar.gz: 676be2383b1d1421b70a50ad5dc044eed15dfe4707b26ca345077644de9abebc
+  metadata.gz: 73b8b86f78e40f77d36ba3857ef15c9efe939480d327011ba083132d48668654
+  data.tar.gz: 897ed641bdc6147d29698901a0b9f37ce71a46d0581734a844cf03666fbf5c20
 SHA512:
-  metadata.gz: cdf31544bc3fd0032dff7b12bb95b1af33466d8e5a199ea0ecd263e1a8cdfdc2d00b02cc95425a1e712c6f2edd8ca626cf5e9ca6523fdf7eecf66a5a4776b17e
-  data.tar.gz: 60e72524a66706827e25fd018ffbe4dc75e823d346a86627c525e0e9f095af6a490846dc04526127708f4c30811f59c30c94b32936543055dcc6bf2fd6a3af4f
+  metadata.gz: 0b5ee6a90da2f11246c01c6f41f01d0fe067cd07ba26b56773e50b6c67c3b87e67d8714694c0c11240d31cb8d58255c58610dbf6304cea21fd547abdc718f8db
+  data.tar.gz: 1554395fcabb6df7f38722c5a26eb680b8436c7bd54f9567477db6b302208872d53417abca1d219a89f48c7fcff8ff8b22e9c26aafa194c79bd683eb83a2ed85

data/.codeclimate.yml

@@ -0,0 +1,47 @@
+version: "2"
+checks:
+  argument-count:
+    enabled: true
+    config:
+      threshold: 4
+  complex-logic:
+    enabled: true
+    config:
+      threshold: 4
+  file-lines:
+    enabled: true
+    config:
+      threshold: 250
+  method-complexity:
+    enabled: true
+    config:
+      threshold: 5
+  method-count:
+    enabled: true
+    config:
+      threshold: 20
+  method-lines:
+    enabled: true
+    config:
+      threshold: 25
+  nested-control-flow:
+    enabled: true
+    config:
+      threshold: 4
+  return-statements:
+    enabled: true
+    config:
+      threshold: 4
+exclude_patterns:
+- "config/"
+- "db/"
+- "dist/"
+- "features/"
+- "demo/"
+- "**/node_modules/"
+- "script/"
+- "**/spec/"
+- "**/test/"
+- "**/tests/"
+- "**/vendor/"
+- "**/*.d.ts"

data/CHANGELOG.md

@@ -4,6 +4,12 @@ You can find recent releases with docs in GitHub:
 
 https://github.com/shivam091/rails_bootstrap_form/releases
 
+## [0.9.8](https://github.com/shivam091/rails_bootstrap_form/compare/v0.9.7...v0.9.8) - 2023-07-01
+
+### What's fixed
+
+- Fixed bug causing button helpers not to work with block and options ([#50](https://github.com/shivam091/rails_bootstrap_form/issues/50))
+
 ## [0.9.7](https://github.com/shivam091/rails_bootstrap_form/compare/v0.9.6...v0.9.7) - 2023-06-26
 
 ### What's new

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rails_bootstrap_form (0.9.7)
+    rails_bootstrap_form (0.9.8)
       actionpack (~> 7.0)
       activemodel (~> 7.0)
 

data/README.md

@@ -2,6 +2,9 @@
 
 [![Ruby](https://github.com/shivam091/rails_bootstrap_form/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/shivam091/rails_bootstrap_form/actions/workflows/main.yml)
 [![Gem Version](https://badge.fury.io/rb/rails_bootstrap_form.svg)](https://badge.fury.io/rb/rails_bootstrap_form)
+[![Gem Downloads](https://img.shields.io/gem/dt/rails_bootstrap_form.svg)](http://rubygems.org/gems/rails_bootstrap_form)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/8038de955c10394ae35d/test_coverage)](https://codeclimate.com/github/shivam091/rails_bootstrap_form/test_coverage)
+[![Maintainability](https://api.codeclimate.com/v1/badges/8038de955c10394ae35d/maintainability)](https://codeclimate.com/github/shivam091/rails_bootstrap_form/maintainability)
 
 **rails_bootstrap_form** is a Rails form builder that makes it super easy to integrate [Bootstrap 5](https://getbootstrap.com/) forms into your Rails application.
 `rails_bootstrap_form`'s form helpers generate the form field and its label along with all the Bootstrap mark-up required for proper Bootstrap display.
@@ -28,7 +31,7 @@ for setting up `application.scss` and `application.js`.
 Add the `rails_bootstrap_form` gem to your `Gemfile`:
 
 ```ruby
-gem "rails_bootstrap_form", "~> 0.9.6"
+gem "rails_bootstrap_form", "~> 0.9.8"
 ```
 
 Then:

data/lib/rails_bootstrap_form/bootstrap_form_builder.rb

@@ -13,7 +13,7 @@ module RailsBootstrapForm
     include RailsBootstrapForm::InputGroupBuilder
     include RailsBootstrapForm::Inputs
 
-    delegate :capture, :concat, :tag, to: :@template
+    delegate :capture, :concat, :tag, :button_tag, to: :@template
 
     attr_accessor :bootstrap_form_options
 

data/lib/rails_bootstrap_form/field_wrapper_builder.rb

@@ -4,6 +4,9 @@
 
 module RailsBootstrapForm
   module FieldWrapperBuilder
+
+    private
+
     def field_wrapper_builder(attribute, bootstrap, options, html_options = nil, &block)
       field_options = field_css_options(attribute, bootstrap, options, html_options.try(:symbolize_keys!))
 
@@ -15,37 +18,17 @@ module RailsBootstrapForm
       help_text = help_text(attribute, bootstrap)
       wrapper_content = ActiveSupport::SafeBuffer.new
 
-      if bootstrap.layout_horizontal?
-        wrapper_content << label
-        wrapper_content << tag.div(class: bootstrap.field_col_wrapper_class) do
-          input_group_wrapper(attribute, bootstrap) do
-            capture(&block)
-          end + help_text
-        end
+      wrapper_content = if bootstrap.layout_horizontal?
+        build_horizontal_layout_content(attribute, bootstrap, label, help_text, &block)
       else
         if bootstrap.floating?
-          wrapper_content << input_group_wrapper(attribute, bootstrap) do
-            tag.div(class: floating_label_classes(attribute)) do
-              capture(&block) + label
-            end
-          end
-          wrapper_content << help_text
+          build_floating_layout_content(attribute, bootstrap, label, help_text, &block)
         else
-          wrapper_content << label
-          wrapper_content << input_group_wrapper(attribute, bootstrap) do
-            capture(&block)
-          end
-          wrapper_content << help_text
+          build_default_layout_content(attribute, bootstrap, label, help_text, &block)
         end
       end
 
-      if bootstrap.wrapper
-        tag.div(**field_wrapper_options(bootstrap)) do
-          wrapper_content
-        end
-      else
-        wrapper_content
-      end
+      build_wrapper_element(bootstrap, wrapper_content)
     end
 
     def field_wrapper_options(bootstrap)
@@ -72,18 +55,11 @@ module RailsBootstrapForm
     def field_css_options(attribute, bootstrap, options, html_options)
       css_options = (html_options || options)
 
-      field_classes = Array(bootstrap.field_class) << [bootstrap.additional_field_class || css_options[:class]]
-      field_classes << "is-invalid" if is_invalid?(attribute)
-      if is_size_valid?(bootstrap)
-        field_classes << "#{bootstrap.field_class}-#{bootstrap.size}"
-      end
+      field_classes = build_field_classes(attribute, bootstrap, css_options)
 
       css_options[:class] = field_classes.flatten.compact
       css_options.merge!(required_field_options(attribute, options))
-
-      if placeholder_required?(bootstrap)
-        css_options[:placeholder] ||= label_text(attribute, bootstrap)
-      end
+      add_placeholder_if_required!(css_options, attribute, bootstrap)
 
       css_options
     end
@@ -96,11 +72,63 @@ module RailsBootstrapForm
       classes
     end
 
+    def build_field_classes(attribute, bootstrap, css_options)
+      field_classes = Array(bootstrap.field_class) <<
+      field_classes << [bootstrap.additional_field_class || css_options[:class]]
+      field_classes << "is-invalid" if is_invalid?(attribute)
+      field_classes << "#{bootstrap.field_class}-#{bootstrap.size}" if is_size_valid?(bootstrap)
+      field_classes
+    end
+
     def placeholder_required?(bootstrap)
       (bootstrap.floating? && !bootstrap.layout_horizontal?) || bootstrap.layout_inline?
     end
 
-    private :field_wrapper, :field_wrapper_classes, :field_wrapper_default_class,
-            :field_css_options, :floating_label_classes
+    def add_placeholder_if_required!(css_options, attribute, bootstrap)
+      css_options[:placeholder] ||= label_text(attribute, bootstrap) if placeholder_required?(bootstrap)
+      css_options
+    end
+
+    def build_horizontal_layout_content(attribute, bootstrap, label, help_text, &block)
+      wrapper_content = ActiveSupport::SafeBuffer.new
+      wrapper_content << label
+      wrapper_content << tag.div(class: bootstrap.field_col_wrapper_class) do
+        input_group_wrapper(attribute, bootstrap) do
+          capture(&block)
+        end + help_text
+      end
+      wrapper_content
+    end
+
+    def build_floating_layout_content(attribute, bootstrap, label, help_text, &block)
+      wrapper_content = ActiveSupport::SafeBuffer.new
+      wrapper_content << input_group_wrapper(attribute, bootstrap) do
+        tag.div(class: floating_label_classes(attribute)) do
+          capture(&block) + label
+        end
+      end
+      wrapper_content << help_text
+      wrapper_content
+    end
+
+    def build_default_layout_content(attribute, bootstrap, label, help_text, &block)
+      wrapper_content = ActiveSupport::SafeBuffer.new
+      wrapper_content << label
+      wrapper_content << input_group_wrapper(attribute, bootstrap) do
+        capture(&block)
+      end
+      wrapper_content << help_text
+      wrapper_content
+    end
+
+    def build_wrapper_element(bootstrap, wrapper_content)
+      if bootstrap.wrapper
+        tag.div(**field_wrapper_options(bootstrap)) do
+          wrapper_content
+        end
+      else
+        wrapper_content
+      end
+    end
   end
 end

data/lib/rails_bootstrap_form/helpers/buttons.rb

@@ -7,37 +7,67 @@ module RailsBootstrapForm
     module Buttons
       extend ActiveSupport::Concern
 
-      def self.included(base_class)
-        def render_button(value = nil, options = {}, &block)
-          value, options = nil, value if value.is_a?(Hash)
+      included do
+        def button(value, options, &block)
           bootstrap = bootstrap_form_options.scoped(options.delete(:bootstrap))
+          value, options = extract_button_value_and_options(value, options)
 
-          button_html = if (bootstrap.render_as_button? || block)
-            button(value, options, &block)
-          else
-            submit(value, options)
-          end
-
-          if bootstrap.layout_inline?
-            tag.div(class: "col-12") { button_html }
-          else
-            button_html
-          end
+          add_button_css_classes!(options, bootstrap)
+
+          button_html = render_button_html(value, options, bootstrap, &block)
+          button_html = wrap_button_html(button_html, bootstrap)
+
+          button_html
         end
 
         def secondary(value = nil, options = {}, &block)
-          add_css_class!(options, "btn btn-secondary")
-          render_button(value, options, &block)
+          button(value, options.merge!(variant: "secondary"), &block)
         end
 
         def primary(value = nil, options = {}, &block)
-          add_css_class!(options, "btn btn-primary")
-          render_button(value, options, &block)
+          button(value, options.merge!(variant: "primary"), &block)
         end
 
         def danger(value = nil, options = {}, &block)
-          add_css_class!(options, "btn btn-danger")
-          render_button(value, options, &block)
+          button(value, options.merge!(variant: "danger"), &block)
+        end
+      end
+
+      private
+
+      def button_variant_class(options)
+        case options.delete(:variant)
+        when "secondary" then "btn-secondary"
+        when "primary" then "btn-primary"
+        when "danger" then "btn-danger"
+        else ""
+        end
+      end
+
+      def extract_button_value_and_options(value, options)
+        return [nil, value.merge(options)] if value.is_a?(Hash)
+
+        [value, options]
+      end
+
+      def add_button_css_classes!(options, bootstrap)
+        add_css_class!(options, "btn")
+        add_css_class!(options, button_variant_class(options))
+      end
+
+      def render_button_html(value, options, bootstrap, &block)
+        if bootstrap.render_as_button? || block
+          button_tag(value, options, &block)
+        else
+          submit(value, options)
+        end
+      end
+
+      def wrap_button_html(button_html, bootstrap)
+        if bootstrap.layout_inline?
+          tag.div(class: "col-12") { button_html }
+        else
+          button_html
         end
       end
     end

data/lib/rails_bootstrap_form/helpers/choice.rb

@@ -7,76 +7,92 @@ module RailsBootstrapForm
     module Choice
       extend ActiveSupport::Concern
 
-      def self.included(base_class)
-        [:check_box, :radio_button].each do |tag_name|
-          define_method("#{tag_name}_label") do |attribute, value, options, bootstrap|
-            unless bootstrap.skip_label?
-              label_options = {
-                class: choice_label_classes(attribute, bootstrap, options)
-              }
-              label_options[:value] = value if tag_name.eql?(:radio_button)
-              label_options[:for] = options[:id] if options[:id].present?
+      private
 
-              label_text = label_text(attribute, bootstrap)
+      [:check_box, :radio_button].each do |tag_name|
+        define_method("#{tag_name}_label") do |attribute, value, options, bootstrap|
+          unless bootstrap.skip_label?
+            label_options = {
+              class: choice_label_classes(attribute, bootstrap, options)
+            }
+            label_options[:value] = value if tag_name.eql?(:radio_button)
+            label_options[:for] = options[:id] if options[:id].present?
 
-              label(attribute, label_text, label_options)
-            end
+            label_text = label_text(attribute, bootstrap)
+
+            label(attribute, label_text, label_options)
           end
         end
+      end
 
-        [:check_box, :radio_button].each do |tag_name|
-          define_method("bootstrap_#{tag_name}") do |attribute, value, options, bootstrap|
-            options[:class] = choice_classes(attribute, bootstrap, options)
-
-            if tag_name.eql?(:check_box)
-              choice_field = check_box_without_bootstrap(attribute, options, value, nil)
-              choice_label = check_box_label(attribute, value, options, bootstrap)
-            else
-              choice_field = radio_button_without_bootstrap(attribute, value, options)
-              choice_label = radio_button_label(attribute, value, options, bootstrap)
-            end
+      [:check_box, :radio_button].each do |tag_name|
+        define_method("bootstrap_#{tag_name}") do |attribute, value, options, bootstrap|
+          options[:class] = choice_classes(attribute, bootstrap, options)
 
-            choice_field + choice_label
+          if tag_name.eql?(:check_box)
+            choice_field = check_box_without_bootstrap(attribute, options, value, nil)
+            choice_label = check_box_label(attribute, value, options, bootstrap)
+          else
+            choice_field = radio_button_without_bootstrap(attribute, value, options)
+            choice_label = radio_button_label(attribute, value, options, bootstrap)
           end
-        end
 
-        def choice_classes(attribute, bootstrap, options)
-          classes = Array("form-check-input") << [bootstrap.additional_field_class || options[:class]]
-          classes << "is-invalid" if is_invalid?(attribute)
-          classes.flatten.compact
+          choice_field + choice_label
         end
+      end
 
-        def choice_label_classes(attribute, bootstrap, options)
-          classes = Array("form-check-label") << bootstrap.additional_label_class
-          classes << "required" if is_field_required?(attribute, options)
-          classes << "is-invalid" if is_invalid?(attribute)
-          classes << bootstrap.hide_class if bootstrap.hide_label?
-          classes.flatten.compact
+      [:check_box, :radio_button].each do |tag_name|
+        define_method("build_#{tag_name}_html") do |attribute, value, bootstrap, options|
+          tag.div(class: choice_wrapper_classes(bootstrap)) do
+            concat(send("bootstrap_#{tag_name}", attribute, value, options, bootstrap))
+            concat(help_text(attribute, bootstrap))
+            concat(generate_error(attribute)) if is_invalid?(attribute)
+          end
         end
+      end
 
-        def choice_container_classes(bootstrap)
-          classes = Array(bootstrap.field_col_wrapper_class)
-          classes << field_offset_class(bootstrap.label_col_wrapper_class)
-          classes.flatten.compact
+      [:check_box, :radio_button].each do |tag_name|
+        define_method("build_wrapped_#{tag_name}_html") do |bootstrap, tag_html|
+          tag.div(**field_wrapper_options(bootstrap)) do
+            if bootstrap.layout_horizontal?
+              tag.div(class: choice_container_classes(bootstrap)) { tag_html }
+            else
+              tag_html
+            end
+          end
         end
+      end
 
-        def choice_wrapper_classes(bootstrap)
-          classes = Array("form-check")
-          classes << "form-check-inline" if bootstrap.inline?
-          classes << "form-switch" if bootstrap.switch?
-          classes.flatten.compact
-        end
+      def choice_classes(attribute, bootstrap, options)
+        classes = Array("form-check-input") << [bootstrap.additional_field_class || options[:class]]
+        classes << "is-invalid" if is_invalid?(attribute)
+        classes.flatten.compact
+      end
 
-        def collection_input_checked?(checked, obj, input_value)
-          checked == input_value || Array(checked).try(:include?, input_value) ||
-            checked == obj || Array(checked).try(:include?, obj)
-        end
+      def choice_label_classes(attribute, bootstrap, options)
+        classes = Array("form-check-label") << bootstrap.additional_label_class
+        classes << "required" if is_field_required?(attribute, options)
+        classes << "is-invalid" if is_invalid?(attribute)
+        classes << bootstrap.hide_class if bootstrap.hide_label?
+        classes.flatten.compact
+      end
+
+      def choice_container_classes(bootstrap)
+        classes = Array(bootstrap.field_col_wrapper_class)
+        classes << field_offset_class(bootstrap.label_col_wrapper_class)
+        classes.flatten.compact
+      end
+
+      def choice_wrapper_classes(bootstrap)
+        classes = Array("form-check")
+        classes << "form-check-inline" if bootstrap.inline?
+        classes << "form-switch" if bootstrap.switch?
+        classes.flatten.compact
+      end
 
-        private :choice_classes, :choice_label_classes,
-                :choice_container_classes, :choice_wrapper_classes,
-                :check_box_label, :radio_button_label,
-                :bootstrap_check_box, :bootstrap_radio_button,
-                :collection_input_checked?
+      def collection_input_checked?(checked, obj, input_value)
+        checked == input_value || Array(checked).try(:include?, input_value) ||
+          checked == obj || Array(checked).try(:include?, obj)
       end
     end
   end

data/lib/rails_bootstrap_form/helpers/errors.rb

@@ -7,59 +7,69 @@ module RailsBootstrapForm
     module Errors
       extend ActiveSupport::Concern
 
-      def self.included(base_class)
-        def is_invalid?(attribute)
-          (attribute && object.respond_to?(:errors) && object.errors[attribute].any?) ||
-            has_association_error?(attribute)
-        end
+      private
 
-        # def input_with_error(attribute, &block)
-        #   input = capture(&block)
-        #   input << generate_error(attribute)
-        #   input
-        # end
+      def is_invalid?(attribute)
+        (attribute && object.respond_to?(:errors) && has_attribute_error?(attribute)) ||
+          has_association_error?(attribute)
+      end
 
-        def generate_error(attribute)
-          if is_invalid?(attribute)
-            error_text = error_messages(attribute)
-            error_klass = "invalid-feedback"
+      def generate_error(attribute)
+        if is_invalid?(attribute)
+          error_text = error_messages(attribute)
+          error_klass = "invalid-feedback"
 
-            tag.div(error_text, class: error_klass)
-          end
+          tag.div(error_text, class: error_klass)
         end
+      end
+
+      def error_messages(attribute)
+        messages = Array(attribute_error_messages(attribute))
+        messages << associated_error_messages(attribute)
 
-        def has_association_error?(attribute)
-          object.class.try(:reflections)&.any? do |association_name, association|
-            next unless is_belongs_to_association?(association)
-            next unless is_association_same?(attribute, association)
+        messages.flatten.to_sentence
+      end
+
+      def has_attribute_error?(attribute)
+        attribute_error_messages(attribute).any?
+      end
 
-            object.errors[association_name].any?
-          end
+      def has_association_error?(attribute)
+        object.class.try(:reflections)&.any? do |association_name, association|
+          has_errors_on_association?(attribute, association_name)
         end
+      end
 
-        def error_messages(attribute)
-          messages = object.errors[attribute]
+      def has_errors_on_association?(attribute, association_name)
+        return false unless is_belongs_to_association?(object.class.reflections[association_name])
+        return false unless is_association_same?(attribute, object.class.reflections[association_name])
 
-          object.class.try(:reflections)&.each do |association_name, association|
-            next unless is_belongs_to_association?(association)
-            next unless is_association_same?(attribute, association)
+        object.errors[association_name].any?
+      end
 
-            messages << object.errors[association_name]
-          end
+      def attribute_error_messages(attribute)
+        object.errors[attribute]
+      end
 
-          messages.flatten.to_sentence
-        end
+      def associated_error_messages(attribute)
+        error_messages = []
 
-        def is_belongs_to_association?(association)
-          association.is_a?(ActiveRecord::Reflection::BelongsToReflection)
-        end
+        object.class.try(:reflections)&.each do |association_name, association|
+          next unless is_belongs_to_association?(association)
+          next unless is_association_same?(attribute, association)
 
-        def is_association_same?(attribute, association)
-          (association.foreign_key == attribute.to_s)
+          error_messages << object.errors[association_name]
         end
 
-        private :is_invalid?, :generate_error, :has_association_error?,
-                :error_messages, :is_belongs_to_association?, :is_association_same?
+        error_messages
+      end
+
+      def is_belongs_to_association?(association)
+        association.is_a?(ActiveRecord::Reflection::BelongsToReflection)
+      end
+
+      def is_association_same?(attribute, association)
+        (association.foreign_key == attribute.to_s)
       end
     end
   end

data/lib/rails_bootstrap_form/helpers/help_text.rb

@@ -7,46 +7,43 @@ module RailsBootstrapForm
     module HelpText
       extend ActiveSupport::Concern
 
-      def self.included(base_class)
-        def help_text(attribute, bootstrap)
-          return if bootstrap.help_text == false
+      private
 
-          help_text = (bootstrap.help_text || scoped_help_text(attribute))
+      def help_text(attribute, bootstrap)
+        return if bootstrap.help_text == false
 
-          tag.div(help_text, class: "form-text text-muted") if help_text.present?
-        end
+        help_text = (bootstrap.help_text || scoped_help_text(attribute))
 
-        def object_class
-          if !object.class.is_a?(ActiveModel::Naming) &&
-             object.respond_to?(:klass) && object.klass.is_a?(ActiveModel::Naming)
-            object.klass
-          else
-            object.class
-          end
-        end
+        tag.div(help_text, class: "form-text text-muted") if help_text.present?
+      end
 
-        def partial_scope
-          if object_class.respond_to?(:model_name)
-            object_class.model_name.name
-          else
-            object_class.name
-          end
+      def object_class
+        if !object.class.is_a?(ActiveModel::Naming) &&
+           object.respond_to?(:klass) && object.klass.is_a?(ActiveModel::Naming)
+          object.klass
+        else
+          object.class
         end
+      end
 
-        def scoped_help_text(attribute)
-          translation_scope = "activerecord.help_texts.#{partial_scope.underscore}"
+      def partial_scope
+        if object_class.respond_to?(:model_name)
+          object_class.model_name.name
+        else
+          object_class.name
+        end
+      end
 
-          help_text = translated_help_text(attribute, translation_scope).presence
+      def scoped_help_text(attribute)
+        translation_scope = "activerecord.help_texts.#{partial_scope.underscore}"
 
-          help_text
-        end
+        help_text = translated_help_text(attribute, translation_scope).presence
 
-        def translated_help_text(attribute, scope)
-          ActiveSupport::SafeBuffer.new(I18n.t(attribute, scope: scope, default: ""))
-        end
+        help_text
+      end
 
-        private :help_text, :partial_scope, :object_class, :scoped_help_text
-                :translated_help_text
+      def translated_help_text(attribute, scope)
+        ActiveSupport::SafeBuffer.new(I18n.t(attribute, scope: scope, default: ""))
       end
     end
   end

data/lib/rails_bootstrap_form/helpers/labels.rb

@@ -7,47 +7,44 @@ module RailsBootstrapForm
     module Labels
       extend ActiveSupport::Concern
 
-      def self.included(base_class)
-        def draw_label(attribute, options, bootstrap)
-          unless bootstrap.skip_label? && !bootstrap.floating?
-            label_options = {
-              class: label_classes(attribute, options, bootstrap)
-            }
-            label_options[:for] = options[:id] if options[:id].present?
-            label_text = label_text(attribute, bootstrap)
-
-            label(attribute, label_text, label_options)
-          end
-        end
+      private
 
-        def label_classes(attribute, options, bootstrap)
-          classes = []
-          classes << label_layout_classes(bootstrap)
-          classes << bootstrap.additional_label_class
-          classes << bootstrap.hide_class if hide_class_required?(bootstrap)
-          classes << "required" if is_field_required?(attribute, options)
-          classes << "is-invalid" if is_invalid?(attribute)
-          classes.flatten.compact
-        end
+      def draw_label(attribute, options, bootstrap)
+        unless bootstrap.skip_label? && !bootstrap.floating?
+          label_options = {
+            class: label_classes(attribute, options, bootstrap)
+          }
+          label_options[:for] = options[:id] if options[:id].present?
+          label_text = label_text(attribute, bootstrap)
 
-        def label_layout_classes(bootstrap)
-          if bootstrap.layout_horizontal?
-            [bootstrap.label_col_class, bootstrap.label_col_wrapper_class]
-          else
-            bootstrap.label_class
-          end
+          label(attribute, label_text, label_options)
         end
+      end
 
-        def label_text(attribute, bootstrap)
-          bootstrap.label_text || object&.class.try(:human_attribute_name, attribute)
-        end
+      def label_classes(attribute, options, bootstrap)
+        classes = []
+        classes << label_layout_classes(bootstrap)
+        classes << bootstrap.additional_label_class
+        classes << bootstrap.hide_class if hide_class_required?(bootstrap)
+        classes << "required" if is_field_required?(attribute, options)
+        classes << "is-invalid" if is_invalid?(attribute)
+        classes.flatten.compact
+      end
 
-        def hide_class_required?(bootstrap)
-          bootstrap.hide_label? || (bootstrap.layout_inline? && !bootstrap.floating?)
+      def label_layout_classes(bootstrap)
+        if bootstrap.layout_horizontal?
+          [bootstrap.label_col_class, bootstrap.label_col_wrapper_class]
+        else
+          bootstrap.label_class
         end
+      end
+
+      def label_text(attribute, bootstrap)
+        bootstrap.label_text || object&.class.try(:human_attribute_name, attribute)
+      end
 
-        private :draw_label, :label_classes, :label_text, :label_layout_classes,
-                :hide_class_required?
+      def hide_class_required?(bootstrap)
+        bootstrap.hide_label? || (bootstrap.layout_inline? && !bootstrap.floating?)
       end
     end
   end

data/lib/rails_bootstrap_form/helpers/required_field.rb

@@ -7,57 +7,61 @@ module RailsBootstrapForm
     module RequiredField
       extend ActiveSupport::Concern
 
-      def self.included(base_class)
-        def is_field_required?(attribute, options)
-          return false unless attribute
+      private
 
-          if options.key?(:required)
-            options[:required]
-          else
-            is_attribute_required?(attribute)
-          end
+      def is_field_required?(attribute, options)
+        return false unless attribute
+
+        if options.key?(:required)
+          options[:required]
+        else
+          is_attribute_required?(attribute)
         end
+      end
 
-        def required_field_options(attribute, options)
-          required = is_field_required?(attribute, options)
+      def required_field_options(attribute, options)
+        required = is_field_required?(attribute, options)
 
-          {}.tap do |option|
-            option[:aria] = {required: true} if required
-            option[:required] = required
-          end
+        {}.tap do |option|
+          option[:aria] = {required: true} if required
+          option[:required] = required
         end
+      end
 
-        def is_attribute_required?(attribute)
-          return false unless attribute
+      def is_attribute_required?(attribute)
+        return false unless attribute
 
-          target = object.instance_of?(Class) ? object : object.class
-          return false unless target.respond_to?(:validators_on)
+        target = target_object(object)
+        return false unless target.respond_to?(:validators_on)
 
-          has_presence_validator?(target_validators(target, attribute)) ||
-            is_required_association?(target, attribute)
-        end
+        has_presence_validator?(target_validators(target, attribute)) || is_required_association?(target, attribute)
+      end
 
-        def target_validators(target, attribute)
-          target.validators_on(attribute).map(&:class)
-        end
+      def target_object(object)
+        object.instance_of?(Class) ? object : object.class
+      end
 
-        def has_presence_validator?(target_validators)
-          target_validators.include?(ActiveModel::Validations::PresenceValidator) ||
-            (defined?(ActiveRecord::Validations::PresenceValidator) &&
-              target_validators.include?(ActiveRecord::Validations::PresenceValidator))
-        end
+      def target_validators(target, attribute)
+        target.validators_on(attribute).map(&:class)
+      end
 
-        def is_required_association?(target, attribute)
-          target.try(:reflections)&.find do |name, a|
-            next unless a.is_a?(ActiveRecord::Reflection::BelongsToReflection)
-            next unless a.foreign_key == attribute.to_s
+      def has_presence_validator?(target_validators)
+        target_validators.include?(ActiveModel::Validations::PresenceValidator) ||
+          (defined?(ActiveRecord::Validations::PresenceValidator) &&
+            target_validators.include?(ActiveRecord::Validations::PresenceValidator))
+      end
 
-            has_presence_validator?(target_validators(target, name))
-          end
+      def is_required_association?(target, attribute)
+        target.try(:reflections)&.find do |name, reflection|
+          required_association?(reflection, attribute)
         end
+      end
+
+      def required_association?(reflection, attribute)
+        return false unless reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection)
+        return false unless reflection.foreign_key == attribute.to_s
 
-        private :is_field_required?, :required_field_options, :target_validators,
-                :has_presence_validator?, :is_required_association?
+        has_presence_validator?(target_validators(reflection.active_record, reflection.name))
       end
     end
   end

data/lib/rails_bootstrap_form/input_group_builder.rb

@@ -6,58 +6,55 @@ module RailsBootstrapForm
   module InputGroupBuilder
     extend ActiveSupport::Concern
 
-    def self.included(base_class)
-      def input_group_wrapper(attribute, bootstrap, &block)
-        input = capture(&block) || ActiveSupport::SafeBuffer.new
+    private
 
-        if input_group_required?(bootstrap)
-          prepend = attach_input(bootstrap, :prepend)
-          append = attach_input(bootstrap, :append)
+    def input_group_wrapper(attribute, bootstrap, &block)
+      input = capture(&block) || ActiveSupport::SafeBuffer.new
 
-          input = prepend + input + append
-          input += generate_error(attribute)
+      if input_group_required?(bootstrap)
+        prepend = attach_input(bootstrap, :prepend)
+        append = attach_input(bootstrap, :append)
 
-          input = tag.div(input, class: input_group_classes(attribute, bootstrap))
-        else
-          input += generate_error(attribute)
-        end
+        input = prepend + input + append
+        input += generate_error(attribute)
 
-        input
+        input = tag.div(input, class: input_group_classes(attribute, bootstrap))
+      else
+        input += generate_error(attribute)
       end
 
-      def input_group_classes(attribute, bootstrap)
-        classes = Array("input-group") << bootstrap.additional_input_group_class
-        if is_size_valid?(bootstrap)
-          classes << "input-group-#{bootstrap.size}"
-        end
-        # Require `has-validation` class if field has errors.
-        classes << "has-validation" if is_invalid?(attribute)
-        classes.flatten.compact
-      end
+      input
+    end
 
-      def attach_input(bootstrap, key)
-        tags = [*bootstrap.send(key)].map do |item|
-          input_group_content(item)
-        end
+    def input_group_classes(attribute, bootstrap)
+      classes = Array("input-group") << bootstrap.additional_input_group_class
+      if is_size_valid?(bootstrap)
+        classes << "input-group-#{bootstrap.size}"
+      end
+      # Require `has-validation` class if field has errors.
+      classes << "has-validation" if is_invalid?(attribute)
+      classes.flatten.compact
+    end
 
-        ActiveSupport::SafeBuffer.new(tags.join)
+    def attach_input(bootstrap, key)
+      tags = [*bootstrap.send(key)].map do |item|
+        input_group_content(item)
       end
 
-      def input_group_content(content)
-        return content if /button|submit/.match?(content)
+      ActiveSupport::SafeBuffer.new(tags.join)
+    end
 
-        tag.span(content.html_safe, class: "input-group-text")
-      end
+    def input_group_content(content)
+      return content if /button|submit/.match?(content)
 
-      def input_group_required?(bootstrap)
-        [
-          bootstrap.prepend,
-          bootstrap.append
-        ].any?(&:present?)
-      end
+      tag.span(content.html_safe, class: "input-group-text")
+    end
 
-      private :input_group_wrapper, :input_group_classes, :attach_input,
-              :input_group_content, :input_group_required?
+    def input_group_required?(bootstrap)
+      [
+        bootstrap.prepend,
+        bootstrap.append
+      ].any?(&:present?)
     end
   end
 end

data/lib/rails_bootstrap_form/inputs/base.rb

@@ -12,22 +12,8 @@ module RailsBootstrapForm
           inputs = ActiveSupport::SafeBuffer.new
 
           collection.each do |object|
-            value = object.send(value_method)
-
-            input_options = {
-              bootstrap: {
-                label_text: text_method.respond_to?(:call) ? text_method.call(object) : object.send(text_method),
-                inline: (bootstrap.inline? || bootstrap.layout_inline?)
-              },
-              required: false,
-              id: sanitized_tag_name(attribute, value)
-            }.deep_merge!(options)
-
-            if (checked = input_options[:checked])
-              input_options[:checked] = collection_input_checked?(checked, object, value)
-            end
-
-            input_value = value_method.respond_to?(:call) ? value_method.call(object) : value
+            input_options = build_input_options(object, attribute, value_method, text_method, bootstrap, options)
+            input_value = resolve_input_value(object, value_method)
 
             inputs << yield(attribute, input_value, input_options)
           end
@@ -66,6 +52,36 @@ module RailsBootstrapForm
           end
         end
       end
+
+      private
+
+      def build_input_options(object, attribute, value_method, text_method, bootstrap, options)
+        input_options = {
+          bootstrap: {
+            label_text: resolve_label_text(text_method, object),
+            inline: (bootstrap.inline? || bootstrap.layout_inline?)
+          },
+          required: false,
+          id: sanitized_tag_name(attribute, object.send(value_method))
+        }.deep_merge!(options)
+
+        input_options[:checked] = resolve_checked_option(input_options[:checked], object, value_method)
+
+        input_options
+      end
+
+      def resolve_label_text(text_method, object)
+        text_method.respond_to?(:call) ? text_method.call(object) : object.send(text_method)
+      end
+
+      def resolve_input_value(object, value_method)
+        value_method.respond_to?(:call) ? value_method.call(object) : object.send(value_method)
+      end
+
+      def resolve_checked_option(checked_option, object, value_method)
+        return collection_input_checked?(checked_option, object, object.send(value_method)) if checked_option
+        false
+      end
     end
   end
 end

data/lib/rails_bootstrap_form/inputs/check_box.rb

@@ -12,20 +12,10 @@ module RailsBootstrapForm
           bootstrap = bootstrap_form_options.scoped(options.delete(:bootstrap))
           return super if bootstrap.disabled?
 
-          check_box_html = tag.div(class: choice_wrapper_classes(bootstrap)) do
-            concat(bootstrap_check_box(attribute, checked_value, options, bootstrap))
-            concat(help_text(attribute, bootstrap))
-            concat(generate_error(attribute)) if is_invalid?(attribute)
-          end
+          check_box_html = build_check_box_html(attribute, checked_value, bootstrap, options)
 
           if bootstrap.wrapper
-            tag.div(**field_wrapper_options(bootstrap)) do
-              if bootstrap.layout_horizontal?
-                tag.div(class: choice_container_classes(bootstrap)) { check_box_html }
-              else
-                check_box_html
-              end
-            end
+            build_wrapped_check_box_html(bootstrap, check_box_html)
           else
             check_box_html
           end

data/lib/rails_bootstrap_form/inputs/radio_button.rb

@@ -12,20 +12,10 @@ module RailsBootstrapForm
           bootstrap = bootstrap_form_options.scoped(options.delete(:bootstrap))
           return super if bootstrap.disabled?
 
-          radio_button_html = tag.div(class: choice_wrapper_classes(bootstrap)) do
-            concat(bootstrap_radio_button(attribute, value, options, bootstrap))
-            concat(help_text(attribute, bootstrap))
-            concat(generate_error(attribute)) if is_invalid?(attribute)
-          end
+          radio_button_html = build_radio_button_html(attribute, value, bootstrap, options)
 
           if bootstrap.wrapper
-            tag.div(**field_wrapper_options(bootstrap)) do
-              if bootstrap.layout_horizontal?
-                tag.div(class: choice_container_classes(bootstrap)) { radio_button_html }
-              else
-                radio_button_html
-              end
-            end
+            build_wrapped_radio_button_html(bootstrap, radio_button_html)
           else
             radio_button_html
           end

data/lib/rails_bootstrap_form/version.rb

@@ -3,6 +3,6 @@
 # -*- warn_indent: true -*-
 
 module RailsBootstrapForm
-  VERSION = "0.9.7".freeze
+  VERSION = "0.9.8".freeze
   REQUIRED_RAILS_VERSION = "~> 7.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_bootstrap_form
 version: !ruby/object:Gem::Version
-  version: 0.9.7
+  version: 0.9.8
 platform: ruby
 authors:
 - Harshal LADHE (shivam091)
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-06-26 00:00:00.000000000 Z
+date: 2023-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: generator_spec
@@ -60,6 +60,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".rspec"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md