bootstrap_form_legacy 4.0.1.dev

data/demo/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the Rails application.
+require_relative 'application'
+
+# Initialize the Rails application.
+Rails.application.initialize!

data/demo/config/environments/development.rb

@@ -0,0 +1,60 @@
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # In the development environment your application's code is reloaded on
+  # every request. This slows down response time but is perfect for development
+  # since you don't have to restart the web server when you make code changes.
+  config.cache_classes = false
+
+  # Do not eager load code on boot.
+  config.eager_load = false
+
+  # Show full error reports.
+  config.consider_all_requests_local = true
+
+  # Enable/disable caching. By default caching is disabled.
+  # Run rails dev:cache to toggle caching.
+  if Rails.root.join('tmp/caching-dev.txt').exist?
+    config.action_controller.perform_caching = true
+
+    config.cache_store = :memory_store
+    config.public_file_server.headers = {
+      'Cache-Control' => "public, max-age=#{2.days.to_i}"
+    }
+  else
+    config.action_controller.perform_caching = false
+
+    config.cache_store = :null_store
+  end
+
+  # Store uploaded files on the local file system (see config/storage.yml for options)
+  if config.respond_to?(:active_storage)
+    config.active_storage.service = :local
+  end
+
+  # Don't care if the mailer can't send.
+  config.action_mailer.raise_delivery_errors = false
+
+  config.action_mailer.perform_caching = false
+
+  # Print deprecation notices to the Rails logger.
+  config.active_support.deprecation = :log
+
+  # Raise an error on page load if there are pending migrations.
+  config.active_record.migration_error = :page_load
+
+  # Debug mode disables concatenation and preprocessing of assets.
+  # This option may cause significant delays in view rendering with a large
+  # number of complex assets.
+  config.assets.debug = true
+
+  # Suppress logger output for asset requests.
+  config.assets.quiet = true
+
+  # Raises error for missing translations
+  # config.action_view.raise_on_missing_translations = true
+
+  # Use an evented file watcher to asynchronously detect changes in source code,
+  # routes, locales, etc. This feature depends on the listen gem.
+  # config.file_watcher = ActiveSupport::EventedFileUpdateChecker
+end

data/demo/config/environments/test.rb

@@ -0,0 +1,48 @@
+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
+  # test suite. You never need to work with it otherwise. Remember that
+  # your test database is "scratch space" for the test suite and is wiped
+  # and recreated between test runs. Don't rely on the data there!
+  config.cache_classes = true
+
+  # Do not eager load code on boot. This avoids loading your whole application
+  # just for the purpose of running a single test. If you are using a tool that
+  # preloads Rails for running tests, you may have to set it to true.
+  config.eager_load = false
+
+  # 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
+  config.action_controller.perform_caching = false
+
+  # Raise exceptions instead of rendering exception templates.
+  config.action_dispatch.show_exceptions = false
+
+  # 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.
+  config.action_mailer.delivery_method = :test
+
+  # Print deprecation notices to the stderr.
+  config.active_support.deprecation = :stderr
+
+  # 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/backtrace_silencers.rb

@@ -0,0 +1,7 @@
+# Be sure to restart your server when you modify this file.
+
+# You can add backtrace silencers for libraries that you're using but don't wish to see in your backtraces.
+# Rails.backtrace_cleaner.add_silencer { |line| line =~ /my_noisy_library/ }
+
+# You can also remove all the silencers if you're trying to debug a problem that might stem from framework code.
+# Rails.backtrace_cleaner.remove_silencers!

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/demo/config/initializers/filter_parameter_logging.rb

@@ -0,0 +1,4 @@
+# Be sure to restart your server when you modify this file.
+
+# Configure sensitive parameters which will be filtered from the log file.
+Rails.application.config.filter_parameters += [:password]

data/demo/config/initializers/inflections.rb

