simple_form 3.0.1 → 4.0.0

data/lib/simple_form/form_builder.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'active_support/core_ext/object/deep_dup'
 require 'simple_form/map_type'
 require 'simple_form/tags'
@@ -8,28 +9,29 @@ module SimpleForm
 
     # When action is create or update, we still should use new and edit
     ACTIONS = {
-      create: :new,
-      update: :edit
+      'create' => 'new',
+      'update' => 'edit'
     }
 
-    ATTRIBUTE_COMPONENTS = [:html5, :min_max, :maxlength, :placeholder, :pattern, :readonly]
+    ATTRIBUTE_COMPONENTS = %i[html5 min_max maxlength minlength placeholder pattern readonly]
 
     extend MapType
     include SimpleForm::Inputs
 
-    map_type :text,                                to: SimpleForm::Inputs::TextInput
-    map_type :file,                                to: SimpleForm::Inputs::FileInput
-    map_type :string, :email, :search, :tel, :url, to: SimpleForm::Inputs::StringInput
-    map_type :password,                            to: SimpleForm::Inputs::PasswordInput
-    map_type :integer, :decimal, :float,           to: SimpleForm::Inputs::NumericInput
-    map_type :range,                               to: SimpleForm::Inputs::RangeInput
-    map_type :check_boxes,                         to: SimpleForm::Inputs::CollectionCheckBoxesInput
-    map_type :radio_buttons,                       to: SimpleForm::Inputs::CollectionRadioButtonsInput
-    map_type :select,                              to: SimpleForm::Inputs::CollectionSelectInput
-    map_type :grouped_select,                      to: SimpleForm::Inputs::GroupedCollectionSelectInput
-    map_type :date, :time, :datetime,              to: SimpleForm::Inputs::DateTimeInput
-    map_type :country, :time_zone,                 to: SimpleForm::Inputs::PriorityInput
-    map_type :boolean,                             to: SimpleForm::Inputs::BooleanInput
+    map_type :text, :hstore, :json, :jsonb,                        to: SimpleForm::Inputs::TextInput
+    map_type :file,                                                to: SimpleForm::Inputs::FileInput
+    map_type :string, :email, :search, :tel, :url, :uuid, :citext, to: SimpleForm::Inputs::StringInput
+    map_type :password,                                            to: SimpleForm::Inputs::PasswordInput
+    map_type :integer, :decimal, :float,                           to: SimpleForm::Inputs::NumericInput
+    map_type :range,                                               to: SimpleForm::Inputs::RangeInput
+    map_type :check_boxes,                                         to: SimpleForm::Inputs::CollectionCheckBoxesInput
+    map_type :radio_buttons,                                       to: SimpleForm::Inputs::CollectionRadioButtonsInput
+    map_type :select,                                              to: SimpleForm::Inputs::CollectionSelectInput
+    map_type :grouped_select,                                      to: SimpleForm::Inputs::GroupedCollectionSelectInput
+    map_type :date, :time, :datetime,                              to: SimpleForm::Inputs::DateTimeInput
+    map_type :country, :time_zone,                                 to: SimpleForm::Inputs::PriorityInput
+    map_type :boolean,                                             to: SimpleForm::Inputs::BooleanInput
+    map_type :hidden,                                              to: SimpleForm::Inputs::HiddenInput
 
     def self.discovery_cache
       @discovery_cache ||= {}
@@ -37,6 +39,7 @@ module SimpleForm
 
     def initialize(*) #:nodoc:
       super
+      @object   = convert_to_model(@object)
       @defaults = options[:defaults]
       @wrapper  = SimpleForm.wrapper(options[:wrapper] || SimpleForm.default_wrapper)
     end
@@ -47,6 +50,11 @@ module SimpleForm
     # label + input + hint (when defined) + errors (when exists), and all can
     # be configured inside a wrapper html.
     #
+    # If a block is given, the contents of the block will replace the input
+    # field that would otherwise be generated automatically. The content will
+    # be given a label and wrapper div to make it consistent with the other
+    # elements in the form.
+    #
     # == Examples
     #
     #   # Imagine @user has error "can't be blank" on name
@@ -106,18 +114,13 @@ module SimpleForm
     # Some inputs, as :time_zone and :country accepts a :priority option. If none is
     # given SimpleForm.time_zone_priority and SimpleForm.country_priority are used respectively.
     #
