simple_form 2.1.0 → 3.2.0

data/test/inputs/required_test.rb

@@ -2,43 +2,43 @@ require 'test_helper'
 
 class RequiredTest < ActionView::TestCase
   # REQUIRED AND PRESENCE VALIDATION
-  test 'builder input should obtain required from ActiveModel::Validations when it is included' do
+  test 'builder input obtains required from ActiveModel::Validations when it is included' do
     with_form_for @validating_user, :name
     assert_select 'input.required[required]#validating_user_name'
     with_form_for @validating_user, :status
     assert_select 'input.optional#validating_user_status'
   end
 
-  test 'builder input should allow overriding required when ActiveModel::Validations is included' do
-    with_form_for @validating_user, :name, :required => false
+  test 'builder input allows overriding required when ActiveModel::Validations is included' do
+    with_form_for @validating_user, :name, required: false
     assert_select 'input.optional#validating_user_name'
-    with_form_for @validating_user, :status, :required => true
+    with_form_for @validating_user, :status, required: true
     assert_select 'input.required[required]#validating_user_status'
   end
 
-  test 'builder input should be required by default when ActiveModel::Validations is not included' do
+  test 'builder input is required by default when ActiveModel::Validations is not included' do
     with_form_for @user, :name
     assert_select 'input.required[required]#user_name'
   end
 
-  test 'builder input should not be required by default when ActiveModel::Validations is not included if option is set to false' do
-    swap SimpleForm, :required_by_default => false do
+  test 'builder input does not be required by default when ActiveModel::Validations is not included if option is set to false' do
+    swap SimpleForm, required_by_default: false do
       with_form_for @user, :name
       assert_select 'input.optional#user_name'
       assert_no_select 'input[required]'
     end
   end
 
-  test 'when not using browser validations, input should not generate required html attribute' do
-    swap SimpleForm, :browser_validations => false do
+  test 'when not using browser validations, input does not generate required html attribute' do
+    swap SimpleForm, browser_validations: false do
       with_input_for @user, :name, :string
       assert_select 'input[type=text].required'
       assert_no_select 'input[type=text][required]'
     end
   end
 
-  test 'builder input should allow disabling required when ActiveModel::Validations is not included' do
-    with_form_for @user, :name, :required => false
+  test 'builder input allows disabling required when ActiveModel::Validations is not included' do
+    with_form_for @user, :name, required: false
     assert_no_select 'input.required'
     assert_no_select 'input[required]'
     assert_select 'input.optional#user_name'
@@ -53,14 +53,14 @@ class RequiredTest < ActionView::TestCase
   end
 
   # VALIDATORS :if :unless
-  test 'builder input should not be required when ActiveModel::Validations is included and if option is present' do
+  test 'builder input does not be required when ActiveModel::Validations is included and if option is present' do
     with_form_for @validating_user, :age
     assert_no_select 'input.required'
     assert_no_select 'input[required]'
     assert_select 'input.optional#validating_user_age'
   end
 
-  test 'builder input should not be required when ActiveModel::Validations is included and unless option is present' do
+  test 'builder input does not be required when ActiveModel::Validations is included and unless option is present' do
     with_form_for @validating_user, :amount
     assert_no_select 'input.required'
     assert_no_select 'input[required]'
@@ -68,7 +68,7 @@ class RequiredTest < ActionView::TestCase
   end
 
   # VALIDATORS :on
-  test 'builder input should be required when validation is on create and is not persisted' do
+  test 'builder input is required when validation is on create and is not persisted' do
     @validating_user.new_record!
     with_form_for @validating_user, :action
     assert_select 'input.required'
@@ -76,14 +76,14 @@ class RequiredTest < ActionView::TestCase
     assert_select 'input.required[required]#validating_user_action'
   end
 
-  test 'builder input should not be required when validation is on create and is persisted' do
+  test 'builder input does not be required when validation is on create and is persisted' do
     with_form_for @validating_user, :action
     assert_no_select 'input.required'
     assert_no_select 'input[required]'
     assert_select 'input.optional#validating_user_action'
   end
 
-  test 'builder input should be required when validation is on save' do
+  test 'builder input is required when validation is on save' do
     with_form_for @validating_user, :credit_limit
     assert_select 'input.required'
     assert_select 'input[required]'
@@ -96,18 +96,30 @@ class RequiredTest < ActionView::TestCase
     assert_select 'input.required[required]#validating_user_credit_limit'
   end
 