@@ -0,0 +1,16 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format. Inflections
+# are locale specific, and you may define rules for as many different
+# locales as you wish. All of these examples are active by default:
+# ActiveSupport::Inflector.inflections(:en) do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end
+
+# These inflection rules are supported but not enabled by default:
+# ActiveSupport::Inflector.inflections(:en) do |inflect|
+#   inflect.acronym 'RESTful'
+# end

data/demo/config/initializers/mime_types.rb

@@ -0,0 +1,4 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new mime types for use in respond_to blocks:
+# Mime::Type.register "text/richtext", :rtf

data/demo/config/initializers/wrap_parameters.rb

@@ -0,0 +1,14 @@
+# Be sure to restart your server when you modify this file.
+
+# This file contains settings for ActionController::ParamsWrapper which
+# is enabled by default.
+
+# 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]
+end
+
+# To enable root element in JSON for ActiveRecord objects.
+# ActiveSupport.on_load(:active_record) do
+#   self.include_root_in_json = true
+# end

data/demo/config/locales/en.yml

@@ -0,0 +1,33 @@
+# Files in the config/locales directory are used for internationalization
+# and are automatically loaded by Rails. If you want to use locales other
+# than English, add the necessary files in this directory.
+#
+# To use the locales, use `I18n.t`:
+#
+#     I18n.t 'hello'
+#
+# In views, this is aliased to just `t`:
+#
+#     <%= t('hello') %>
+#
+# To use a different locale, set it with `I18n.locale`:
+#
+#     I18n.locale = :es
+#
+# 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.
+
+en:
+  hello: "Hello world"

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/demo/config/routes.rb

@@ -0,0 +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,24 @@
+ActiveRecord::Schema.define(version: 1) do
+
+  create_table :addresses, force: :cascade do |t|
+    t.integer :user_id
+    t.string  :street
+    t.string  :city
+    t.string  :state
+    t.string  :zip_code
+    t.timestamps
+  end
+
+  create_table :users, force: :cascade do |t|
+    t.string  :email
+    t.string  :password
+    t.text    :comments
+    t.string  :status
+    t.string  :misc
+    t.text    :preferences
+    t.boolean :terms, default: false
+    t.string  :type
+    t.timestamps
+  end
+
+end

data/demo/package.json

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

data/lib/bootstrap_form.rb

@@ -0,0 +1,13 @@
+require 'bootstrap_form/form_builder'
+require 'bootstrap_form/helper'
+
+module BootstrapForm
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end
+
+ActiveSupport.on_load(:action_view) do
+  include BootstrapForm::Helper
+end

data/lib/bootstrap_form/aliasing.rb

@@ -0,0 +1,35 @@
+module BootstrapForm
+  # This module implements the old ActiveSupport alias_method_chain feature
+  # with a new name, and without the deprecation warnings. In ActiveSupport 5+,
+  # this style of patching was deprecated in favor of Module.prepend. But
+  # Module.prepend is not present in Ruby 1.9, which we would still like to
+  # support. So we continue to use of alias_method_chain, albeit with a
+  # different name to avoid collisions.
+  module Aliasing
+    # This code is copied and pasted from ActiveSupport, but with :bootstrap
+    # hardcoded as the feature name, and with the deprecation warning removed.
+    def bootstrap_method_alias(target)
+      feature = :bootstrap
+
+      # Strip out punctuation on predicates, bang or writer methods since
+      # e.g. target?_without_feature is not a valid method name.
+      aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+      yield(aliased_target, punctuation) if block_given?
+
+      with_method = "#{aliased_target}_with_#{feature}#{punctuation}"
+      without_method = "#{aliased_target}_without_#{feature}#{punctuation}"
+
+      alias_method without_method, target
+      alias_method target, with_method
+
+      case
+      when public_method_defined?(without_method)
+        public target
+      when protected_method_defined?(without_method)
+        protected target
+      when private_method_defined?(without_method)
+        private target
+      end
+    end
+  end
+end

data/lib/bootstrap_form/form_builder.rb