-    def input(attribute_name, options={}, &block)
+    def input(attribute_name, options = {}, &block)
       options = @defaults.deep_dup.deep_merge(options) if @defaults
-      input = find_input(attribute_name, options, &block)
 
-      chosen =
-        if name = options[:wrapper] || find_wrapper_mapping(input.input_type)
-          name.respond_to?(:render) ? name : SimpleForm.wrapper(name)
-        else
-          wrapper
-        end
+      input   = find_input(attribute_name, options, &block)
+      wrapper = find_wrapper(input.input_type, options)
 
-      chosen.render input
+      wrapper.render input
     end
     alias :attribute :input
 
@@ -135,12 +138,41 @@ module SimpleForm
     #     <input class="string required" id="user_name" maxlength="100"
     #        name="user[name]" type="text" value="Carlos" />
     #
-    def input_field(attribute_name, options={})
+    # It also support validation classes once it is configured.
+    #
+    #   # config/initializers/simple_form.rb
+    #   SimpleForm.setup do |config|
+    #     config.input_field_valid_class = 'is-valid'
+    #     config.input_field_error_class = 'is-invalid'
+    #   end
+    #
+    #   simple_form_for @user do |f|
+    #     f.input_field :name
+    #   end
+    #
+    # When the validation happens, the input will be rendered with
+    # the class configured according to the validation:
+    #
+    # - when the input is valid:
+    #
+    #     <input class="is-valid string required" id="user_name" value="Carlos" />
+    #
+    # - when the input is invalid:
+    #
+    #     <input class="is-invalid string required" id="user_name" value="" />
+    #
+    def input_field(attribute_name, options = {})
+      components = (wrapper.components.map(&:namespace) & ATTRIBUTE_COMPONENTS)
+
       options = options.dup
-      options[:input_html] = options.except(:as, :collection, :label_method, :value_method, *ATTRIBUTE_COMPONENTS)
+      options[:input_html] = options.except(:as, :boolean_style, :collection, :label_method, :value_method, :prompt, *components)
       options = @defaults.deep_dup.deep_merge(options) if @defaults
 
-      SimpleForm::Wrappers::Root.new(ATTRIBUTE_COMPONENTS + [:input], wrapper: false).render find_input(attribute_name, options)
+      input      = find_input(attribute_name, options)
+      wrapper    = find_wrapper(input.input_type, options)
+      components = build_input_field_components(components.push(:input))
+
+      SimpleForm::Wrappers::Root.new(components, wrapper.options.merge(wrapper: false)).render input
     end
 
     # Helper for dealing with association selects/radios, generating the
@@ -171,7 +203,7 @@ module SimpleForm
     #
     # Please note that the association helper is currently only tested with Active Record. Depending on the ORM you are using your mileage may vary.
     #
