comfy_bootstrap_form 4.0.0.beta1 → 4.0.0.beta2

data/{test/dummy → demo}/config/environments/test.rb

@@ -1,4 +1,4 @@
-Dummy::Application.configure do
+Rails.application.configure do
   # Settings specified here will take precedence over those in config/application.rb.
 
   # The test environment is used exclusively to run your application's
@@ -12,23 +12,11 @@ Dummy::Application.configure do
   # preloads Rails for running tests, you may have to set it to true.
   config.eager_load = false
 
-  version = Rails.version.to_f
-
-  # Configure static asset server for tests with Cache-Control for performance.
-  if version < 4.2
-    config.serve_static_assets  = true
-  elsif version < 5
-    config.serve_static_files  = true
-  end
-
-  if version < 5
-    config.static_cache_control = "public, max-age=3600"
-  else
-    config.public_file_server.enabled = true
-    config.public_file_server.headers = {
-      "Cache-Control" => "public, max-age=3600"
-    }
-  end
+  # Configure public file server for tests with Cache-Control for performance.
+  config.public_file_server.enabled = true
+  config.public_file_server.headers = {
+    'Cache-Control' => "public, max-age=#{1.hour.to_i}"
+  }
 
   # Show full error reports and disable caching.
   config.consider_all_requests_local       = true
@@ -40,6 +28,13 @@ Dummy::Application.configure do
   # Disable request forgery protection in test environment.
   config.action_controller.allow_forgery_protection = false
 
+  # Store uploaded files on the local file system in a temporary directory
+  if config.respond_to?(:active_storage)
+    config.active_storage.service = :test
+  end
+
+  config.action_mailer.perform_caching = false
+
   # Tell Action Mailer not to deliver emails to the real world.
   # The :test delivery method accumulates sent emails in the
   # ActionMailer::Base.deliveries array.
@@ -48,6 +43,6 @@ Dummy::Application.configure do
   # Print deprecation notices to the stderr.
   config.active_support.deprecation = :stderr
 
-  # In Rails 5, the default value of this option will change from `:sorted` to `:random`.
-  config.active_support.test_order = :sorted
+  # Raises error for missing translations
+  # config.action_view.raise_on_missing_translations = true
 end

data/demo/config/initializers/application_controller_renderer.rb

@@ -0,0 +1,8 @@
+# Be sure to restart your server when you modify this file.
+
+# ActiveSupport::Reloader.to_prepare do
+#   ApplicationController.renderer.defaults.merge!(
+#     http_host: 'example.org',
+#     https: false
+#   )
+# end

data/demo/config/initializers/assets.rb

@@ -0,0 +1,14 @@
+# Be sure to restart your server when you modify this file.
+
+# Version of your assets, change this if you want to expire all your assets.
+Rails.application.config.assets.version = '1.0'
+
+# Add additional assets to the asset load path.
+# Rails.application.config.assets.paths << Emoji.images_path
+# Add Yarn node_modules folder to the asset load path.
+Rails.application.config.assets.paths << Rails.root.join('node_modules')
+
+# Precompile additional assets.
+# application.js, application.css, and all non-JS/CSS in the app/assets
+# folder are already added.
+# Rails.application.config.assets.precompile += %w( admin.js admin.css )

data/demo/config/initializers/cookies_serializer.rb

@@ -0,0 +1,5 @@
+# Be sure to restart your server when you modify this file.
+
+# Specify a serializer for the signed and encrypted cookie jars.
+# Valid options are :json, :marshal, and :hybrid.
+Rails.application.config.action_dispatch.cookies_serializer = :json

data/{test/dummy → demo}/config/initializers/mime_types.rb

@@ -2,4 +2,3 @@
 
 # Add new mime types for use in respond_to blocks:
 # Mime::Type.register "text/richtext", :rtf
-# Mime::Type.register_alias "text/html", :iphone

data/{test/dummy → demo}/config/initializers/wrap_parameters.rb

@@ -5,10 +5,10 @@
 
 # Enable parameter wrapping for JSON. You can disable this by setting :format to an empty array.
 ActiveSupport.on_load(:action_controller) do
-  wrap_parameters format: [:json] if respond_to?(:wrap_parameters)
+  wrap_parameters format: [:json]
 end
 
 # To enable root element in JSON for ActiveRecord objects.
 # ActiveSupport.on_load(:active_record) do
-#  self.include_root_in_json = true
+#   self.include_root_in_json = true
 # end