-  test 'builder input should be required when validation is on update and is persisted' do
+  test 'builder input is required when validation is on update and is persisted' do
     with_form_for @validating_user, :phone_number
     assert_select 'input.required'
     assert_select 'input[required]'
     assert_select 'input.required[required]#validating_user_phone_number'
   end
 
-  test 'builder input should not be required when validation is on update and is not persisted' do
+  test 'builder input does not be required when validation is on update and is not persisted' do
     @validating_user.new_record!
     with_form_for @validating_user, :phone_number
     assert_no_select 'input.required'
     assert_no_select 'input[required]'
     assert_select 'input.optional#validating_user_phone_number'
   end
+
+  test 'builder input does not generate required html attribute when option is set to false when it is set to true in wrapper' do
+    swap SimpleForm, browser_validations: true do
+      swap_wrapper :default, self.custom_wrapper_with_required_input do
+        with_concat_form_for(@user) do |f|
+          concat f.input :name, required: false
+        end
+        assert_no_select 'input[type=text][required]'
+        assert_no_select 'input[type=text][aria-required]'
+      end
+    end
+  end
 end

data/test/inputs/string_input_test.rb

@@ -2,126 +2,127 @@
 require 'test_helper'
 
 class StringInputTest < ActionView::TestCase
-  test 'input should map text field to string attribute' do
+  test 'input maps text field to string attribute' do
     with_input_for @user, :name, :string
-    assert_select "input#user_name[type=text][name='user[name]'][value=New in SimpleForm!]"
+    assert_select "input#user_name[type=text][name='user[name]'][value='New in SimpleForm!']"
   end
 
-  test 'input should generate a password field for password attributes' do
+  test 'input generates a password field for password attributes' do
     with_input_for @user, :password, :password
     assert_select "input#user_password.password[type=password][name='user[password]']"
   end
 
-  test 'input should not use size attribute for decimal attributes' do
-    with_input_for @user, :credit_limit, :decimal
-    assert_no_select 'input.decimal[size]'
-  end
-
-  test 'input should get maxlength from column definition for string attributes' do
+  test 'input gets maxlength from column definition for string attributes' do
     with_input_for @user, :name, :string
-    assert_select 'input.string[maxlength=100]'
+    assert_select 'input.string[maxlength="100"]'
   end
 
-  test 'input should not get maxlength from column without size definition for string attributes' do
+  test 'input does not get maxlength from column without size definition for string attributes' do
     with_input_for @user, :action, :string
     assert_no_select 'input.string[maxlength]'
   end
 
-  test 'input should get size from column definition for string attributes respecting maximum value' do
-    with_input_for @user, :name, :string
-    assert_select 'input.string[size=50]'
-  end
-
-  test 'input should use default text size for password attributes' do
-    with_input_for @user, :password, :password
-    assert_select 'input.password[type=password][size=50]'
-  end
-
-  test 'input should get maxlength from column definition for password attributes' do
+  test 'input gets maxlength from column definition for password attributes' do
     with_input_for @user, :password, :password
-    assert_select 'input.password[type=password][maxlength=100]'
+    assert_select 'input.password[type=password][maxlength="100"]'
   end
 
-  test 'input should infer maxlength column definition from validation when present' do
+  test 'input infers maxlength column definition from validation when present' do
     with_input_for @validating_user, :name, :string
-    assert_select 'input.string[maxlength=25]'
+    assert_select 'input.string[maxlength="25"]'
   end
 
-  test 'input should not get maxlength from validation when tokenizer present' do
+  test 'input does not get maxlength from validation when tokenizer present' do
     with_input_for @validating_user, :action, :string
     assert_no_select 'input.string[maxlength]'
   end
 
-  test 'input should get maxlength from validation when :is option present' do
+  test 'input gets maxlength from validation when :is option present' do
     with_input_for @validating_user, :home_picture, :string
-    assert_select 'input.string[maxlength=12]'
+    assert_select 'input.string[maxlength="12"]'
   end
 
-  test 'input size and maxlength should be the column limit plus one to make room for decimal point' do
+  test 'input maxlength is the column limit plus one to make room for decimal point' do
     with_input_for @user, :credit_limit, :string
 
-    assert_select "input.string[maxlength=16][size=16]"
+    assert_select 'input.string[maxlength="16"]'
   end
 
