simple_form 2.1.0 → 3.0.0

data/test/inputs/grouped_collection_select_input_test.rb

@@ -4,8 +4,8 @@ require 'test_helper'
 class GroupedCollectionSelectInputTest < ActionView::TestCase
   test 'grouped collection accepts array collection form' do
     with_input_for @user, :tag_ids, :grouped_select,
-      :collection => [['Authors', ['Jose', 'Carlos']], ['General', ['Bob', 'John']]],
-      :group_method => :last
+      collection: [['Authors', ['Jose', 'Carlos']], ['General', ['Bob', 'John']]],
+      group_method: :last
 
     assert_select 'select.grouped_select#user_tag_ids' do
       assert_select 'optgroup[label=Authors]' do
@@ -22,8 +22,8 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
 
   test 'grouped collection accepts empty array collection form' do
     with_input_for @user, :tag_ids, :grouped_select,
-      :collection => [],
-      :group_method => :last
+      collection: [],
+      group_method: :last
 
     assert_select 'select.grouped_select#user_tag_ids'
   end
@@ -31,8 +31,8 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
 
   test 'grouped collection accepts proc as collection' do
     with_input_for @user, :tag_ids, :grouped_select,
-      :collection => Proc.new { [['Authors', ['Jose', 'Carlos']], ['General', ['Bob', 'John']]] },
-      :group_method => :last
+      collection: Proc.new { [['Authors', ['Jose', 'Carlos']], ['General', ['Bob', 'John']]] },
+      group_method: :last
 
     assert_select 'select.grouped_select#user_tag_ids' do
       assert_select 'optgroup[label=Authors]' do
@@ -49,8 +49,8 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
 
   test 'grouped collection accepts hash collection form' do
     with_input_for @user, :tag_ids, :grouped_select,
-      :collection => { 'Authors' => ['Jose', 'Carlos'], 'General' => ['Bob', 'John'] },
-      :group_method => :last
+      collection: { 'Authors' => ['Jose', 'Carlos'], 'General' => ['Bob', 'John'] },
+      group_method: :last
 
     assert_select 'select.grouped_select#user_tag_ids' do
       assert_select 'optgroup[label=Authors]' do
@@ -67,9 +67,9 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
 
   test 'grouped collection accepts group_label_method option' do
     with_input_for @user, :tag_ids, :grouped_select,
-      :collection => { ['Jose', 'Carlos'] => 'Authors' },
-      :group_method => :first,
-      :group_label_method => :last
+      collection: { ['Jose', 'Carlos'] => 'Authors' },
+      group_method: :first,
+      group_label_method: :last
 
     assert_select 'select.grouped_select#user_tag_ids' do
       assert_select 'optgroup[label=Authors]' do
@@ -81,10 +81,10 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
 
   test 'grouped collection accepts label and value methods options' do
     with_input_for @user, :tag_ids, :grouped_select,
-      :collection => { 'Authors' => ['Jose', 'Carlos'] },
-      :group_method => :last,
-      :label_method => :upcase,
-      :value_method => :downcase
+      collection: { 'Authors' => ['Jose', 'Carlos'] },
+      group_method: :last,
+      label_method: :upcase,
+      value_method: :downcase
 
     assert_select 'select.grouped_select#user_tag_ids' do
       assert_select 'optgroup[label=Authors]' do
@@ -96,10 +96,10 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
 
   test 'grouped collection should allow overriding label and value methods using a lambda' do
     with_input_for @user, :tag_ids, :grouped_select,
-      :collection => { 'Authors' => ['Jose', 'Carlos'] },
-      :group_method => :last,
-      :label_method => lambda { |i| i.upcase },
-      :value_method => lambda { |i| i.downcase }
+      collection: { 'Authors' => ['Jose', 'Carlos'] },
+      group_method: :last,
+      label_method: lambda { |i| i.upcase },
+      value_method: lambda { |i| i.downcase }
 
     assert_select 'select.grouped_select#user_tag_ids' do
       assert_select 'optgroup[label=Authors]' do
@@ -116,7 +116,7 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
     ]
 
     with_input_for @user, :tag_ids, :grouped_select,