data/{test/dummy → demo}/config/locales/en.yml

@@ -16,6 +16,16 @@
 #
 # This would use the information in config/locales/es.yml.
 #
+# The following keys must be escaped otherwise they will not be retrieved by
+# the default I18n backend:
+#
+# true, false, on, off, yes, no
+#
+# Instead, surround them with single quotes.
+#
+# en:
+#   'true': 'foo'
+#
 # To learn more, please read the Rails Internationalization guide
 # available at http://guides.rubyonrails.org/i18n.html.
 

data/demo/config/puma.rb

@@ -0,0 +1,56 @@
+# Puma can serve each request in a thread from an internal thread pool.
+# The `threads` method setting takes two numbers: a minimum and maximum.
+# Any libraries that use thread pools should be configured to match
+# the maximum value specified for Puma. Default is set to 5 threads for minimum
+# and maximum; this matches the default thread size of Active Record.
+#
+threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }
+threads threads_count, threads_count
+
+# Specifies the `port` that Puma will listen on to receive requests; default is 3000.
+#
+port        ENV.fetch("PORT") { 3000 }
+
+# Specifies the `environment` that Puma will run in.
+#
+environment ENV.fetch("RAILS_ENV") { "development" }
+
+# Specifies the number of `workers` to boot in clustered mode.
+# Workers are forked webserver processes. If using threads and workers together
+# the concurrency of the application would be max `threads` * `workers`.
+# Workers do not work on JRuby or Windows (both of which do not support
+# processes).
+#
+# workers ENV.fetch("WEB_CONCURRENCY") { 2 }
+
+# Use the `preload_app!` method when specifying a `workers` number.
+# This directive tells Puma to first boot the application and load code
+# before forking the application. This takes advantage of Copy On Write
+# process behavior so workers use less memory. If you use this option
+# you need to make sure to reconnect any threads in the `on_worker_boot`
+# block.
+#
+# preload_app!
+
+# If you are preloading your application and using Active Record, it's
+# recommended that you close any connections to the database before workers
+# are forked to prevent connection leakage.
+#
+# before_fork do
+#   ActiveRecord::Base.connection_pool.disconnect! if defined?(ActiveRecord)
+# end
+
+# The code in the `on_worker_boot` will be called if you are using
+# clustered mode by specifying a number of `workers`. After each worker
+# process is booted, this block will be run. If you are using the `preload_app!`
+# option, you will want to use this block to reconnect to any threads
+# or connections that may have been created at application boot, as Ruby
+# cannot share connections between processes.
+#
+# on_worker_boot do
+#   ActiveRecord::Base.establish_connection if defined?(ActiveRecord)
+# end
+#
+
+# Allow puma to be restarted by `rails restart` command.
+plugin :tmp_restart

data/{test/dummy → demo}/config/routes.rb

@@ -1,3 +1,5 @@
 Dummy::Application.routes.draw do
   resources :users
+
+  root to: "bootstrap#form"
 end

data/demo/config/spring.rb

@@ -0,0 +1,6 @@
+%w[
+  .ruby-version
+  .rbenv-vars
+  tmp/restart.txt
+  tmp/caching-dev.txt
+].each { |path| Spring.watch(path) }

data/demo/config/storage.yml

@@ -0,0 +1,35 @@
+test:
+  service: Disk
+  root: <%= Rails.root.join("tmp/storage") %>
+
+local:
+  service: Disk
+  root: <%= Rails.root.join("storage") %>
+
+# Use rails credentials:edit to set the AWS secrets (as aws:access_key_id|secret_access_key)
+# amazon:
+#   service: S3
+#   access_key_id: <%= Rails.application.credentials.dig(:aws, :access_key_id) %>
+#   secret_access_key: <%= Rails.application.credentials.dig(:aws, :secret_access_key) %>
+#   region: us-east-1
+#   bucket: your_own_bucket
+
+# Remember not to checkin your GCS keyfile to a repository
+# google:
+#   service: GCS
+#   project: your_project
+#   keyfile: <%= Rails.root.join("path/to/gcs.keyfile") %>
+#   bucket: your_own_bucket
+
+# Use rails credentials:edit to set the Azure Storage secret (as azure_storage:storage_access_key)
+# microsoft:
+#   service: AzureStorage
+#   path: your_azure_storage_path
+#   storage_account_name: your_account_name
+#   storage_access_key: <%= Rails.application.credentials.dig(:azure_storage, :storage_access_key) %>
+#   container: your_container_name
+
+# mirror:
+#   service: Mirror
+#   primary: local
+#   mirrors: [ amazon, google, microsoft ]