-  test 'input should not generate placeholder by default' do
+  test 'input does not generate placeholder by default' do
     with_input_for @user, :name, :string
     assert_no_select 'input[placeholder]'
   end
 
-  test 'input should accept the placeholder option' do
-    with_input_for @user, :name, :string, :placeholder => 'Put in some text'
-    assert_select 'input.string[placeholder=Put in some text]'
+  test 'input accepts the placeholder option' do
+    with_input_for @user, :name, :string, placeholder: 'Put in some text'
+    assert_select 'input.string[placeholder="Put in some text"]'
   end
 
-  test 'input should generate a password field for password attributes that accept placeholder' do
-    with_input_for @user, :password, :password, :placeholder => 'Password Confirmation'
-    assert_select 'input[type=password].password[placeholder=Password Confirmation]#user_password'
+  test 'input generates a password field for password attributes that accept placeholder' do
+    with_input_for @user, :password, :password, placeholder: 'Password Confirmation'
+    assert_select 'input[type=password].password[placeholder="Password Confirmation"]#user_password'
   end
 
-  test 'input should not infer pattern from attributes by default' do
+  test 'input does not infer pattern from attributes by default' do
     with_input_for @other_validating_user, :country, :string
     assert_no_select 'input[pattern="\w+"]'
   end
 
-  test 'input should infer pattern from attributes' do
-    with_input_for @other_validating_user, :country, :string, :pattern => true
+  test 'input infers pattern from attributes' do
+    with_input_for @other_validating_user, :country, :string, pattern: true
     assert_select 'input[pattern="\w+"]'
   end
 
-  test 'input should infer pattern from attributes using proc' do
-    with_input_for @other_validating_user, :name, :string, :pattern => true
+  test 'input infers pattern from attributes using proc' do
+    with_input_for @other_validating_user, :name, :string, pattern: true
     assert_select 'input[pattern="\w+"]'
   end
 
-  test 'input should not infer pattern from attributes if root default is false' do
+  test 'input does not infer pattern from attributes if root default is false' do
     swap_wrapper do
       with_input_for @other_validating_user, :country, :string
       assert_no_select 'input[pattern="\w+"]'
     end
   end
 
-  test 'input should use given pattern from attributes' do
-    with_input_for @other_validating_user, :country, :string, :input_html => { :pattern => "\\d+" }
+  test 'input uses given pattern from attributes' do
+    with_input_for @other_validating_user, :country, :string, input_html: { pattern: "\\d+" }
     assert_select 'input[pattern="\d+"]'
   end
 