-      :collection => tag_groups, :group_method => :tags
+      collection: tag_groups, group_method: :tags
 
     assert_select 'select.grouped_select#user_tag_ids' do
       assert_select 'optgroup[label=Group of Tags]' do
@@ -130,4 +130,17 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
       end
     end
   end
+
+  test 'grouped collection should accept html options as the last element of collection' do
+    with_input_for @user, :tag_ids, :grouped_select,
+      collection: [['Authors', [['Jose', 'jose', class: 'foo'], ['Carlos', 'carlos', class: 'bar']]]],
+      group_method: :last
+
+    assert_select 'select.grouped_select#user_tag_ids' do
+      assert_select 'optgroup[label=Authors]' do
+        assert_select 'option.foo', 'Jose'
+        assert_select 'option.bar', 'Carlos'
+      end
+    end
+  end
 end

data/test/inputs/hidden_input_test.rb

@@ -9,7 +9,7 @@ class HiddenInputTest < ActionView::TestCase
   end
 
   test 'hint should not be generated for hidden fields' do
-    store_translations(:en, :simple_form => { :hints => { :user => { :name => "text" } } }) do
+    store_translations(:en, simple_form: { hints: { user: { name: "text" } } }) do
       with_input_for @user, :name, :hidden
       assert_no_select 'span.hint'
     end
@@ -20,10 +20,11 @@ class HiddenInputTest < ActionView::TestCase
     assert_no_select 'label'
   end
 
-  test 'required/optional options should not be generated for hidden inputs' do
+  test 'required/aria-required/optional options should not be generated for hidden inputs' do
     with_input_for @user, :name, :hidden
     assert_no_select 'input.required'
     assert_no_select 'input[required]'
+    assert_no_select 'input[aria-required]'
     assert_no_select 'input.optional'
     assert_select 'input.hidden#user_name'
   end

data/test/inputs/numeric_input_test.rb

@@ -121,13 +121,13 @@ class NumericInputTest < ActionView::TestCase
   end
 
   test 'numeric input should accept the placeholder option' do
-    with_input_for @user, :age, :integer, :placeholder => 'Put in your age'
+    with_input_for @user, :age, :integer, placeholder: 'Put in your age'
     assert_select 'input.integer[placeholder=Put in your age]'
   end
 
   test 'numeric input should use i18n to translate placeholder text' do