data/demo/db/schema.rb

@@ -0,0 +1,11 @@
+ActiveRecord::Schema.define(version: 1) do
+
+  create_table :users, force: :cascade do |t|
+    t.string  :email
+    t.string  :password
+    t.boolean :terms, default: false
+    t.string  :test
+    t.timestamps
+  end
+
+end

data/demo/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "dummy",
+  "private": true,
+  "dependencies": {}
+}

data/lib/bootstrap_form.rb

@@ -1,5 +1,5 @@
 require 'bootstrap_form/form_builder'
-require 'bootstrap_form/helper'
+require 'bootstrap_form/view_helper'
 
 module BootstrapForm
   module Rails
@@ -9,5 +9,5 @@ module BootstrapForm
 end
 
 ActiveSupport.on_load(:action_view) do
-  include BootstrapForm::Helper
+  include BootstrapForm::ViewHelper
 end

data/lib/bootstrap_form/form_builder.rb

@@ -1,460 +1,481 @@
-require_relative 'aliasing'
-require_relative 'helpers/bootstrap'
-
 module BootstrapForm
   class FormBuilder < ActionView::Helpers::FormBuilder
-    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     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
+    ].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
 
-    DATE_SELECT_HELPERS = %w{date_select time_select datetime_select}
+      def horizontal?
+        @layout.to_s == "horizontal"
+      end
 
-    delegate :content_tag, :capture, :concat, to: :@template
+      def inline?
+        @layout.to_s == "inline"
+      end
 
-    def initialize(object_name, object, template, options)
-      @layout = options[:layout]
-      @label_col = options[:label_col] || default_label_col
-      @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
+      def offset_col_class
+        label_col_class.sub(/\Acol-(\w+)-(\d+)\z/, 'offset-\1-\2')
       end
-      @acts_like_form_tag = options[:acts_like_form_tag]
 
-      super
     end
 
-    FIELD_HELPERS.each do |method_name|
-      with_method_name = "#{method_name}_with_bootstrap"
-      without_method_name = "#{method_name}_without_bootstrap"
+    delegate :content_tag, :capture, :concat, to: :@template
 
-      define_method(with_method_name) do |name, options = {}|
-        form_group_builder(name, options) do
-          prepend_and_append_input(options) do
-            send(without_method_name, name, options)
-          end
-        end
-      end
+    attr_accessor :bootstrap
 
-      bootstrap_method_alias method_name
+    def initialize(object_name, object, template, options)
+      @bootstrap = BootstrapOptions.new(options.delete(:bootstrap) || {})
+      super(object_name, object, template, options)
     end
 
-    DATE_SELECT_HELPERS.each do |method_name|
-      with_method_name = "#{method_name}_with_bootstrap"
-      without_method_name = "#{method_name}_without_bootstrap"
-
-      define_method(with_method_name) do |name, options = {}, html_options = {}|
-        form_group_builder(name, options, html_options) do
-          content_tag(:div, send(without_method_name, name, options, html_options), class: control_specific_class(method_name))
+    # Overriding default methods to forward everything to field_helper
+    FIELD_HELPERS.each do |field_helper|
+      class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+        def #{field_helper}(method, options = {})
+          field_helper(method, options) do
+            super(method, options)
+          end
         end
-      end
-
-      bootstrap_method_alias method_name
+      RUBY_EVAL
     end
 
-    def file_field_with_bootstrap(name, options = {})
-      form_group_builder(name, options.reverse_merge(control_class: nil)) do
-        file_field_without_bootstrap(name, options)
+    # Wrapper for select helper. Boostrap options are sent via html_options hash:
+    #
+    #   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
+        super(method, choices, options, html_options, &block)
       end
     end
 
-    bootstrap_method_alias :file_field
+    # Wrapper around checkbox. Example usage:
+    #
+    #   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] || {}
 