-    def association(association, options={}, &block)
+    def association(association, options = {}, &block)
       options = options.dup
 
       return simple_fields_for(*[association,
@@ -183,31 +215,9 @@ module SimpleForm
       raise "Association #{association.inspect} not found" unless reflection
 
       options[:as] ||= :select
-      options[:collection] ||= options.fetch(:collection) {
-        conditions = reflection.options[:conditions]
-        conditions = conditions.call if conditions.respond_to?(:call)
-        reflection.klass.where(conditions).order(reflection.options[:order])
-      }
-
-      attribute = case reflection.macro
-        when :belongs_to
-          (reflection.respond_to?(:options) && reflection.options[:foreign_key]) || :"#{reflection.name}_id"
-        when :has_one
-          raise ArgumentError, ":has_one associations are not supported by f.association"
-        else
-          if options[:as] == :select
-            html_options = options[:input_html] ||= {}
-            html_options[:multiple] = true unless html_options.key?(:multiple)
-          end
-
-          # Force the association to be preloaded for performance.
-          if options[:preload] != false && object.respond_to?(association)
-            target = object.send(association)
-            target.to_a if target.respond_to?(:to_a)
-          end
+      options[:collection] ||= fetch_association_collection(reflection, options)
 
-          :"#{reflection.name.to_s.singularize}_ids"
-      end
+      attribute = build_association_attribute(reflection, association, options)
 
       input(attribute, options.merge(reflection: reflection))
     end
@@ -227,8 +237,8 @@ module SimpleForm
       options = args.extract_options!.dup
       options[:class] = [SimpleForm.button_class, options[:class]].compact
       args << options
-      if respond_to?("#{type}_button")
-        send("#{type}_button", *args, &block)
+      if respond_to?(:"#{type}_button")
+        send(:"#{type}_button", *args, &block)
       else
         send(type, *args, &block)
       end
@@ -242,7 +252,7 @@ module SimpleForm
     #    f.error :name
     #    f.error :name, id: "cool_error"
     #
-    def error(attribute_name, options={})
+    def error(attribute_name, options = {})
       options = options.dup
 
       options[:error_html] = options.except(:error_tag, :error_prefix, :error_method)
@@ -259,7 +269,7 @@ module SimpleForm
     #
     #    f.full_error :token #=> <span class="error">Token is invalid</span>
     #
-    def full_error(attribute_name, options={})
+    def full_error(attribute_name, options = {})
       options = options.dup
 
       options[:error_prefix] ||= if object.class.respond_to?(:human_attribute_name)
@@ -281,7 +291,7 @@ module SimpleForm
     #    f.hint :name, id: "cool_hint"
     #    f.hint "Don't forget to accept this"
     #
-    def hint(attribute_name, options={})
+    def hint(attribute_name, options = {})
       options = options.dup
 
       options[:hint_html] = options.except(:hint_tag, :hint)
@@ -305,7 +315,7 @@ module SimpleForm
     #
     #    f.label :name                     # Do I18n lookup
     #    f.label :name, "Name"             # Same behavior as Rails, do not add required tag
-    #    f.label :name, label: "Name"   # Same as above, but adds required tag
+    #    f.label :name, label: "Name"      # Same as above, but adds required tag
     #
     #    f.label :name, required: false
     #    f.label :name, id: "cool_label"
@@ -314,7 +324,7 @@ module SimpleForm
       return super if args.first.is_a?(String) || block_given?
 
       options = args.extract_options!.dup
-      options[:label_html] = options.except(:label, :required, :as)
+      options[:label_html] = options.except(:label, :label_text, :required, :as)
 
       column      = find_attribute_column(attribute_name)
       input_type  = default_input_type(attribute_name, column, options)
@@ -332,7 +342,7 @@ module SimpleForm
     #    f.error_notification message: 'Something went wrong'
     #    f.error_notification id: 'user_error_message', class: 'form_error'
     #
-    def error_notification(options={})
+    def error_notification(options = {})
       SimpleForm::ErrorNotification.new(self, options).render
     end
 
@@ -464,15 +474,60 @@ module SimpleForm
       @lookup_action ||= begin
         action = template.controller && template.controller.action_name
         return unless action
-        action = action.to_sym
+        action = action.to_s
         ACTIONS[action] || action
       end
     end
 
     private
 
+    def fetch_association_collection(reflection, options)
+      options.fetch(:collection) do
+        relation = reflection.klass.all
+
+        if reflection.respond_to?(:scope) && reflection.scope
+          if reflection.scope.parameters.any?
+            relation = reflection.klass.instance_exec(object, &reflection.scope)
+          else
+            relation = reflection.klass.instance_exec(&reflection.scope)
+          end
+        else
+          order = reflection.options[:order]
+          conditions = reflection.options[:conditions]
+          conditions = object.instance_exec(&conditions) if conditions.respond_to?(:call)
+
+          relation = relation.where(conditions) if relation.respond_to?(:where)
+          relation = relation.order(order) if relation.respond_to?(:order)
+        end
+
+        relation
+      end
+    end
+
+    def build_association_attribute(reflection, association, options)
+      case reflection.macro
+      when :belongs_to
+        (reflection.respond_to?(:options) && reflection.options[:foreign_key]) || :"#{reflection.name}_id"
+      when :has_one
+        raise ArgumentError, ":has_one associations are not supported by f.association"
+      else
+        if options[:as] == :select
+          html_options = options[:input_html] ||= {}
+          html_options[:multiple] = true unless html_options.key?(:multiple)
+        end
+
+        # Force the association to be preloaded for performance.
+        if options[:preload] != false && object.respond_to?(association)
+          target = object.send(association)
+          target.to_a if target.respond_to?(:to_a)
+        end
+
+        :"#{reflection.name.to_s.singularize}_ids"
+      end
+    end
+
     # Find an input based on the attribute name.
-    def find_input(attribute_name, options={}, &block) #:nodoc:
+    def find_input(attribute_name, options = {}, &block)
       column     = find_attribute_column(attribute_name)
       input_type = default_input_type(attribute_name, column, options)
 
@@ -484,18 +539,18 @@ module SimpleForm
     end
 
     # Attempt to guess the better input type given the defined options. By
-    # default alwayls fallback to the user :as option, or to a :select when a
+    # default always fallback to the user :as option, or to a :select when a
     # collection is given.
-    def default_input_type(attribute_name, column, options) #:nodoc:
+    def default_input_type(attribute_name, column, options)
       return options[:as].to_sym if options[:as]
-      return :select             if options[:collection]
       custom_type = find_custom_type(attribute_name.to_s) and return custom_type
+      return :select             if options[:collection]
 
       input_type = column.try(:type)
       case input_type
       when :timestamp
         :datetime
-      when :string, nil
+      when :string, :citext, nil
         case attribute_name.to_s
         when /password/  then :password
         when /time_zone/ then :time_zone
@@ -511,24 +566,26 @@ module SimpleForm
       end
     end
 
-    def find_custom_type(attribute_name) #:nodoc:
+    def find_custom_type(attribute_name)
       SimpleForm.input_mappings.find { |match, type|
         attribute_name =~ match
       }.try(:last) if SimpleForm.input_mappings
     end
 
-    def file_method?(attribute_name) #:nodoc:
+    def file_method?(attribute_name)
       file = @object.send(attribute_name) if @object.respond_to?(attribute_name)
       file && SimpleForm.file_methods.any? { |m| file.respond_to?(m) }
     end
 
-    def find_attribute_column(attribute_name) #:nodoc:
-      if @object.respond_to?(:column_for_attribute)
+    def find_attribute_column(attribute_name)
+      if @object.respond_to?(:type_for_attribute) && @object.has_attribute?(attribute_name)
+        @object.type_for_attribute(attribute_name.to_s)
+      elsif @object.respond_to?(:column_for_attribute) && @object.has_attribute?(attribute_name)
         @object.column_for_attribute(attribute_name)
       end
     end
 
-    def find_association_reflection(association) #:nodoc:
+    def find_association_reflection(association)
       if @object.class.respond_to?(:reflect_on_association)
         @object.class.reflect_on_association(association)
       end
@@ -541,24 +598,42 @@ module SimpleForm
     #    b) Or use the found mapping
     # 2) If not, fallbacks to #{input_type}Input
     # 3) If not, fallbacks to SimpleForm::Inputs::#{input_type}Input
-    def find_mapping(input_type) #:nodoc:
+    def find_mapping(input_type)
       discovery_cache[input_type] ||=
         if mapping = self.class.mappings[input_type]
           mapping_override(mapping) || mapping
         else
           camelized = "#{input_type.to_s.camelize}Input"
-          attempt_mapping(camelized, Object) || attempt_mapping(camelized, self.class) ||
+          attempt_mapping_with_custom_namespace(camelized) ||
+            attempt_mapping(camelized, Object) ||
+            attempt_mapping(camelized, self.class) ||
             raise("No input found for #{input_type}")
         end
     end
 
-    def find_wrapper_mapping(input_type) #:nodoc:
-      SimpleForm.wrapper_mappings && SimpleForm.wrapper_mappings[input_type]
+    # Attempts to find a wrapper mapping. It follows the following rules:
+    #
+    # 1) It tries to find a wrapper for the current form
+    # 2) If not, it tries to find a config
+    def find_wrapper_mapping(input_type)
+      if options[:wrapper_mappings] && options[:wrapper_mappings][input_type]
+        options[:wrapper_mappings][input_type]
+      else
+        SimpleForm.wrapper_mappings && SimpleForm.wrapper_mappings[input_type]
+      end
+    end
+
+    def find_wrapper(input_type, options)
+      if name = options[:wrapper] || find_wrapper_mapping(input_type)
+        name.respond_to?(:render) ? name : SimpleForm.wrapper(name)
+      else
+        wrapper
+      end
     end
 
     # If cache_discovery is enabled, use the class level cache that persists
     # between requests, otherwise use the instance one.
-    def discovery_cache #:nodoc:
+    def discovery_cache
       if SimpleForm.cache_discovery
         self.class.discovery_cache
       else
@@ -566,14 +641,16 @@ module SimpleForm
       end
     end
 
-    def mapping_override(klass) #:nodoc:
+    def mapping_override(klass)
       name = klass.name
       if name =~ /^SimpleForm::Inputs/
-        attempt_mapping name.split("::").last, Object
+        input_name = name.split("::").last
+        attempt_mapping_with_custom_namespace(input_name) ||
+          attempt_mapping(input_name, Object)
       end
     end
 
-    def attempt_mapping(mapping, at) #:nodoc:
+    def attempt_mapping(mapping, at)
       return if SimpleForm.inputs_discovery == false && at == Object
 
       begin
@@ -582,5 +659,41 @@ module SimpleForm
         raise if e.message !~ /#{mapping}$/
       end
     end
+
+    def attempt_mapping_with_custom_namespace(input_name)
+      SimpleForm.custom_inputs_namespaces.each do |namespace|
+        if (mapping = attempt_mapping(input_name, namespace.constantize))
+          return mapping
+        end
+      end
+
+      nil
+    end
+
+    def build_input_field_components(components)
+      components.map do |component|
+        if component == :input
+          SimpleForm::Wrappers::Leaf.new(component, build_input_field_options)
+        else
+          SimpleForm::Wrappers::Leaf.new(component)
+        end
+      end
+    end
+
+    def build_input_field_options
+      input_field_options = {}
+      valid_class         = SimpleForm.input_field_valid_class
+      error_class         = SimpleForm.input_field_error_class
+
+      if error_class.present?
+        input_field_options[:error_class] = error_class
+      end
+
+      if valid_class.present?
+        input_field_options[:valid_class] = valid_class
+      end
+
+      input_field_options
+    end
   end
 end

data/lib/simple_form/helpers/autofocus.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SimpleForm
   module Helpers
     module Autofocus

data/lib/simple_form/helpers/disabled.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SimpleForm
   module Helpers
     module Disabled

data/lib/simple_form/helpers/readonly.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SimpleForm
   module Helpers
     module Readonly

data/lib/simple_form/helpers/required.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SimpleForm
   module Helpers
     module Required

data/lib/simple_form/helpers/validators.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SimpleForm
   module Helpers
     module Validators
@@ -24,7 +25,7 @@ module SimpleForm
       end
 
       def action_validator_match?(validator)
-        return true if !validator.options.include?(:on)
+        return true unless validator.options.include?(:on)
 
         case validator.options[:on]
         when :save

data/lib/simple_form/helpers.rb

@@ -1,12 +1,13 @@
+# frozen_string_literal: true
 module SimpleForm
   # Helpers are made of several helpers that cannot be turned on automatically.
   # For instance, disabled cannot be turned on automatically, it requires the
   # user to explicitly pass the option disabled: true so it may work.
   module Helpers
-    autoload :Autofocus,    'simple_form/helpers/autofocus'
-    autoload :Disabled,     'simple_form/helpers/disabled'
-    autoload :Readonly,     'simple_form/helpers/readonly'
-    autoload :Required,     'simple_form/helpers/required'
-    autoload :Validators,   'simple_form/helpers/validators'
+    autoload :Autofocus,  'simple_form/helpers/autofocus'
+    autoload :Disabled,   'simple_form/helpers/disabled'
+    autoload :Readonly,   'simple_form/helpers/readonly'
+    autoload :Required,   'simple_form/helpers/required'
+    autoload :Validators, 'simple_form/helpers/validators'
   end
 end

data/lib/simple_form/i18n_cache.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SimpleForm
   # A lot of configuration values are retrived from I18n,
   # like boolean collection, required string. This module provides

data/lib/simple_form/inputs/base.rb

@@ -1,10 +1,13 @@
+# frozen_string_literal: true
 require 'simple_form/i18n_cache'
 require 'active_support/core_ext/string/output_safety'
+require 'action_view/helpers'
 
 module SimpleForm
   module Inputs
     class Base
       include ERB::Util
+      include ActionView::Helpers::TranslationHelper
 
       extend I18nCache
 
@@ -19,6 +22,7 @@ module SimpleForm
       include SimpleForm::Components::HTML5
       include SimpleForm::Components::LabelInput
       include SimpleForm::Components::Maxlength
+      include SimpleForm::Components::Minlength
       include SimpleForm::Components::MinMax
       include SimpleForm::Components::Pattern
       include SimpleForm::Components::Placeholders
@@ -48,19 +52,19 @@ module SimpleForm
       enable :hint
 
       # Usually disabled, needs to be enabled explicitly passing true as option.
-      disable :maxlength, :placeholder, :pattern, :min_max
+      disable :maxlength, :minlength, :placeholder, :pattern, :min_max
 
       def initialize(builder, attribute_name, column, input_type, options = {})
         super
 
-        options             = options.dup
-        @builder            = builder
-        @attribute_name     = attribute_name
-        @column             = column
-        @input_type         = input_type
-        @reflection         = options.delete(:reflection)
-        @options            = options.reverse_merge!(self.class.default_options)
-        @required           = calculate_required
+        options         = options.dup
+        @builder        = builder
+        @attribute_name = attribute_name
+        @column         = column
+        @input_type     = input_type
+        @reflection     = options.delete(:reflection)
+        @options        = options.reverse_merge!(self.class.default_options)
+        @required       = calculate_required
 
         # Notice that html_options_for receives a reference to input_html_classes.
         # This means that classes added dynamically to input_html_classes will
@@ -79,7 +83,7 @@ module SimpleForm
         end
       end
 
-      def input
+      def input(wrapper_options = nil)
         raise NotImplementedError
       end
 
@@ -92,7 +96,7 @@ module SimpleForm
       end
 
       def input_class
-        "#{lookup_model_names.join("_")}_#{reflection_or_attribute_name}"
+        "#{lookup_model_names.join('_')}_#{reflection_or_attribute_name}"
       end
 
       private
@@ -113,7 +117,7 @@ module SimpleForm
       end
 
       def decimal_or_float?
-        column.number? && column.type != :integer
+        column.type == :float || column.type == :decimal
       end
 
       def nested_boolean_style?
@@ -167,7 +171,7 @@ module SimpleForm
       #            email: 'E-mail.'
       #
       #  Take a look at our locale example file.
-      def translate(namespace, default='')
+      def translate_from_namespace(namespace, default = '')
         model_names = lookup_model_names.dup
         lookups     = []
 
@@ -182,7 +186,46 @@ module SimpleForm
         lookups << :"defaults.#{reflection_or_attribute_name}"
         lookups << default
 
-        I18n.t(lookups.shift, scope: :"simple_form.#{namespace}", default: lookups).presence
+        I18n.t(lookups.shift, scope: :"#{i18n_scope}.#{namespace}", default: lookups).presence
+      end
+
+      def merge_wrapper_options(options, wrapper_options)
+        if wrapper_options
+          wrapper_options = set_input_classes(wrapper_options)
+
+          wrapper_options.merge(options) do |key, oldval, newval|
+            case key.to_s
+            when "class"
+              Array(oldval) + Array(newval)
+            when "data", "aria"
+              oldval.merge(newval)
+            else
+              newval
+            end
+          end
+        else
+          options
+        end
+      end
+
+      def set_input_classes(wrapper_options)
+        wrapper_options = wrapper_options.dup
+        error_class     = wrapper_options.delete(:error_class)
+        valid_class     = wrapper_options.delete(:valid_class)
+
+        if error_class.present? && has_errors?
+          wrapper_options[:class] = "#{wrapper_options[:class]} #{error_class}"
+        end
+
+        if valid_class.present? && valid?
+          wrapper_options[:class] = "#{wrapper_options[:class]} #{valid_class}"
+        end
+
+        wrapper_options
+      end
+
+      def i18n_scope
+        SimpleForm.i18n_scope
       end
     end
   end

data/lib/simple_form/inputs/block_input.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module SimpleForm
   module Inputs
     class BlockInput < Base
@@ -6,7 +7,7 @@ module SimpleForm
         @block = block
       end
 
-      def input
+      def input(wrapper_options = nil)
         template.capture(&@block)
       end
     end