-    store_translations(:en, :simple_form => { :placeholders => { :user => {
-      :age => 'Age goes here'
+    store_translations(:en, simple_form: { placeholders: { user: {
+      age: 'Age goes here'
     } } }) do
       with_input_for @user, :age, :integer
       assert_select 'input.integer[placeholder=Age goes here]'

data/test/inputs/priority_input_test.rb

@@ -10,7 +10,7 @@ class PriorityInputTest < ActionView::TestCase
   end
 
   test 'input should generate a country select with SimpleForm default' do
-    swap SimpleForm, :country_priority => [ 'Brazil' ] do
+    swap SimpleForm, country_priority: [ 'Brazil' ] do
       with_input_for @user, :country, :country
       assert_select 'select option[value=][disabled=disabled]'
     end
@@ -24,13 +24,13 @@ class PriorityInputTest < ActionView::TestCase
   end
 
   test 'input should generate a time zone select field with default' do
-    with_input_for @user, :time_zone, :time_zone, :default => 'Brasilia'
+    with_input_for @user, :time_zone, :time_zone, default: 'Brasilia'
     assert_select 'select option[value=Brasilia][selected=selected]'
     assert_no_select 'select option[value=]'
   end
 
   test 'input should generate a time zone select using options priority' do
-    with_input_for @user, :time_zone, :time_zone, :priority => /Brasilia/
+    with_input_for @user, :time_zone, :time_zone, priority: /Brasilia/
     assert_select 'select option[value=][disabled=disabled]'
     assert_no_select 'select option[value=]', /^$/
   end
@@ -40,4 +40,10 @@ class PriorityInputTest < ActionView::TestCase
     assert_select 'select.required'
     assert_no_select 'select[required]'
   end
+
+  test 'priority input should not generate invalid aria-required html attribute' do
+    with_input_for @user, :country, :country
+    assert_select 'select.required'
+    assert_no_select 'select[aria-required]'
+  end
 end

data/test/inputs/readonly_test.rb

@@ -2,52 +2,52 @@ require 'test_helper'
 
 class ReadonlyTest < ActionView::TestCase
   test 'string input should generate readonly elements when readonly option is true' do
-    with_input_for @user, :name, :string, :readonly => true
+    with_input_for @user, :name, :string, readonly: true
     assert_select 'input.string.readonly[readonly]'
   end
 
   test 'text input should generate readonly elements when readonly option is true' do
-    with_input_for @user, :description, :text, :readonly => true
+    with_input_for @user, :description, :text, readonly: true
     assert_select 'textarea.text.readonly[readonly]'
   end
 
   test 'numeric input should generate readonly elements when readonly option is true' do
-    with_input_for @user, :age, :integer, :readonly => true
+    with_input_for @user, :age, :integer, readonly: true
     assert_select 'input.integer.readonly[readonly]'
   end
 
   test 'date input should generate readonly elements when readonly option is true' do
-    with_input_for @user, :born_at, :date, :readonly => true
+    with_input_for @user, :born_at, :date, readonly: true
     assert_select 'select.date.readonly[readonly]'
   end
 
   test 'datetime input should generate readonly elements when readonly option is true' do
-    with_input_for @user, :created_at, :datetime, :readonly => true
+    with_input_for @user, :created_at, :datetime, readonly: true
     assert_select 'select.datetime.readonly[readonly]'
   end
 
   test 'string input should generate readonly elements when readonly option is false' do
-    with_input_for @user, :name, :string, :readonly => false
+    with_input_for @user, :name, :string, readonly: false
     assert_no_select 'input.string.readonly[readonly]'
   end
 
   test 'text input should generate readonly elements when readonly option is false' do
-    with_input_for @user, :description, :text, :readonly => false
+    with_input_for @user, :description, :text, readonly: false
     assert_no_select 'textarea.text.readonly[readonly]'
   end
 
   test 'numeric input should generate readonly elements when readonly option is false' do
-    with_input_for @user, :age, :integer, :readonly => false
+    with_input_for @user, :age, :integer, readonly: false
     assert_no_select 'input.integer.readonly[readonly]'
   end
 
   test 'date input should generate readonly elements when readonly option is false' do
-    with_input_for @user, :born_at, :date, :readonly => false
+    with_input_for @user, :born_at, :date, readonly: false
     assert_no_select 'select.date.readonly[readonly]'
   end
 
   test 'datetime input should generate readonly elements when readonly option is false' do
-    with_input_for @user, :created_at, :datetime, :readonly => false
+    with_input_for @user, :created_at, :datetime, readonly: false
     assert_no_select 'select.datetime.readonly[readonly]'
   end
 
@@ -77,13 +77,13 @@ class ReadonlyTest < ActionView::TestCase
   end
 
   test 'input should generate readonly attribute when the field is readonly and the object is persisted' do
-    with_input_for @user, :credit_card, :string, :readonly => :lookup
+    with_input_for @user, :credit_card, :string, readonly: :lookup
     assert_select 'input.string.readonly[readonly]'
   end
 
   test 'input should not generate readonly attribute when the field is readonly and the object is not persisted' do
     @user.new_record!
-    with_input_for @user, :credit_card, :string, :readonly => :lookup
+    with_input_for @user, :credit_card, :string, readonly: :lookup
     assert_no_select 'input.string.readonly[readonly]'
   end
 

data/test/inputs/required_test.rb

@@ -10,9 +10,9 @@ class RequiredTest < ActionView::TestCase
   end
 
   test 'builder input should allow overriding required when ActiveModel::Validations is included' do
-    with_form_for @validating_user, :name, :required => false
+    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
 
@@ -22,7 +22,7 @@ class RequiredTest < ActionView::TestCase
   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
+    swap SimpleForm, required_by_default: false do
       with_form_for @user, :name
       assert_select 'input.optional#user_name'
       assert_no_select 'input[required]'
@@ -30,7 +30,7 @@ class RequiredTest < ActionView::TestCase
   end
 
   test 'when not using browser validations, input should not generate required html attribute' do
-    swap SimpleForm, :browser_validations => false 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]'
@@ -38,7 +38,7 @@ class RequiredTest < ActionView::TestCase
   end
 
   test 'builder input should allow disabling required when ActiveModel::Validations is not included' do
-    with_form_for @user, :name, :required => false
+    with_form_for @user, :name, required: false
     assert_no_select 'input.required'
     assert_no_select 'input[required]'
     assert_select 'input.optional#user_name'

data/test/inputs/string_input_test.rb

@@ -12,11 +12,6 @@ class StringInputTest < ActionView::TestCase
     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
     with_input_for @user, :name, :string
     assert_select 'input.string[maxlength=100]'
@@ -27,16 +22,6 @@ class StringInputTest < ActionView::TestCase
     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
     with_input_for @user, :password, :password
     assert_select 'input.password[type=password][maxlength=100]'
@@ -57,10 +42,10 @@ class StringInputTest < ActionView::TestCase
     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 should be 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
@@ -69,12 +54,12 @@ class StringInputTest < ActionView::TestCase
   end
 
   test 'input should accept the placeholder option' do
-    with_input_for @user, :name, :string, :placeholder => 'Put in some text'
+    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'
+    with_input_for @user, :password, :password, placeholder: 'Password Confirmation'
     assert_select 'input[type=password].password[placeholder=Password Confirmation]#user_password'
   end
 
@@ -84,12 +69,12 @@ class StringInputTest < ActionView::TestCase
   end
 
   test 'input should infer pattern from attributes' do
-    with_input_for @other_validating_user, :country, :string, :pattern => true
+    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
+    with_input_for @other_validating_user, :name, :string, pattern: true
     assert_select 'input[pattern="\w+"]'
   end
 
@@ -101,13 +86,18 @@ class StringInputTest < ActionView::TestCase
   end
 
   test 'input should use given pattern from attributes' do
-    with_input_for @other_validating_user, :country, :string, :input_html => { :pattern => "\\d+" }
+    with_input_for @other_validating_user, :country, :string, input_html: { pattern: "\\d+" }
     assert_select 'input[pattern="\d+"]'
   end
 
+  test 'input should 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 should use i18n to translate placeholder text' do
-    store_translations(:en, :simple_form => { :placeholders => { :user => {
-      :name => 'Name goes here'
+    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]'
@@ -138,7 +128,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

@@ -8,7 +8,7 @@ class TextInputTest < ActionView::TestCase
   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'
+    with_input_for @user, :description, :text, placeholder: 'Put in some text'
     assert_select 'textarea.text[placeholder=Put in some text]'
   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,6 +24,28 @@ module MiscHelpers
     end
   end
 
+  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
+    klass.class_eval do
+      undef_method method
+      alias_method method, :"new_#{method}"
+      undef_method :"new_#{method}"
+    end
+  end
+
   def swap_wrapper(name=:default, wrapper=self.custom_wrapper)
     old = SimpleForm.wrappers[name]
     SimpleForm.wrappers[name] = wrapper
@@ -33,69 +55,69 @@ module MiscHelpers
   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" }
+      b.use :hint, wrap_with: { class: "omg_hint" }
     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_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)
@@ -122,17 +144,17 @@ module MiscHelpers
 
   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

data/test/support/mock_controller.rb

@@ -13,12 +13,12 @@ class MockController
     "http://example.com"
   end
 
-  def url_helpers
-    self
+  def url_options
+    {}
   end
 
-  def hash_for_user_path(*args); end
-  def hash_for_validating_user_path(*args); end
-  def hash_for_other_validating_user_path(*args); end
-  def hash_for_users_path(*args); end
+  def hash_for_user_path(*); end
+  def hash_for_validating_user_path(*); end
+  def hash_for_other_validating_user_path(*); end
+  def hash_for_users_path(*); end
 end