-    if Gem::Version.new(Rails::VERSION::STRING) >= Gem::Version.new("4.1.0")
-      def select_with_bootstrap(method, choices = nil, options = {}, html_options = {}, &block)
-        form_group_builder(method, options, html_options) do
-          prepend_and_append_input(options) do
-            select_without_bootstrap(method, choices, options, html_options, &block)
-          end
-        end
+      help_text = draw_help(bootstrap_options[: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?
+        label_text = custom_text
       end
-    else
-      def select_with_bootstrap(method, choices, options = {}, html_options = {})
-        form_group_builder(method, options, html_options) do
-          prepend_and_append_input(options) do
-            select_without_bootstrap(method, choices, options, html_options)
+
+      fieldset_css_class = "form-group"
+      fieldset_css_class << " row" if bootstrap.horizontal?
+      fieldset_css_class << " #{bootstrap.inline_margin_class}" if bootstrap.inline?
+
+      content_tag(:fieldset, class: fieldset_css_class) do
+        draw_control_column(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")
+            concat errors     if errors.present?
+            concat help_text  if help_text.present?
           end
         end
       end
     end
 
-    bootstrap_method_alias :select
-
-    def collection_select_with_bootstrap(method, collection, value_method, text_method, options = {}, html_options = {})
-      form_group_builder(method, options, html_options) do
-        collection_select_without_bootstrap(method, collection, value_method, text_method, options, html_options)
+    # Helper to generate multiple radio buttons. Example usage:
+    #
+    #   collection_radio_buttons :choices, ["a", "b"], :to_s, :to_s %>
+    #   collection_radio_buttons :choices, [["a", "Label A"], ["b", "Label B"]], :first, :second
+    #   collection_radio_buttons :choices, Choice.all, :id, :label
+    #
+    # Takes bootstrap options:
+    #   inline: true            - to render inputs inline
+    #   label: {text: "Custom"} - to specify a label
+    #   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) || {})
+
+      args = [bootstrap_options, method, collection, value_method, text_method, options, html_options]
+      draw_choices(*args) do |m, v, opts|
+        radio_button(m, v, opts)
       end
     end
 
-    bootstrap_method_alias :collection_select
+    # Helper to generate multiple checkboxes. Same options as for radio buttons.
+    # Example usage:
+    #
+    #   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) || {})
 
-    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
-        grouped_collection_select_without_bootstrap(method, collection, group_method, group_label_method, option_key_method, option_value_method, options, html_options)
+      content = "".html_safe
+      unless options[:include_hidden] == false
+        content << hidden_field(method, multiple: true, value: "")
       end
-    end
-
-    bootstrap_method_alias :grouped_collection_select
 
-    def time_zone_select_with_bootstrap(method, priority_zones = nil, options = {}, html_options = {})
-      form_group_builder(method, options, html_options) do
-        time_zone_select_without_bootstrap(method, priority_zones, options, html_options)
+      args = [bootstrap_options, method, collection, value_method, text_method, options, html_options]
+      content << draw_choices(*args) do |m, v, opts|
+        opts[:multiple]       = true
+        opts[:include_hidden] = false
+        ActionView::Helpers::FormBuilder.instance_method(:check_box).bind(self).call(m, opts, v)
       end
     end
 
-    bootstrap_method_alias :time_zone_select
-
-    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, :help, :inline)
-      check_box_options[:class] = ["form-check-input", check_box_options[:class]].compact.join(' ')
-
-      html = check_box_without_bootstrap(name, check_box_options, checked_value, unchecked_value)
-      label_content = block_given? ? capture(&block) : options[:label]
-      html.concat(" ").concat(label_content || (object && object.class.human_attribute_name(name)) || name.to_s.humanize)
-
-      label_name = name
-      # label's `for` attribute needs to match checkbox tag's id,
-      # IE sanitized value, IE
-      # https://github.com/rails/rails/blob/c57e7239a8b82957bcb07534cb7c1a3dcef71864/actionview/lib/action_view/helpers/tags/base.rb#L116-L118
-      if options[:multiple]
-        label_name =
-          "#{name}_#{checked_value.to_s.gsub(/\s/, "_").gsub(/[^-\w]/, "").downcase}"
+    # Bootstrap wrapper for readonly text field that is shown as plain text.
+    #
+    #   plaintext(:value)
+    #
+    def plaintext(method, options = {})
+      bootstrap_options = (options.delete(:bootstrap) || {})
+      draw_form_group(bootstrap_options, method, options) do
+        remove_css_class!(options, "form-control")
+        add_css_class!(options, "form-control-plaintext")
+        options[:readonly] = true
+        ActionView::Helpers::FormBuilder.instance_method(:text_field).bind(self).call(method, options)
       end
+    end
 
-      disabled_class = " disabled" if options[:disabled]
-      label_class    = options[:label_class]
-
-      if options[:inline]
-        label_class = " #{label_class}" if label_class
-        label(label_name, html, class: "form-check-inline#{disabled_class}#{label_class}")
-      else
-        content_tag(:div, class: "form-check#{disabled_class}") do
-          label(label_name, html, class: ["form-check-label", label_class].compact.join(" "))
+    # Add bootstrap formatted submit button. If you need to change its type or
+    # add another css class, you need to override all css classes like so:
+    #
+    #   submit(class: "btn btn-info custom-class")
+    #
+    # You may add additional content that directly follows the button. Here's
+    # an example of a cancel link:
+    #
+    #   submit do
+    #     link_to("Cancel", "/", class: "btn btn-link")
+    #   end
+    #
+    def submit(value = nil, options = {}, &block)
+      value, options = nil, value if value.is_a?(Hash)
+      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
+          out = super(value, options)
+          out << capture(&block) if block_given?
+          out
         end
       end
     end
 
-    bootstrap_method_alias :check_box
+    # Same as submit button, only with btn-primary class added
+    def primary(value = nil, options = {}, &block)
+      add_css_class!(options, "btn-primary")
+      submit(value, options, &block)
+    end
 
-    def radio_button_with_bootstrap(name, value, *args)
-      options = args.extract_options!.symbolize_keys!
-      args << options.except(:label, :label_class, :help, :inline)
+    # Helper method to put arbitrary content in markup that renders correctly
+    # for the Bootstrap form. Example:
+    #
+    #   form_group bootstrap: {label: {text: "Label"}} do
+    #     "Some content"
+    #   end
+    #
+    def form_group(options = {}, &block)
+      bootstrap_options       = options.delete(:bootstrap) || {}
+      bootstrap_label_options = bootstrap_options.delete(:label) || {}
 
-      html = radio_button_without_bootstrap(name, value, *args) + " " + options[:label]
+      label_text = bootstrap_label_options[:text]
 
-      disabled_class = " disabled" if options[:disabled]
-      label_class    = options[:label_class]
+      label = if label_text.present?
+        label_options = {}
+        add_css_class!(label_options, bootstrap_label_options[:class])
 
-      if options[:inline]
-        label_class = " #{label_class}" if label_class
-        label(name, html, class: "radio-inline#{disabled_class}#{label_class}", value: value)
-      else
-        content_tag(:div, class: "radio#{disabled_class}") do
-          label(name, html, value: value, class: 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
-      end
-    end
-
-    bootstrap_method_alias :radio_button
 
-    def collection_check_boxes_with_bootstrap(*args)
-      html = inputs_collection(*args) do |name, value, options|
-        options[:multiple] = true
-        check_box(name, options, value, nil)
+        content_tag(:label, label_text, label_options)
       end
-      hidden_field(args.first,{value: "", multiple: true}).concat(html)
-    end
 
-    bootstrap_method_alias :collection_check_boxes
+      form_group_class = "form-group"
+      form_group_class << " row"      if bootstrap.horizontal?
+      form_group_class << " mr-sm-2"  if bootstrap.inline?
 
-    def collection_radio_buttons_with_bootstrap(*args)
-      inputs_collection(*args) do |name, value, options|
-        radio_button(name, value, options)
+      content_tag(:div, class: form_group_class) do
+        content = "".html_safe
+        content << label if label.present?
+        content << draw_control_column(offset: label.blank?) do
+          yield
+        end
       end
     end
 
-    bootstrap_method_alias :collection_radio_buttons
-
-    def check_boxes_collection(*args)
-      warn "'BootstrapForm#check_boxes_collection' is deprecated, use 'BootstrapForm#collection_check_boxes' instead"
-      collection_check_boxes(*args)
-    end
-
-    def radio_buttons_collection(*args)
-      warn "'BootstrapForm#radio_buttons_collection' is deprecated, use 'BootstrapForm#collection_radio_buttons' instead"
-      collection_radio_buttons(*args)
-    end
-
-    def form_group(*args, &block)
-      options = args.extract_options!
-      name = args.first
-
-      options[:class] = ["form-group", options[:class]].compact.join(' ')
-      options[:class] << " row" if get_group_layout(options[:layout]) == :horizontal
-      options[:class] << " #{error_class}" if has_error?(name)
-      options[:class] << " #{feedback_class}" if options[:icon]
-
-      content_tag(:div, options.except(:id, :label, :help, :icon, :label_col, :control_col, :layout)) do
-        label = generate_label(options[:id], name, options[:label], options[:label_col], options[:layout]) if options[:label]
-        control = capture(&block).to_s
-        control.concat(generate_help(name, options[:help]).to_s)
-        control.concat(generate_icon(options[:icon])) if options[:icon]
-
-        if get_group_layout(options[:layout]) == :horizontal
-          control_class = options[:control_col] || control_col
-          unless options[:label]
-            control_offset = offset_col(options[:label_col] || @label_col)
-            control_class = "#{control_class} #{control_offset}"
-          end
-          control = content_tag(:div, control, class: control_class)
-        end
+  private
 
-        concat(label).concat(control)
+    # 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
 
-    def fields_for_with_bootstrap(record_name, record_object = nil, fields_options = {}, &block)
-      fields_options, record_object = record_object, nil if record_object.is_a?(Hash) && record_object.extractable_options?
-      fields_options[:layout] ||= options[:layout]
-      fields_options[:label_col] = fields_options[:label_col].present? ? "#{fields_options[:label_col]} #{label_class}" : options[:label_col]
-      fields_options[:control_col] ||= options[:control_col]
-      fields_options[:inline_errors] ||= options[:inline_errors]
-      fields_options[:label_errors] ||= options[:label_errors]
-      fields_for_without_bootstrap(record_name, record_object, fields_options, &block)
-    end
+    # form group wrapper for input fields
+    def draw_form_group(bootstrap_options, method, options, &block)
+      label  = draw_label(bootstrap_options, method)
+      errors = draw_errors(method)
 
-    bootstrap_method_alias :fields_for
+      control = draw_control(bootstrap_options, errors, method, options) do
+        yield
+      end
 
-    private
+      form_group_class = "form-group"
+      form_group_class << " row"      if bootstrap.horizontal?
+      form_group_class << " mr-sm-2"  if bootstrap.inline?
 
-    def horizontal?
-      layout == :horizontal
+      content_tag(:div, class: form_group_class) do
+        concat label
+        concat control
+      end
     end
 
-    def get_group_layout(group_layout)
-      group_layout || layout
-    end
+    def draw_errors(method)
+      return unless (errors = object && object.errors[method]).present?
 
-    def default_label_col
-      "col-sm-2"
+      content_tag(:div, class: "invalid-feedback") do
+        errors.join(", ")
+      end
     end
 
-    def offset_col(label_col)
-      label_col.sub(/^col-(\w+)-(\d)$/, 'col-\1-offset-\2')
-    end
+    # Renders label for a given field. Takes following bootstrap options:
+    #
+    # :text   - replace default label text
+    # :class  - css class on the label
+    # :hide   - if `true` will render for screen readers only
+    #
+    # This is how those options can be passed in:
+    #
+    #   text_field(:value, bootstrap: {label: {text: "Custom", class: "custom"}})
+    #
+    def draw_label(bootstrap_options, method)
+      bootstrap_label_options = bootstrap_options[:label] || {}
+
+      text    = nil
+      options = {}
+
+      if (custom_text = bootstrap_label_options[:text]).present?
+        text = custom_text
+      end
 
-    def default_control_col
-      "col-sm-10"
-    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.inline_margin_class) if bootstrap.inline?
 
-    def hide_class
-      "sr-only" # still accessible for screen readers
-    end
+      if bootstrap.horizontal?
+        add_css_class!(options, "col-form-label")
+        add_css_class!(options, bootstrap.label_col_class)
+        add_css_class!(options, bootstrap.label_align_class)
+      end
 
-    def control_class
-      "form-control"
+      label(method, text, options)
     end
 
-    def label_class
-      "form-control-label"
-    end
+    # Renders control for a given field
+    def draw_control(bootstrap_options, errors, method, options, &block)
+      bootstrap_label_options  = bootstrap_options[:label] || {}
 
-    def error_class
-      "has-danger"
-    end
+      add_css_class!(options, "form-control")
+      add_css_class!(options, "is-invalid") if errors.present?
 
-    def feedback_class
-      "has-feedback"
-    end
+      offset = !!bootstrap_label_options[:hide]
 
-    def control_specific_class(method)
-      "rails-bootstrap-forms-#{method.gsub(/_/, "-")}"
+      draw_control_column(offset: offset) do
+        draw_input_group(bootstrap_options, errors) do
+          yield
+        end
+      end
     end
 
-    def has_error?(name)
-      object.respond_to?(:errors) && !(name.nil? || object.errors[name].empty?)
+    # Wrapping in control in column wrapper
+    #
+    def draw_control_column(offset:, &block)
+      return yield unless bootstrap.horizontal?
+      css_class = "#{bootstrap.control_col_class}"
+      css_class << " #{bootstrap.offset_col_class}" if offset
+      content_tag(:div, class: css_class) do
+        yield
+      end
     end
 
-    def required_attribute?(obj, attribute)
-
-      return false unless obj and attribute
-
-      target = (obj.class == Class) ? obj : obj.class
-
-      target_validators = if target.respond_to? :validators_on
-                            target.validators_on(attribute).map(&:class)
-                          else
-                            []
-                          end
-
-      has_presence_validator = target_validators.include?(
-                                 ActiveModel::Validations::PresenceValidator)
-
-      if defined? ActiveRecord::Validations::PresenceValidator
-        has_presence_validator |= target_validators.include?(
-                                    ActiveRecord::Validations::PresenceValidator)
+    # Wraps input field in input group container that allows prepending and
+    # appending text or html. Example:
+    #
+    #   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)
+
+      help_text = draw_help(bootstrap_options[:help])
+
+      # Not prepending or appending anything. Bail.
+      if prepend_html.blank? && append_html.blank?
+        content = capture(&block)
+        content << errors     if errors.present?
+        content << help_text  if help_text.present?
+        return content
       end
 
-      has_presence_validator
-    end
-
-    def form_group_builder(method, options, html_options = nil)
-      options.symbolize_keys!
-      html_options.symbolize_keys! if html_options
-
-      # Add control_class; allow it to be overridden by :control_class option
-      css_options = html_options || options
-      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 has_error?(method)
-
-      options = convert_form_tag_options(method, options) if acts_like_form_tag
-
-      wrapper_class = css_options.delete(:wrapper_class)
-      wrapper_options = css_options.delete(:wrapper)
-      help = options.delete(:help)
-      icon = options.delete(:icon)
-      label_col = options.delete(:label_col)
-      control_col = options.delete(:control_col)
-      layout = get_group_layout(options.delete(:layout))
-      form_group_options = {
-        id: options[:id],
-        help: help,
-        icon: icon,
-        label_col: label_col,
-        control_col: control_col,
-        layout: layout,
-        class: wrapper_class
-      }
-
-      if wrapper_options.is_a?(Hash)
-        form_group_options.merge!(wrapper_options)
+      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
+    end
 
-      unless options.delete(:skip_label)
-        if options[:label].is_a?(Hash)
-          label_text  = options[:label].delete(:text)
-          label_class = options[:label].delete(:class)
-          options.delete(:label)
-        end
-        label_class ||= options.delete(:label_class)
-        label_class = hide_class if options.delete(:hide_label)
+    def draw_input_group_content(bootstrap_options, type)
+      value = bootstrap_options[type]
+      return unless value.present?
 
-        if options[:label].is_a?(String)
-          label_text ||= options.delete(:label)
+      content_tag(:div, class: "input-group-#{type}") do
+        if value.is_a?(Hash) && value[:html].present?
+          value[:html]
+        else
+          content_tag(:span, value, class: "input-group-text")
         end
-
-        form_group_options.merge!(label: {
-          text: label_text,
-          class: label_class,
-          skip_required: options.delete(:skip_required)
-        })
-      end
-
-      form_group(method, form_group_options) do
-        yield
       end
     end
 
-    def convert_form_tag_options(method, options = {})
-      options[:name] ||= method
-      options[:id] ||= method
-      options
+    # Drawing boostrap form field help text. Example usage:
+    #
+    #   text_field(:value, bootstrap: {help: "help text"})
+    #
+    def draw_help(text)
+      return if text.blank?
+      content_tag(:small, text, class: "form-text text-muted")
     end
 
-    def generate_label(id, name, options, custom_label_col, group_layout)
-      options[:for] = id if acts_like_form_tag
-      classes = [options[:class], label_class]
-      classes << (custom_label_col || label_col) if get_group_layout(group_layout) == :horizontal
-      unless options.delete(:skip_required)
-        classes << "required" if required_attribute?(object, name)
-      end
+    # Rendering of choices for checkboxes and radio buttons
+    def draw_choices(bootstrap_options, method, collection, value_method, text_method, options, html_options, &input)
+      add_css_class!(html_options, "form-check-input")
 
-      options[:class] = classes.compact.join(" ")
+      draw_form_group_fieldset(bootstrap_options, method, html_options) do
 
-      if label_errors && has_error?(name)
-        error_messages = get_error_messages(name)
-        label_text = (options[:text] || object.class.human_attribute_name(name)).to_s.concat(" #{error_messages}")
-        label(name, label_text, options.except(:text))
-      else
-        label(name, options[:text], options.except(:text))
-      end
+        form_check_css_class = "form-check"
+        form_check_css_class << " form-check-inline" if bootstrap_options[:inline]
 
-    end
+        errors    = draw_errors(method)
+        help_text = draw_help(bootstrap_options[:help])
 
-    def generate_help(name, help_text)
-      if has_error?(name) && inline_errors
-        help_text = get_error_messages(name)
-        help_klass = 'invalid-feedback'
-      end
-      return if help_text == false
+        add_css_class!(html_options, "is-invalid") if errors.present?
 
-      help_klass ||= 'form-text text-muted'
-      help_text ||= get_help_text_by_i18n_key(name)
+        content = "".html_safe
+        collection.each_with_index.map do |item, index|
+          item_value  = item.send(value_method)
+          item_text   = item.send(text_method)
 
-      content_tag(:span, help_text, class: help_klass) if help_text.present?
-    end
+          content << content_tag(:div, class: form_check_css_class) do
+            concat input.call(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]
+              concat errors     if errors.present?
+              concat help_text  if help_text.present?
+            end
+          end
+        end
 
-    def generate_icon(icon)
-      content_tag(:span, "", class: "glyphicon glyphicon-#{icon} form-control-feedback")
-    end
+        if bootstrap_options[:inline]
+          content << errors     if errors.present?
+          content << help_text  if help_text.present?
+        end
 
-    def get_error_messages(name)
-      object.errors[name].join(", ")
+        content
+      end
     end
 
-    def inputs_collection(name, collection, value, text, options = {}, &block)
-      form_group_builder(name, options) do
-        inputs = ""
+    # Wrapper for collections of radio buttons and checkboxes
+    def draw_form_group_fieldset(bootstrap_options, method, options, &block)
+      bootstrap_label_options = bootstrap_options[:label] || {}
 
-        collection.each do |obj|
-          input_options = options.merge(label: text.respond_to?(:call) ? text.call(obj) : obj.send(text))
+      unless bootstrap_label_options[:hide]
+        label_text = bootstrap_label_options.delete(:text)
+        label_text ||= ActionView::Helpers::Tags::Label::LabelBuilder
+          .new(@template, @object_name.to_s, method, @object, nil).translation
 
-          input_value = value.respond_to?(:call) ? value.call(obj) : obj.send(value)
-          if checked = input_options[:checked]
-            input_options[:checked] = checked == input_value                     ||
-                                      Array(checked).try(:include?, input_value) ||
-                                      checked == obj                             ||
-                                      Array(checked).try(:include?, obj)
-          end
+        add_css_class!(bootstrap_label_options, "col-form-label pt-0")
 
-          input_options.delete(:class)
-          inputs << block.call(name, input_value, input_options)
+        if bootstrap.horizontal?
+          add_css_class!(bootstrap_label_options, bootstrap.label_col_class)
+          add_css_class!(bootstrap_label_options, bootstrap.label_align_class)
         end
 
-        inputs.html_safe
+        label = content_tag(:legend, bootstrap_label_options) do
+          label_text
+        end
       end
-    end
 
-    def get_help_text_by_i18n_key(name)
-      if object
+      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
+          yield
+        end
 
-        if object.class.respond_to?(:model_name)
-          # ActiveModel::Naming 3.X.X does not support .name; it is supported as of 4.X.X
-          partial_scope = object.class.model_name.respond_to?(:name) ? object.class.model_name.name : object.class.model_name
+        if bootstrap.horizontal?
+          content_tag(:div, content, class: "row")
         else
-          partial_scope = object.class.name
+          content
         end
-
-        underscored_scope = "activerecord.help.#{partial_scope.underscore}"
-        downcased_scope = "activerecord.help.#{partial_scope.downcase}"
-        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
       end
     end
 
+    def add_css_class!(options, string)
+      css_class = [options[:class], string].compact.join(" ")
+      options[:class] = css_class if css_class.present?
+    end
+
+    def remove_css_class!(options, string)
+      css_class = options[:class].to_s.split(" ")
+      options[:class] = (css_class - [string]).compact.join(" ")
+      options.delete(:class) if options[:class].blank?
+    end
+
   end
+
 end