simple_form 2.1.3 → 3.0.0

data/test/inputs/collection_select_input_test.rb

@@ -14,7 +14,7 @@ class CollectionSelectInputTest < ActionView::TestCase
   end
 
   test 'input as select should use i18n to translate select boolean options' do
-    store_translations(:en, :simple_form => { :yes => 'Sim', :no => 'Não' }) do
+    store_translations(:en, simple_form: { yes: 'Sim', no: 'Não' }) do
       with_input_for @user, :active, :select
       assert_select 'select option[value=true]', 'Sim'
       assert_select 'select option[value=false]', 'Não'
@@ -22,17 +22,17 @@ class CollectionSelectInputTest < ActionView::TestCase
   end
 
   test 'input should allow overriding collection for select types' do
-    with_input_for @user, :name, :select, :collection => ['Jose', 'Carlos']
+    with_input_for @user, :name, :select, collection: ['Jose', 'Carlos']
     assert_select 'select.select#user_name'
     assert_select 'select option', 'Jose'
     assert_select 'select option', 'Carlos'
   end
 
   test 'input should do automatic collection translation for select types using defaults key' do
-    store_translations(:en, :simple_form => { :options => { :defaults => {
-      :gender => { :male => 'Male', :female => 'Female'}
+    store_translations(:en, simple_form: { options: { defaults: {
+      gender: { male: 'Male', female: 'Female'}
     } } } ) do
-      with_input_for @user, :gender, :select, :collection => [:male, :female]
+      with_input_for @user, :gender, :select, collection: [:male, :female]
       assert_select 'select.select#user_gender'
       assert_select 'select option', 'Male'
       assert_select 'select option', 'Female'
@@ -40,10 +40,10 @@ class CollectionSelectInputTest < ActionView::TestCase
   end
 
   test 'input should do automatic collection translation for select types using specific object key' do
-    store_translations(:en, :simple_form => { :options => { :user => {
-      :gender => { :male => 'Male', :female => 'Female'}
+    store_translations(:en, simple_form: { options: { user: {
+      gender: { male: 'Male', female: 'Female'}
     } } } ) do
-      with_input_for @user, :gender, :select, :collection => [:male, :female]
+      with_input_for @user, :gender, :select, collection: [:male, :female]
       assert_select 'select.select#user_gender'
       assert_select 'select option', 'Male'
       assert_select 'select option', 'Female'
@@ -52,13 +52,19 @@ class CollectionSelectInputTest < ActionView::TestCase
 
   test 'input should mark the selected value by default' do
     @user.name = "Carlos"
-    with_input_for @user, :name, :select, :collection => ['Jose', 'Carlos']
+    with_input_for @user, :name, :select, collection: ['Jose', 'Carlos']
     assert_select 'select option[selected=selected]', 'Carlos'
   end
 
+  test 'input should accept html options as the last element of collection' do
+    with_input_for @user, :name, :select, collection: [['Jose', class: 'foo']]
+    assert_select 'select.select#user_name'
+    assert_select 'select option.foo', 'Jose'
+  end
+
   test 'input should mark the selected value also when using integers' do
     @user.age = 18
-    with_input_for @user, :age, :select, :collection => 18..60
+    with_input_for @user, :age, :select, collection: 18..60
     assert_select 'select option[selected=selected]', '18'
   end
 
@@ -70,13 +76,13 @@ class CollectionSelectInputTest < ActionView::TestCase
   end
 
   test 'input should set the correct value when using a collection that includes floats' do
-    with_input_for @user, :age, :select, :collection => [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]
+    with_input_for @user, :age, :select, collection: [2.0, 2.5, 3.0, 3.5, 4.0, 4.5]
     assert_select 'select option[value="2.0"]'
     assert_select 'select option[value="2.5"]'
   end
 
   test 'input should set the correct values when using a collection that uses mixed values' do
-    with_input_for @user, :age, :select, :collection => ["Hello Kitty", 2, 4.5, :johnny, nil, true, false]
+    with_input_for @user, :age, :select, collection: ["Hello Kitty", 2, 4.5, :johnny, nil, true, false]
     assert_select 'select option[value="Hello Kitty"]'
     assert_select 'select option[value="2"]'
     assert_select 'select option[value="4.5"]'
@@ -87,39 +93,39 @@ class CollectionSelectInputTest < ActionView::TestCase
   end
 
   test 'input should include a blank option even if :include_blank is set to false if the collection includes a nil value' do
-    with_input_for @user, :age, :select, :collection => [nil], :include_blank => false
+    with_input_for @user, :age, :select, collection: [nil], include_blank: false
     assert_select 'select option[value=""]'
   end
 
   test 'input should automatically set include blank' do
-    with_input_for @user, :age, :select, :collection => 18..30
+    with_input_for @user, :age, :select, collection: 18..30
     assert_select 'select option[value=]', ''
   end
 
   test 'input should not set include blank if otherwise is told' do
-    with_input_for @user, :age, :select, :collection => 18..30, :include_blank => false
+    with_input_for @user, :age, :select, collection: 18..30, include_blank: false
     assert_no_select 'select option[value=]', ''
   end
 
   test 'input should not set include blank if prompt is given' do
-    with_input_for @user, :age, :select, :collection => 18..30, :prompt => "Please select foo"
+    with_input_for @user, :age, :select, collection: 18..30, prompt: "Please select foo"
     assert_no_select 'select option[value=]', ''
   end
 
   test 'input should not set include blank if multiple is given' do
-    with_input_for @user, :age, :select, :collection => 18..30, :input_html => { :multiple => true }
+    with_input_for @user, :age, :select, collection: 18..30, input_html: { multiple: true }
     assert_no_select 'select option[value=]', ''
   end
 
   test 'input should detect label and value on collections' do
-    users = [ setup_new_user(:id => 1, :name => "Jose"), setup_new_user(:id => 2, :name => "Carlos") ]
-    with_input_for @user, :description, :select, :collection => users
+    users = [User.build(id: 1, name: "Jose"), User.build(id: 2, name: "Carlos")]
+    with_input_for @user, :description, :select, collection: users
     assert_select 'select option[value=1]', 'Jose'
     assert_select 'select option[value=2]', 'Carlos'
   end
 
   test 'input should disable the anothers components when the option is a object' do
-    with_input_for @user, :description, :select, :collection => ["Jose", "Carlos"], :disabled => true
+    with_input_for @user, :description, :select, collection: ["Jose", "Carlos"], disabled: true
     assert_no_select 'select option[value=Jose][disabled=disabled]', 'Jose'
     assert_no_select 'select option[value=Carlos][disabled=disabled]', 'Carlos'
     assert_select 'select[disabled=disabled]'
@@ -127,7 +133,7 @@ class CollectionSelectInputTest < ActionView::TestCase
   end
 
   test 'input should not disable the anothers components when the option is a object' do
-    with_input_for @user, :description, :select, :collection => ["Jose", "Carlos"], :disabled => 'Jose'
+    with_input_for @user, :description, :select, collection: ["Jose", "Carlos"], disabled: 'Jose'
     assert_select 'select option[value=Jose][disabled=disabled]', 'Jose'
     assert_no_select 'select option[value=Carlos][disabled=disabled]', 'Carlos'
     assert_no_select 'select[disabled=disabled]'
@@ -136,101 +142,120 @@ class CollectionSelectInputTest < ActionView::TestCase
 
   test 'input should allow overriding label and value method using a lambda for collection selects' do
     with_input_for @user, :name, :select,
-                          :collection => ['Jose' , 'Carlos'],
-                          :label_method => lambda { |i| i.upcase },
-                          :value_method => lambda { |i| i.downcase }
+                          collection: ['Jose', 'Carlos'],
+                          label_method: lambda { |i| i.upcase },
+                          value_method: lambda { |i| i.downcase }
     assert_select 'select option[value=jose]', "JOSE"
     assert_select 'select option[value=carlos]', "CARLOS"
   end
 
   test 'input should allow overriding only label but not value method using a lambda for collection select' do
     with_input_for @user, :name, :select,
-                          :collection => ['Jose' , 'Carlos'],
-                          :label_method => lambda { |i| i.upcase }
+                          collection: ['Jose', 'Carlos'],
+                          label_method: lambda { |i| i.upcase }
     assert_select 'select option[value=Jose]', "JOSE"
     assert_select 'select option[value=Carlos]', "CARLOS"
   end
 
   test 'input should allow overriding only value but not label method using a lambda for collection select' do
     with_input_for @user, :name, :select,
-                          :collection => ['Jose' , 'Carlos'],
-                          :value_method => lambda { |i| i.downcase }
+                          collection: ['Jose', 'Carlos'],
+                          value_method: lambda { |i| i.downcase }
     assert_select 'select option[value=jose]', "Jose"
     assert_select 'select option[value=carlos]', "Carlos"
   end
 
   test 'input should allow symbols for collections' do
-    with_input_for @user, :name, :select, :collection => [:jose, :carlos]
+    with_input_for @user, :name, :select, collection: [:jose, :carlos]
     assert_select 'select.select#user_name'
     assert_select 'select option[value=jose]', 'jose'
     assert_select 'select option[value=carlos]', 'carlos'
   end
 
   test 'collection input with select type should generate required html attribute only with blank option' do
-    with_input_for @user, :name, :select, :include_blank => true, :collection => ['Jose' , 'Carlos']
-    assert_select 'select.required'
-    assert_select 'select[required]'
-  end
-
-  test 'collection input with select type should generate required html attribute only with blank option or prompt' do
-    with_input_for @user, :name, :select, :prompt => 'Name...', :collection => ['Jose', 'Carlos']
+    with_input_for @user, :name, :select, include_blank: true, collection: ['Jose', 'Carlos']
     assert_select 'select.required'
     assert_select 'select[required]'
   end
 
   test 'collection input with select type should not generate required html attribute without blank option' do
-    with_input_for @user, :name, :select, :include_blank => false, :collection => ['Jose' , 'Carlos']
+    with_input_for @user, :name, :select, include_blank: false, collection: ['Jose', 'Carlos']
     assert_select 'select.required'
     assert_no_select 'select[required]'
+    assert_no_select 'select[aria-required=true]'
   end
 
   test 'collection input with select type with multiple attribute should generate required html attribute without blank option' do
-    with_input_for @user, :name, :select, :include_blank => false, :input_html => {:multiple => true}, :collection => ['Jose' , 'Carlos']
+    with_input_for @user, :name, :select, include_blank: false, input_html: { multiple: true }, collection: ['Jose', 'Carlos']
     assert_select 'select.required'
     assert_select 'select[required]'
   end
 
   test 'collection input with select type with multiple attribute should generate required html attribute with blank option' do
-    with_input_for @user, :name, :select, :include_blank => true, :input_html => {:multiple => true}, :collection => ['Jose' , 'Carlos']
+    with_input_for @user, :name, :select, include_blank: true, input_html: { multiple: true }, collection: ['Jose', 'Carlos']
     assert_select 'select.required'
     assert_select 'select[required]'
   end
 
+  test 'with a blank option, a collection input of type select has an aria-required html attribute' do
+    with_input_for @user, :name, :select, include_blank: true, collection: ['Jose', 'Carlos']
+    assert_select 'select.required'
+    assert_select 'select[aria-required=true]'
+  end
+
+  test 'without a blank option, a collection input of type select does not have an aria-required html attribute' do
+    with_input_for @user, :name, :select, include_blank: false, collection: ['Jose', 'Carlos']
+    assert_select 'select.required'
+    assert_no_select 'select[aria-required]'
+  end
+
+  test 'without a blank option and with a multiple option, a collection input of type select has an aria-required html attribute' do
+    with_input_for @user, :name, :select, include_blank: false, input_html: { multiple: true }, collection: ['Jose', 'Carlos']
+    assert_select 'select.required'
+    assert_select 'select[aria-required=true]'
+  end
+
+  test 'with a blank option and a multiple option, a collection input of type select has an aria-required html attribute' do
+    with_input_for @user, :name, :select, include_blank: true, input_html: { multiple: true }, collection: ['Jose', 'Carlos']
+    assert_select 'select.required'
+    assert_select 'select[aria-required]'
+  end
+
   test 'input should allow disabled options with a lambda for collection select' do
-    with_input_for @user, :name, :select, :collection => ["Carlos", "Antonio"],
-      :disabled => lambda { |x| x == "Carlos" }
+    with_input_for @user, :name, :select, collection: ["Carlos", "Antonio"],
+      disabled: lambda { |x| x == "Carlos" }
     assert_select 'select option[value=Carlos][disabled=disabled]', 'Carlos'
     assert_select 'select option[value=Antonio]', 'Antonio'
     assert_no_select 'select option[value=Antonio][disabled]'
   end
 
   test 'input should allow disabled and label method with lambdas for collection select' do
-    with_input_for @user, :name, :select, :collection => ["Carlos", "Antonio"],
-      :disabled => lambda { |x| x == "Carlos" }, :label_method => lambda { |x| x.upcase }
+    with_input_for @user, :name, :select, collection: ["Carlos", "Antonio"],
+      disabled: lambda { |x| x == "Carlos" }, label_method: lambda { |x| x.upcase }
     assert_select 'select option[value=Carlos][disabled=disabled]', 'CARLOS'
     assert_select 'select option[value=Antonio]', 'ANTONIO'
     assert_no_select 'select option[value=Antonio][disabled]'
   end
 
   test 'input should allow a non lambda disabled option with lambda label method for collections' do
-    with_input_for @user, :name, :select, :collection => ["Carlos", "Antonio"],
-      :disabled => "Carlos", :label_method => lambda { |x| x.upcase }
+    with_input_for @user, :name, :select, collection: ["Carlos", "Antonio"],
+      disabled: "Carlos", label_method: lambda { |x| x.upcase }
     assert_select 'select option[value=Carlos][disabled=disabled]', 'CARLOS'
     assert_select 'select option[value=Antonio]', 'ANTONIO'
     assert_no_select 'select option[value=Antonio][disabled]'
   end
 
   test 'input should allow selected and label method with lambdas for collection select' do
-    with_input_for @user, :name, :select, :collection => ["Carlos", "Antonio"],
-      :selected => lambda { |x| x == "Carlos" }, :label_method => lambda { |x| x.upcase }
+    with_input_for @user, :name, :select, collection: ["Carlos", "Antonio"],
+      selected: lambda { |x| x == "Carlos" }, label_method: lambda { |x| x.upcase }
     assert_select 'select option[value=Carlos][selected=selected]', 'CARLOS'
     assert_select 'select option[value=Antonio]', 'ANTONIO'
     assert_no_select 'select option[value=Antonio][selected]'
   end
 
   test 'input should allow a non lambda selected option with lambda label method for collection select' do
-    with_input_for @user, :name, :select, :collection => ["Carlos", "Antonio"],
-      :selected => "Carlos", :label_method => lambda { |x| x.upcase }
+    with_input_for @user, :name, :select, collection: ["Carlos", "Antonio"],
+      selected: "Carlos", label_method: lambda { |x| x.upcase }
     assert_select 'select option[value=Carlos][selected=selected]', 'CARLOS'
     assert_select 'select option[value=Antonio]', 'ANTONIO'
     assert_no_select 'select option[value=Antonio][selected]'
@@ -238,8 +263,8 @@ class CollectionSelectInputTest < ActionView::TestCase
 
   test 'input should not override default selection through attribute value with label method as lambda for collection select' do
     @user.name = "Carlos"
-    with_input_for @user, :name, :select, :collection => ["Carlos", "Antonio"],
-      :label_method => lambda { |x| x.upcase }
+    with_input_for @user, :name, :select, collection: ["Carlos", "Antonio"],
+      label_method: lambda { |x| x.upcase }
     assert_select 'select option[value=Carlos][selected=selected]', 'CARLOS'
     assert_select 'select option[value=Antonio]', 'ANTONIO'
     assert_no_select 'select option[value=Antonio][selected]'

data/test/inputs/datetime_input_test.rb

@@ -13,7 +13,7 @@ class DateTimeInputTest < ActionView::TestCase
 
   test 'input should be able to pass options to datetime select' do
     with_input_for @user, :created_at, :datetime,
-      :disabled => true, :prompt => { :year => 'ano', :month => 'mês', :day => 'dia' }
+      disabled: true, prompt: { year: 'ano', month: 'mês', day: 'dia' }
 
     assert_select 'select.datetime[disabled=disabled]'
     assert_select 'select.datetime option', 'ano'
@@ -30,8 +30,8 @@ class DateTimeInputTest < ActionView::TestCase
   end
 
   test 'input should be able to pass options to date select' do
-    with_input_for @user, :born_at, :date, :as => :date,
-      :disabled => true, :prompt => { :year => 'ano', :month => 'mês', :day => 'dia' }
+    with_input_for @user, :born_at, :date, as: :date,
+      disabled: true, prompt: { year: 'ano', month: 'mês', day: 'dia' }
 
     assert_select 'select.date[disabled=disabled]'
     assert_select 'select.date option', 'ano'
@@ -40,7 +40,7 @@ class DateTimeInputTest < ActionView::TestCase
   end
 
   test 'input should be able to pass :default to date select' do
-    with_input_for @user, :born_at, :date, :default => Date.today
+    with_input_for @user, :born_at, :date, default: Date.today
     assert_select "select.date option[value=#{Date.today.year}][selected=selected]"
   end
 
@@ -54,8 +54,8 @@ class DateTimeInputTest < ActionView::TestCase
   end
 
   test 'input should be able to pass options to time select' do
-    with_input_for @user, :delivery_time, :time, :required => true,
-      :disabled => true, :prompt => { :hour => 'hora', :minute => 'minuto' }
+    with_input_for @user, :delivery_time, :time, required: true,
+      disabled: true, prompt: { hour: 'hora', minute: 'minuto' }
 
     assert_select 'select.time[disabled=disabled]'
     assert_select 'select.time option', 'hora'
@@ -63,26 +63,26 @@ class DateTimeInputTest < ActionView::TestCase
   end
 
   test 'label should use i18n to get target for date input type' do
-    store_translations(:en, :date => { :order => [:month, :day, :year] }) do
+    store_translations(:en, date: { order: ['month', 'day', 'year'] }) do
       with_input_for :project, :created_at, :date
       assert_select 'label[for=project_created_at_2i]'
     end
   end
 
   test 'label should use i18n to get target for datetime input type' do
-    store_translations(:en, :date => { :order => [:month, :day, :year] }) do
+    store_translations(:en, date: { order: ['month', 'day', 'year'] }) do
       with_input_for :project, :created_at, :datetime
       assert_select 'label[for=project_created_at_2i]'
     end
   end
 
   test 'label should use order to get target when date input type' do
-    with_input_for :project, :created_at, :date, :order => [:month, :year, :day]
+    with_input_for :project, :created_at, :date, order: ['month', 'year', 'day']
     assert_select 'label[for=project_created_at_2i]'
   end
 
   test 'label should use order to get target when datetime input type' do
-    with_input_for :project, :created_at, :datetime, :order => [:month, :year, :day]
+    with_input_for :project, :created_at, :datetime, order: ['month', 'year', 'day']
     assert_select 'label[for=project_created_at_2i]'
   end
 
@@ -92,8 +92,14 @@ class DateTimeInputTest < ActionView::TestCase
   end
 
   test 'date time input should generate required html attribute' do
-    with_input_for @user, :delivery_time, :time, :required => true
+    with_input_for @user, :delivery_time, :time, required: true
     assert_select 'select.required'
     assert_select 'select[required]'
   end
+
+  test 'date time input has an aria-required html attribute' do
+    with_input_for @user, :delivery_time, :time, required: true
+    assert_select 'select.required'
+    assert_select 'select[aria-required=true]'
+  end
 end

data/test/inputs/disabled_test.rb

@@ -2,52 +2,52 @@ require 'test_helper'
 
 class DisabledTest < ActionView::TestCase
   test 'string input should be disabled when disabled option is true' do
-    with_input_for @user, :name, :string, :disabled => true
+    with_input_for @user, :name, :string, disabled: true
     assert_select 'input.string.disabled[disabled]'
   end
 
   test 'text input should be disabled when disabled option is true' do
-    with_input_for @user, :description, :text, :disabled => true
+    with_input_for @user, :description, :text, disabled: true
     assert_select 'textarea.text.disabled[disabled]'
   end
 
   test 'numeric input should be disabled when disabled option is true' do
-    with_input_for @user, :age, :integer, :disabled => true
+    with_input_for @user, :age, :integer, disabled: true
     assert_select 'input.integer.disabled[disabled]'
   end
 
   test 'date input should be disabled when disabled option is true' do
-    with_input_for @user, :born_at, :date, :disabled => true
+    with_input_for @user, :born_at, :date, disabled: true
     assert_select 'select.date.disabled[disabled]'
   end
 
   test 'datetime input should be disabled when disabled option is true' do
-    with_input_for @user, :created_at, :datetime, :disabled => true
+    with_input_for @user, :created_at, :datetime, disabled: true
     assert_select 'select.datetime.disabled[disabled]'
   end
 
   test 'string input should not be disabled when disabled option is false' do
-    with_input_for @user, :name, :string, :disabled => false
+    with_input_for @user, :name, :string, disabled: false
     assert_no_select 'input.string.disabled[disabled]'
   end
 
   test 'text input should not be disabled when disabled option is false' do
-    with_input_for @user, :description, :text, :disabled => false
+    with_input_for @user, :description, :text, disabled: false
     assert_no_select 'textarea.text.disabled[disabled]'
   end
 
   test 'numeric input should not be disabled when disabled option is false' do
-    with_input_for @user, :age, :integer, :disabled => false
+    with_input_for @user, :age, :integer, disabled: false
     assert_no_select 'input.integer.disabled[disabled]'
   end
 
   test 'date input should not be disabled when disabled option is false' do
-    with_input_for @user, :born_at, :date, :disabled => false
+    with_input_for @user, :born_at, :date, disabled: false
     assert_no_select 'select.date.disabled[disabled]'
   end
 
   test 'datetime input should not be disabled when disabled option is false' do
-    with_input_for @user, :created_at, :datetime, :disabled => false
+    with_input_for @user, :created_at, :datetime, disabled: false
     assert_no_select 'select.datetime.disabled[disabled]'
   end
 

data/test/inputs/discovery_test.rb

@@ -3,7 +3,7 @@ require 'test_helper'
 class DiscoveryTest < ActionView::TestCase
   # Setup new inputs and remove them after the test.
   def discovery(value=false)
-    swap SimpleForm, :cache_discovery => value do
+    swap SimpleForm, cache_discovery: value do
       begin
         load "support/discovery_inputs.rb"
         yield
@@ -29,7 +29,7 @@ class DiscoveryTest < ActionView::TestCase
 
   test 'builder should discover new inputs' do
     discovery do
-      with_form_for @user, :name, :as => :customized
+      with_form_for @user, :name, as: :customized
       assert_select 'form section input#user_name.string'
     end
   end
@@ -38,7 +38,7 @@ class DiscoveryTest < ActionView::TestCase
     with_form_for @user, :name
     assert_select 'form input#user_name.string'
 
-    swap SimpleForm, :inputs_discovery => false do
+    swap SimpleForm, inputs_discovery: false do
       discovery do
         with_form_for @user, :name
         assert_no_select 'form section input#user_name.string'
@@ -62,7 +62,7 @@ class DiscoveryTest < ActionView::TestCase
 
   test 'new inputs can override the input_html_options' do
     discovery do
-      with_form_for @user, :active, :as => :select
+      with_form_for @user, :active, as: :select
       assert_select 'form select#user_active.select.chosen'
     end
   end

data/test/inputs/file_input_test.rb

@@ -8,7 +8,7 @@ class FileInputTest < ActionView::TestCase
   end
 
   test "input should generate a file field that doesn't accept placeholder" do
-    store_translations(:en, :simple_form => { :placeholders => { :user => { :name => "text" } } }) do
+    store_translations(:en, simple_form: { placeholders: { user: { name: "text" } } }) do
       with_input_for @user, :name, :file
       assert_no_select 'input[placeholder]'
     end

data/test/inputs/general_test.rb

@@ -16,52 +16,68 @@ class InputTest < ActionView::TestCase
   end
 
   test 'string input should generate autofocus attribute when autofocus option is true' do
-    with_input_for @user, :name, :string, :autofocus => true
+    with_input_for @user, :name, :string, autofocus: true
     assert_select 'input.string[autofocus]'
   end
 
+  test 'input accepts input_class configuration' do
+    swap SimpleForm, input_class: :xlarge do
+      with_input_for @user, :name, :string
+      assert_select 'input.xlarge'
+      assert_no_select 'div.xlarge'
+    end
+  end
+
+  test 'input does not add input_class when configured to not generate additional classes for input' do
+    swap SimpleForm, input_class: 'xlarge', generate_additional_classes_for: [:wrapper] do
+      with_input_for @user, :name, :string
+      assert_select 'input'
+      assert_no_select '.xlarge'
+    end
+  end
+
   test 'text input should generate autofocus attribute when autofocus option is true' do
-    with_input_for @user, :description, :text, :autofocus => true
+    with_input_for @user, :description, :text, autofocus: true
     assert_select 'textarea.text[autofocus]'
   end
 
   test 'numeric input should generate autofocus attribute when autofocus option is true' do
-    with_input_for @user, :age, :integer, :autofocus => true
+    with_input_for @user, :age, :integer, autofocus: true
     assert_select 'input.integer[autofocus]'
   end
 
   test 'date input should generate autofocus attribute when autofocus option is true' do
-    with_input_for @user, :born_at, :date, :autofocus => true
+    with_input_for @user, :born_at, :date, autofocus: true
     assert_select 'select.date[autofocus]'
   end
 
   test 'datetime input should generate autofocus attribute when autofocus option is true' do
-    with_input_for @user, :created_at, :datetime, :autofocus => true
+    with_input_for @user, :created_at, :datetime, autofocus: true
     assert_select 'select.datetime[autofocus]'
   end
 
   test 'string input should generate autofocus attribute when autofocus option is false' do
-    with_input_for @user, :name, :string, :autofocus => false
+    with_input_for @user, :name, :string, autofocus: false
     assert_no_select 'input.string[autofocus]'
   end
 
   test 'text input should generate autofocus attribute when autofocus option is false' do
-    with_input_for @user, :description, :text, :autofocus => false
+    with_input_for @user, :description, :text, autofocus: false
     assert_no_select 'textarea.text[autofocus]'
   end
 
   test 'numeric input should generate autofocus attribute when autofocus option is false' do
-    with_input_for @user, :age, :integer, :autofocus => false
+    with_input_for @user, :age, :integer, autofocus: false
     assert_no_select 'input.integer[autofocus]'
   end
 
   test 'date input should generate autofocus attribute when autofocus option is false' do
-    with_input_for @user, :born_at, :date, :autofocus => false
+    with_input_for @user, :born_at, :date, autofocus: false
     assert_no_select 'select.date[autofocus]'
   end
 
   test 'datetime input should generate autofocus attribute when autofocus option is false' do
-    with_input_for @user, :created_at, :datetime, :autofocus => false
+    with_input_for @user, :created_at, :datetime, autofocus: false
     assert_no_select 'select.datetime[autofocus]'
   end
 
@@ -103,12 +119,12 @@ class InputTest < ActionView::TestCase
   end
 
   test 'input as select with collection should be generated properly when object is not present' do
-    with_input_for :project, :name, :select, :collection => ['Jose', 'Carlos']
+    with_input_for :project, :name, :select, collection: ['Jose', 'Carlos']
     assert_select 'select.select#project_name'
   end
 
   test 'input should not generate empty css class' do
-    swap SimpleForm, :generate_additional_classes_for => [:wrapper, :label] do
+    swap SimpleForm, generate_additional_classes_for: [:wrapper, :label] do
       with_input_for :project, :name, :string
       assert_no_select 'input#project_name[class]'
     end