@@ -0,0 +1,564 @@
+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
+
+    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}
+
+    DATE_SELECT_HELPERS = %w{date_select time_select datetime_select}
+
+    delegate :content_tag, :capture, :concat, to: :@template
+
+    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
+      end
+
+      super
+    end
+
+    FIELD_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 = {}|
+        form_group_builder(name, options) do
+          send(without_method_name, name, options)
+        end
+      end
+
+      bootstrap_method_alias method_name
+    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 = {}|
+        prevent_prepend_and_append!(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))
+        end
+      end
+
+      bootstrap_method_alias method_name
+    end
+
+    def file_field_with_bootstrap(name, options = {})
+      prevent_prepend_and_append!(options)
+      options = options.reverse_merge(control_class: "custom-file-input")
+      form_group_builder(name, options) do
+        content_tag(:div, class: "custom-file") do
+          placeholder = options.delete(:placeholder) || "Choose file"
+          placeholder_opts = { class: "custom-file-label" }
+          placeholder_opts[:for] = options[:id] if options[:id].present?
+
+          input = file_field_without_bootstrap(name, options)
+          placeholder_label = label(name, placeholder, placeholder_opts)
+          concat(input)
+          concat(placeholder_label)
+        end
+      end
+    end
+
+    bootstrap_method_alias :file_field
+
+    def select_with_bootstrap(method, choices = nil, options = {}, html_options = {}, &block)
+      form_group_builder(method, options, html_options) do
+        select_without_bootstrap(method, choices, options, html_options, &block)
+      end
+    end
+
+    bootstrap_method_alias :select
+
+    def collection_select_with_bootstrap(method, collection, value_method, text_method, options = {}, html_options = {})
+      prevent_prepend_and_append!(options)
+      form_group_builder(method, options, html_options) do
+        collection_select_without_bootstrap(method, collection, value_method, text_method, options, html_options)
+      end
+    end
+
+    bootstrap_method_alias :collection_select
+
+    def grouped_collection_select_with_bootstrap(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
+      prevent_prepend_and_append!(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)
+      end
+    end
+
+    bootstrap_method_alias :grouped_collection_select
+
+    def time_zone_select_with_bootstrap(method, priority_zones = nil, options = {}, html_options = {})
+      prevent_prepend_and_append!(options)
+      form_group_builder(method, options, html_options) do
+        time_zone_select_without_bootstrap(method, priority_zones, options, html_options)
+      end
+    end
+
+    bootstrap_method_alias :time_zone_select
+
+    def check_box_with_bootstrap(name, options = {}, checked_value = "1", unchecked_value = "0", &block)
+      prevent_prepend_and_append!(options)
+      options = options.symbolize_keys!
+      check_box_options = options.except(:label, :label_class, :help, :inline, :custom, :hide_label, :skip_label)
+      check_box_classes = [check_box_options[:class]]
+      check_box_classes << "position-static" if options[:skip_label] || options[:hide_label]
+      if options[:custom]
+        validation = nil
+        validation = "is-invalid" if has_error?(name)
+        check_box_options[:class] = (["custom-control-input", validation] + check_box_classes).compact.join(' ')
+      else
+        check_box_options[:class] = (["form-check-input"] + check_box_classes).compact.join(' ')
+      end
+
+      checkbox_html = check_box_without_bootstrap(name, check_box_options, checked_value, unchecked_value)
+      label_content = block_given? ? capture(&block) : options[:label]
+      label_description = 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/5-0-stable/actionview/lib/action_view/helpers/tags/base.rb#L123-L125
+      if options[:multiple]
+        label_name =
+          "#{name}_#{checked_value.to_s.gsub(/\s/, "_").gsub(/[^-[[:word:]]]/, "").mb_chars.downcase.to_s}"
+      end
+
+      label_classes = [options[:label_class]]
+      label_classes << hide_class if options[:hide_label]
+
+      if options[:custom]
+        div_class = ["custom-control", "custom-checkbox"]
+        div_class.append("custom-control-inline") if layout_inline?(options[:inline])
+        label_class = label_classes.prepend("custom-control-label").compact.join(" ")
+        content_tag(:div, class: div_class.compact.join(" ")) do
+          if options[:skip_label]
+            checkbox_html
+          else
+            # TODO: Notice we don't seem to pass the ID into the custom control.
+            checkbox_html.concat(label(label_name, label_description, class: label_class))
+          end
+        end
+      else
+        wrapper_class = "form-check"
+        wrapper_class += " form-check-inline" if layout_inline?(options[:inline])
+        label_class = label_classes.prepend("form-check-label").compact.join(" ")
+        content_tag(:div, class: wrapper_class) do
+          if options[:skip_label]
+            checkbox_html
+          else
+            checkbox_html
+              .concat(label(label_name,
+                            label_description,
+                            { class: label_class }.merge(options[:id].present? ? { for: options[:id] } : {})))
+          end
+        end
+      end
+    end
+
+    bootstrap_method_alias :check_box
+
+    def radio_button_with_bootstrap(name, value, *args)
+      prevent_prepend_and_append!(options)
+      options = args.extract_options!.symbolize_keys!
+      radio_options = options.except(:label, :label_class, :help, :inline, :custom, :hide_label, :skip_label)
+      radio_classes = [options[:class]]
+      radio_classes << "position-static" if options[:skip_label] || options[:hide_label]
+      if options[:custom]
+        radio_options[:class] = radio_classes.prepend("custom-control-input").compact.join(' ')
+      else
+        radio_options[:class] = radio_classes.prepend("form-check-input").compact.join(' ')
+      end
+      args << radio_options
+      radio_html = radio_button_without_bootstrap(name, value, *args)
+
+      disabled_class = " disabled" if options[:disabled]
+      label_classes  = [options[:label_class]]
+      label_classes << hide_class if options[:hide_label]
+
+      if options[:custom]
+        div_class = ["custom-control", "custom-radio"]
+        div_class.append("custom-control-inline") if layout_inline?(options[:inline])
+        label_class = label_classes.prepend("custom-control-label").compact.join(" ")
+        content_tag(:div, class: div_class.compact.join(" ")) do
+          if options[:skip_label]
+            radio_html
+          else
+            # TODO: Notice we don't seem to pass the ID into the custom control.
+            radio_html.concat(label(name, options[:label], value: value, class: label_class))
+          end
+        end
+      else
+        wrapper_class = "form-check"
+        wrapper_class += " form-check-inline" if layout_inline?(options[:inline])
+        label_class = label_classes.prepend("form-check-label").compact.join(" ")
+        content_tag(:div, class: "#{wrapper_class}#{disabled_class}") do
+          if options[:skip_label]
+            radio_html
+          else
+            radio_html
+              .concat(label(name, options[:label], { value: value, class: label_class }.merge(options[:id].present? ? { for: options[:id] } : {})))
+          end
+        end
+      end
+    end
+
+    bootstrap_method_alias :radio_button
+
+    def collection_check_boxes_with_bootstrap(*args)
+      prevent_prepend_and_append!(options)
+      html = inputs_collection(*args) do |name, value, options|
+        options[:multiple] = true
+        check_box(name, options, value, nil)
+      end
+      hidden_field(args.first,{value: "", multiple: true}).concat(html)
+    end
+
+    bootstrap_method_alias :collection_check_boxes
+
+    def collection_radio_buttons_with_bootstrap(*args)
+      prevent_prepend_and_append!(options)
+      inputs_collection(*args) do |name, value, options|
+        radio_button(name, value, options)
+      end
+    end
+
+    bootstrap_method_alias :collection_radio_buttons
+
+    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] << " form-inline" if field_inline_override?(options[:layout])
+      options[:class] << " #{feedback_class}" if options[:icon]
+
+      content_tag(:div, options.except(:append, :id, :label, :help, :icon, :input_group_class, :label_col, :control_col, :layout, :prepend)) do
+        label = generate_label(options[:id], name, options[:label], options[:label_col], options[:layout]) if options[:label]
+        control = prepend_and_append_input(name, options, &block).to_s
+
+        help = options[:help]
+        help_text = generate_help(name, help).to_s
+
+        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 + help_text, class: control_class)
+          concat(label).concat(control)
+        else
+          concat(label).concat(control).concat(help_text)
+        end
+      end
+    end
+
+    def fields_for_with_bootstrap(record_name, record_object = nil, fields_options = {}, &block)
+      if record_object.is_a?(Hash) && record_object.extractable_options?
+        fields_options = record_object
+        record_object = nil
+      end
+      fields_options[:layout] ||= options[:layout]
+      fields_options[:label_col] = fields_options[:label_col].present? ? "#{fields_options[:label_col]}" : options[:label_col]
+      fields_options[: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
+
+    bootstrap_method_alias :fields_for
+
+    # the Rails `fields` method passes its options
+    # to the builder, so there is no need to write a `bootstrap_form` helper
+    # for the `fields` method.
+
+    private
+
+    def layout_default?(field_layout = nil)
+      [:default, nil].include? layout_in_effect(field_layout)
+    end
+
+    def layout_horizontal?(field_layout = nil)
+      layout_in_effect(field_layout) == :horizontal
+    end
+
+    def layout_inline?(field_layout = nil)
+      layout_in_effect(field_layout) == :inline
+    end
+
+    def field_inline_override?(field_layout = nil)
+      field_layout == :inline && layout != :inline
+    end
+
+    # true and false should only come from check_box and radio_button,
+    # and those don't have a :horizontal layout
+    def layout_in_effect(field_layout)
+      field_layout = :inline if field_layout == true
+      field_layout = :default if field_layout == false
+      field_layout || layout
+    end
+
+    def get_group_layout(group_layout)
+      group_layout || layout
+    end
+
+    def default_label_col
+      "col-sm-2"
+    end
+
+    def offset_col(label_col)
+      label_col.sub(/^col-(\w+)-(\d)$/, 'offset-\1-\2')
+    end
+
+    def default_control_col
+      "col-sm-10"
+    end
+
+    def hide_class
+      "sr-only" # still accessible for screen readers
+    end
+
+    def control_class
+      "form-control"
+    end
+
+    def feedback_class
+      "has-feedback"
+    end
+
+    def control_specific_class(method)
+      "rails-bootstrap-forms-#{method.gsub(/_/, "-")}"
+    end
+
+    def has_error?(name)
+      object.respond_to?(:errors) && !(name.nil? || object.errors[name].empty?)
+    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)
+      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)
+
+      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
+      }
+
+      form_group_options[:append] = options.delete(:append) if options[:append]
+      form_group_options[:prepend] = options.delete(:prepend) if options[:prepend]
+      form_group_options[:input_group_class] = options.delete(:input_group_class) if options[:input_group_class]
+
+      if wrapper_options.is_a?(Hash)
+        form_group_options.merge!(wrapper_options)
+      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)
+
+        if options[:label].is_a?(String)
+          label_text ||= options.delete(:label)
+        end
+
+        form_group_options[:label] = {
+          text: label_text,
+          class: label_class,
+          required: options[:required],
+          skip_required: options.delete(:skip_required)
+        }.merge(css_options[:id].present? ? { for: css_options[:id] } : {})
+      end
+
+      form_group(method, form_group_options) do
+        yield
+      end
+    end
+
+    def convert_form_tag_options(method, options = {})
+      unless @options[:skip_default_ids]
+        options[:name] ||= method
+        options[:id] ||= method
+      end
+      options
+    end
+
+    def generate_label(id, name, options, custom_label_col, group_layout)
+      classes = [options[:class]]
+
+      if layout_horizontal?(group_layout)
+        classes << "col-form-label"
+        classes << (custom_label_col || label_col)
+      elsif layout_inline?(group_layout)
+        classes << "mr-sm-2"
+      end
+
+      unless options.delete(:skip_required)
+        classes << "required" if options.delete(:required) || required_attribute?(object, name)
+      end
+
+      options[:class] = classes.compact.join(" ").strip
+      options.delete(:class) if options[:class].empty?
+
+      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}")
+        options[:class] = [options[:class], "text-danger"].compact.join(" ")
+        label(name, label_text, options.except(:text))
+      else
+        label(name, options[:text], options.except(:text))
+      end
+    end
+
+    def has_inline_error?(name)
+      has_error?(name) && inline_errors
+    end
+
+    def generate_error(name)
+      if has_inline_error?(name)
+        help_text = get_error_messages(name)
+        help_klass = 'invalid-feedback'
+        help_tag = :div
+
+        content_tag(help_tag, help_text, class: help_klass)
+      end
+    end
+
+    def generate_help(name, help_text)
+      return if help_text == false || has_inline_error?(name)
+
+      help_klass ||= 'form-text text-muted'
+      help_text ||= get_help_text_by_i18n_key(name)
+      help_tag ||= :small
+
+      content_tag(help_tag, help_text, class: help_klass) if help_text.present?
+    end
+
+    def get_error_messages(name)
+      object.errors[name].join(", ")
+    end
+
+    def inputs_collection(name, collection, value, text, options = {}, &block)
+      options[:inline] ||= layout_inline?(options[:layout])
+      form_group_builder(name, options) do
+        inputs = ""
+
+        collection.each do |obj|
+          input_options = options.merge(label: text.respond_to?(:call) ? text.call(obj) : obj.send(text))
+
+          input_value = value.respond_to?(:call) ? value.call(obj) : obj.send(value)
+          if checked = input_options[:checked]
+            input_options[:checked] = checked == input_value                     ||
+                                      Array(checked).try(:include?, input_value) ||
+                                      checked == obj                             ||
+                                      Array(checked).try(:include?, obj)
+          end
+          
+          if disabled = input_options[:disabled]
+            input_options[:disabled] = if disabled.is_a?(Array)
+                                          disabled.include?(input_value)
+                                       else
+                                          disabled
+                                       end
+          end
+
+          input_options.delete(:class)
+          inputs << block.call(name, input_value, input_options)
+        end
+
+        inputs.html_safe
+      end
+    end
+
+    def get_help_text_by_i18n_key(name)
+      if object
+
+        if object.class.respond_to?(:model_name)
+          partial_scope = object.class.model_name.name
+        else
+          partial_scope = object.class.name
+        end
+
+        underscored_scope = "activerecord.help.#{partial_scope.underscore}"
+        downcased_scope = "activerecord.help.#{partial_scope.downcase}"
+        # First check for a subkey :html, as it is also accepted by i18n, and the simple check for name would return an hash instead of a string (both with .presence returning true!)
+        help_text = I18n.t("#{name}.html", scope: underscored_scope, default: '').html_safe.presence
+        help_text ||= if text = I18n.t("#{name}.html", scope: downcased_scope, default: '').html_safe.presence
+                        warn "I18n key '#{downcased_scope}.#{name}' is deprecated, use '#{underscored_scope}.#{name}' instead"
+                        text
+                      end
+        help_text ||= I18n.t(name, scope: underscored_scope, default: '').presence
+        help_text ||= if text = I18n.t(name, scope: downcased_scope, default: '').presence
+                        warn "I18n key '#{downcased_scope}.#{name}' is deprecated, use '#{underscored_scope}.#{name}' instead"
+                        text
+                      end
+        help_text ||= I18n.t("#{name}_html", scope: underscored_scope, default: '').html_safe.presence
+        help_text ||= if text = I18n.t("#{name}_html", scope: downcased_scope, default: '').html_safe.presence
+                        warn "I18n key '#{downcased_scope}.#{name}' is deprecated, use '#{underscored_scope}.#{name}' instead"
+                        text
+                      end
+        help_text
+      end
+    end
+  end
+end