-  test 'input should use i18n to translate placeholder text' do
-    store_translations(:en, :simple_form => { :placeholders => { :user => {
-      :name => 'Name goes here'
+  test 'input does not use pattern if model has :without validation option' do
+    with_input_for @other_validating_user, :description, :string, pattern: true
+    assert_no_select 'input[pattern="\d+"]'
+  end
+
+  test 'input uses i18n to translate placeholder text' do
+    store_translations(:en, simple_form: { placeholders: { user: {
+      name: 'Name goes here'
     } } }) do
       with_input_for @user, :name, :string
-      assert_select 'input.string[placeholder=Name goes here]'
+      assert_select 'input.string[placeholder="Name goes here"]'
+    end
+  end
+
+  test 'input uses custom i18n scope to translate placeholder text' do
+    store_translations(:en, my_scope: { placeholders: { user: {
+      name: 'Name goes here'
+    } } }) do
+      swap SimpleForm, i18n_scope: :my_scope do
+        with_input_for @user, :name, :string
+        assert_select 'input.string[placeholder="Name goes here"]'
+      end
     end
   end
 
   [:email, :url, :search, :tel].each do |type|
-    test "input should allow type #{type}" do
+    test "input allows type #{type}" do
       with_input_for @user, :name, type
       assert_select "input.string.#{type}"
       assert_select "input[type=#{type}]"
     end
 
-    test "input should not allow type #{type} if HTML5 compatibility is disabled" do
+    test "input does not allow type #{type} if HTML5 compatibility is disabled" do
       swap_wrapper do
         with_input_for @user, :name, type
         assert_select "input[type=text]"
@@ -138,7 +139,7 @@ class StringInputTest < ActionView::TestCase
   end
 
   test 'input strips extra spaces from class html attribute when giving a custom class' do
-    with_input_for @user, :name, :string, :input_html => { :class => "my_input" }
+    with_input_for @user, :name, :string, input_html: { class: "my_input" }
     assert_select "input[class='string required my_input']"
     assert_no_select "input[class='string required my_input ']"
     assert_no_select "input[class=' string required my_input']"

data/test/inputs/text_input_test.rb

@@ -2,23 +2,30 @@
 require 'test_helper'
 
 class TextInputTest < ActionView::TestCase
-  test 'input should generate a text area for text attributes' do
+  test 'input generates a text area for text attributes' do
     with_input_for @user, :description, :text
     assert_select 'textarea.text#user_description'
   end
 
-  test 'input should generate a text area for text attributes that accept placeholder' do
-    with_input_for @user, :description, :text, :placeholder => 'Put in some text'
-    assert_select 'textarea.text[placeholder=Put in some text]'
+  test 'input generates a text area for text attributes that accept placeholder' do
+    with_input_for @user, :description, :text, placeholder: 'Put in some text'
+    assert_select 'textarea.text[placeholder="Put in some text"]'
   end
 
-  test 'input should get maxlength from column definition for text attributes' do
+  test 'input generates a placeholder from the translations' do
+    store_translations(:en, simple_form: { placeholders: { user: { name: "placeholder from i18n en.simple_form.placeholders.user.name" } } }) do
+      with_input_for @user, :name, :text
+      assert_select 'textarea.text[placeholder="placeholder from i18n en.simple_form.placeholders.user.name"]'
+    end
+  end
+
+  test 'input gets maxlength from column definition for text attributes' do
     with_input_for @user, :description, :text
-    assert_select 'textarea.text[maxlength=200]'
+    assert_select 'textarea.text[maxlength="200"]'
   end
 
-  test 'input should infer maxlength column definition from validation when present for text attributes' do
+  test 'input infers maxlength column definition from validation when present for text attributes' do
     with_input_for @validating_user, :description, :text
-    assert_select 'textarea.text[maxlength=50]'
+    assert_select 'textarea.text[maxlength="50"]'
   end
 end

data/test/simple_form_test.rb

@@ -6,4 +6,12 @@ class SimpleFormTest < ActiveSupport::TestCase
       assert_equal SimpleForm, config
     end
   end
+
+  test 'setup block configure Simple Form' do
+    SimpleForm.setup do |config|
+      assert_equal SimpleForm, config
+    end
+
+    assert_equal true, SimpleForm.configured?
+  end
 end

data/test/support/discovery_inputs.rb

@@ -1,16 +1,26 @@
 class StringInput < SimpleForm::Inputs::StringInput
-  def input
+  def input(wrapper_options = nil)
     "<section>#{super}</section>".html_safe
   end
 end
 
 class NumericInput < SimpleForm::Inputs::NumericInput
-  def input
+  def input(wrapper_options = nil)
     "<section>#{super}</section>".html_safe
   end
 end
 
 class CustomizedInput < SimpleForm::Inputs::StringInput
+  def input(wrapper_options = nil)
+    "<section>#{super}</section>".html_safe
+  end
+
+  def input_method
+    :text_field
+  end
+end
+
+class DeprecatedInput < SimpleForm::Inputs::StringInput
   def input
     "<section>#{super}</section>".html_safe
   end
@@ -25,3 +35,23 @@ class CollectionSelectInput < SimpleForm::Inputs::CollectionSelectInput
     super.push('chosen')
   end
 end
+
+module CustomInputs
+  class CustomizedInput < SimpleForm::Inputs::StringInput
+    def input_html_classes
+      super.push('customized-namespace-custom-input')
+    end
+  end
+
+  class PasswordInput < SimpleForm::Inputs::PasswordInput
+    def input_html_classes
+      super.push('password-custom-input')
+    end
+  end
+
+  class NumericInput < SimpleForm::Inputs::PasswordInput
+    def input_html_classes
+      super.push('numeric-custom-input')
+    end
+  end
+end

data/test/support/misc_helpers.rb

@@ -8,7 +8,7 @@ module MiscHelpers
   end
 
   def assert_no_select(selector, value = nil)
-    assert_select(selector, :text => value, :count => 0)
+    assert_select(selector, text: value, count: 0)
   end
 
   def swap(object, new_values)
@@ -24,78 +24,179 @@ module MiscHelpers
     end
   end
 
-  def swap_wrapper(name=:default, wrapper=self.custom_wrapper)
-    old = SimpleForm.wrappers[name]
-    SimpleForm.wrappers[name] = wrapper
+  def stub_any_instance(klass, method, value)
+    klass.class_eval do
+      alias_method :"new_#{method}", method
+
+      define_method(method) do
+        if value.respond_to?(:call)
+          value.call
+        else
+          value
+        end
+      end
+    end
+
     yield
   ensure
-    SimpleForm.wrappers[name] = old
+    klass.class_eval do
+      undef_method method
+      alias_method method, :"new_#{method}"
+      undef_method :"new_#{method}"
+    end
+  end
+
+  def swap_wrapper(name = :default, wrapper = custom_wrapper)
+    old = SimpleForm.wrappers[name.to_s]
+    SimpleForm.wrappers[name.to_s] = wrapper
+    yield
+  ensure
+    SimpleForm.wrappers[name.to_s] = old
   end
 
   def custom_wrapper
-    SimpleForm.build :tag => :section, :class => "custom_wrapper", :pattern => false do |b|
+    SimpleForm.build tag: :section, class: "custom_wrapper", pattern: false do |b|
       b.use :pattern
-      b.wrapper :another, :class => "another_wrapper" do |ba|
+      b.wrapper :another, class: "another_wrapper" do |ba|
         ba.use :label
         ba.use :input
       end
-      b.wrapper :error_wrapper, :tag => :div, :class => "error_wrapper" do |be|
-        be.use :error, :wrap_with => { :tag => :span, :class => "omg_error" }
+      b.wrapper :error_wrapper, tag: :div, class: "error_wrapper" do |be|
+        be.use :error, wrap_with: { tag: :span, class: "omg_error" }
+      end
+      b.use :hint, wrap_with: { class: "omg_hint" }
+    end
+  end
+
+  def custom_wrapper_with_wrapped_optional_component
+    SimpleForm.build tag: :section, class: "custom_wrapper" do |b|
+      b.wrapper tag: :div, class: 'no_output_wrapper' do |ba|
+        ba.optional :hint, wrap_with: { tag: :p, class: 'omg_hint' }
       end
-      b.use :hint, :wrap_with => { :class => "omg_hint" }
+    end
+  end
+
+  def custom_wrapper_with_unless_blank
+    SimpleForm.build tag: :section, class: "custom_wrapper" do |b|
+      b.wrapper tag: :div, class: 'no_output_wrapper', unless_blank: true do |ba|
+        ba.optional :hint, wrap_with: { tag: :p, class: 'omg_hint' }
+      end
+    end
+  end
+
+  def custom_wrapper_with_input_class
+    SimpleForm.build tag: :div, class: "custom_wrapper" do |b|
+      b.use :label
+      b.use :input, class: 'inline-class'
+    end
+  end
+
+  def custom_wrapper_with_label_class
+    SimpleForm.build tag: :div, class: "custom_wrapper" do |b|
+      b.use :label, class: 'inline-class'
+      b.use :input
+    end
+  end
+
+  def custom_wrapper_with_input_attributes
+    SimpleForm.build tag: :div, class: "custom_wrapper" do |b|
+      b.use :input, data: { modal: true }
+    end
+  end
+
+  def custom_wrapper_with_label_input_class
+    SimpleForm.build tag: :div, class: "custom_wrapper" do |b|
+      b.use :label_input, class: 'inline-class'
     end
   end
 
   def custom_wrapper_with_wrapped_input
-    SimpleForm.build :tag => :div, :class => "custom_wrapper" do |b|
-      b.wrapper :tag => :div, :class => 'elem' do |component|
+    SimpleForm.build tag: :div, class: "custom_wrapper" do |b|
+      b.wrapper tag: :div, class: 'elem' do |component|
         component.use :label
-        component.use :input, :wrap_with => { :tag => :div, :class => 'input' }
+        component.use :input, wrap_with: { tag: :div, class: 'input' }
       end
     end
   end
 
   def custom_wrapper_with_wrapped_label
-    SimpleForm.build :tag => :div, :class => "custom_wrapper" do |b|
-      b.wrapper :tag => :div, :class => 'elem' do |component|
-        component.use :label, :wrap_with => { :tag => :div, :class => 'label' }
+    SimpleForm.build tag: :div, class: "custom_wrapper" do |b|
+      b.wrapper tag: :div, class: 'elem' do |component|
+        component.use :label, wrap_with: { tag: :div, class: 'label' }
         component.use :input
       end
     end
   end
 
   def custom_wrapper_without_top_level
-    SimpleForm.build :tag => false, :class => 'custom_wrapper_without_top_level' do |b|
+    SimpleForm.build tag: false, class: 'custom_wrapper_without_top_level' do |b|
       b.use :label_input
-      b.use :hint,  :wrap_with => { :tag => :span, :class => :hint }
-      b.use :error, :wrap_with => { :tag => :span, :class => :error }
+      b.use :hint,  wrap_with: { tag: :span, class: :hint }
+      b.use :error, wrap_with: { tag: :span, class: :error }
     end
   end
 
   def custom_wrapper_without_class
-    SimpleForm.build :tag => :div, :wrapper_html => { :id => 'custom_wrapper_without_class' } do |b|
+    SimpleForm.build tag: :div, wrapper_html: { id: 'custom_wrapper_without_class' } do |b|
       b.use :label_input
     end
   end
 
   def custom_wrapper_with_label_html_option
-    SimpleForm.build :tag => :div, :class => "custom_wrapper", :label_html => { :class => 'extra-label-class' } do |b|
+    SimpleForm.build tag: :div, class: "custom_wrapper", label_html: { class: 'extra-label-class' } do |b|
       b.use :label_input
     end
   end
 
   def custom_wrapper_with_wrapped_label_input
-    SimpleForm.build :tag => :section, :class => "custom_wrapper", :pattern => false do |b|
-      b.use :label_input, :wrap_with => { :tag => :div, :class => :field }
+    SimpleForm.build tag: :section, class: "custom_wrapper", pattern: false do |b|
+      b.use :label_input, wrap_with: { tag: :div, class: :field }
+    end
+  end
+
+  def custom_wrapper_with_additional_attributes
+    SimpleForm.build tag: :div, class: 'custom_wrapper', html: { data: { wrapper: :test }, title: 'some title' } do |b|
+      b.use :label_input
+    end
+  end
+
+  def custom_wrapper_with_full_error
+    SimpleForm.build tag: :div, class: 'custom_wrapper' do |b|
+      b.use :full_error,  wrap_with: { tag: :span, class: :error }
+    end
+  end
+
+  def custom_wrapper_with_label_text
+    SimpleForm.build :label_text => proc { |label, required| "**#{label}**" } do |b|
+      b.use :label_input
+    end
+  end
+
+  def custom_wrapper_with_custom_label_component
+    SimpleForm.build tag: :span, class: 'custom_wrapper' do |b|
+      b.use :label_text
+    end
+  end
+
+  def custom_wrapper_with_html5_components
+    SimpleForm.build tag: :span, class: 'custom_wrapper' do |b|
+      b.use :label_text
+    end
+  end
+
+  def custom_wrapper_with_required_input
+    SimpleForm.build tag: :span, class: 'custom_wrapper' do |b|
+      b.use :html5
+      b.use :input, required: true
     end
   end
 
   def custom_form_for(object, *args, &block)
-    simple_form_for(object, *(args << { :builder => CustomFormBuilder }), &block)
+    simple_form_for(object, *args, { builder: CustomFormBuilder }, &block)
   end
 
   def custom_mapping_form_for(object, *args, &block)
-    simple_form_for(object, *(args << { :builder => CustomMapTypeFormBuilder }), &block)
+    simple_form_for(object, *args, { builder: CustomMapTypeFormBuilder }, &block)
   end
 
   def with_concat_form_for(*args, &block)
@@ -120,19 +221,19 @@ module MiscHelpers
     end
   end
 
-  def with_input_for(object, attribute_name, type, options={})
+  def with_input_for(object, attribute_name, type, options = {})
     with_concat_form_for(object) do |f|
-      f.input(attribute_name, options.merge(:as => type))
+      f.input(attribute_name, options.merge(as: type))
     end
   end
 end
 
 class CustomFormBuilder < SimpleForm::FormBuilder
   def input(attribute_name, *args, &block)
-    super(attribute_name, *(args << { :input_html => { :class => 'custom' } }), &block)
+    super(attribute_name, *args, { input_html: { class: 'custom' } }, &block)
   end
 end
 
 class CustomMapTypeFormBuilder < SimpleForm::FormBuilder
-  map_type :custom_type, :to => SimpleForm::Inputs::StringInput
+  map_type :custom_type, to: SimpleForm::Inputs::StringInput
 end