simple_form 3.0.4 → 5.0.3

data/test/inputs/grouped_collection_select_input_test.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 # encoding: UTF-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']]],
+      collection: [['Authors', %w[Jose Carlos]], ['General', %w[Bob John]]],
       group_method: :last
 
     assert_select 'select.grouped_select#user_tag_ids' do
@@ -31,7 +32,7 @@ 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']]] },
+      collection: proc { [['Authors', %w[Jose Carlos]], ['General', %w[Bob John]]] },
       group_method: :last
 
     assert_select 'select.grouped_select#user_tag_ids' do
@@ -49,7 +50,7 @@ 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'] },
+      collection: { Authors: %w[Jose Carlos], General: %w[Bob John] },
       group_method: :last
 
     assert_select 'select.grouped_select#user_tag_ids' do
@@ -67,7 +68,7 @@ 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' },
+      collection: { %w[Jose Carlos] => 'Authors' },
       group_method: :first,
       group_label_method: :last
 
@@ -79,9 +80,45 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
     end
   end
 
+  test 'grouped collection finds default label methods on the group objects' do
+    option_list = %w[Jose Carlos]
+
+    GroupedClass = Struct.new(:to_label, :options)
+    group = GroupedClass.new("Authors", option_list)
+
+    with_input_for @user, :tag_ids, :grouped_select,
+      collection: [group],
+      group_method: :options
+
+    assert_select 'select.grouped_select#user_tag_ids' do
+      assert_select 'optgroup[label=Authors]' do
+        assert_select 'option', 'Jose'
+        assert_select 'option', 'Carlos'
+      end
+    end
+  end
+
+  test 'grouped collections finds the default label method from the first non-empty object' do
+    Agent = Struct.new(:id, :name)
+    agents = [["First", []], ["Second", [Agent.new(7, 'Bond'), Agent.new(47, 'Hitman')]]]
+
+    with_input_for @user, :tag_ids, :grouped_select,
+      collection: agents,
+      group_label_method: :first,
+      group_method: :last,
+      include_blank: false
+
+    assert_select 'select.grouped_select#user_tag_ids' do
+      assert_select 'optgroup[label=Second]' do
+        assert_select 'option[value="7"]', 'Bond'
+        assert_select 'option[value="47"]', 'Hitman'
+      end
+    end
+  end
+
   test 'grouped collection accepts label and value methods options' do
     with_input_for @user, :tag_ids, :grouped_select,
-      collection: { 'Authors' => ['Jose', 'Carlos'] },
+      collection: { Authors: %w[Jose Carlos] },
       group_method: :last,
       label_method: :upcase,
       value_method: :downcase
@@ -94,12 +131,12 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
     end
   end
 
-  test 'grouped collection should allow overriding label and value methods using a lambda' do
+  test 'grouped collection allows overriding label and value methods using a lambda' do
     with_input_for @user, :tag_ids, :grouped_select,
-      collection: { 'Authors' => ['Jose', 'Carlos'] },
+      collection: { Authors: %w[Jose Carlos] },
       group_method: :last,
-      label_method: lambda { |i| i.upcase },
-      value_method: lambda { |i| i.downcase }
+      label_method: ->(i) { i.upcase },
+      value_method: ->(i) { i.downcase }
 
     assert_select 'select.grouped_select#user_tag_ids' do
       assert_select 'optgroup[label=Authors]' do
@@ -112,26 +149,26 @@ class GroupedCollectionSelectInputTest < ActionView::TestCase
   test 'grouped collection with associations' do
     tag_groups = [
       TagGroup.new(1, "Group of Tags", [Tag.new(1, "Tag 1"), Tag.new(2, "Tag 2")]),
-      TagGroup.new(2, "Other group", [Tag.new(3, "Tag 3"), Tag.new(4,"Tag 4")])
+      TagGroup.new(2, "Other group", [Tag.new(3, "Tag 3"), Tag.new(4, "Tag 4")])
     ]
 
     with_input_for @user, :tag_ids, :grouped_select,
       collection: tag_groups, group_method: :tags
 
     assert_select 'select.grouped_select#user_tag_ids' do
-      assert_select 'optgroup[label=Group of Tags]' do
-        assert_select 'option[value=1]', 'Tag 1'
-        assert_select 'option[value=2]', 'Tag 2'
+      assert_select 'optgroup[label="Group of Tags"]' do
+        assert_select 'option[value="1"]', 'Tag 1'
+        assert_select 'option[value="2"]', 'Tag 2'
       end
 
-      assert_select 'optgroup[label=Other group]' do
-        assert_select 'option[value=3]', 'Tag 3'
-        assert_select 'option[value=4]', 'Tag 4'
+      assert_select 'optgroup[label="Other group"]' do
+        assert_select 'option[value="3"]', 'Tag 3'
+        assert_select 'option[value="4"]', 'Tag 4'
       end
     end
   end
 
-  test 'grouped collection should accept html options as the last element of collection' do
+  test 'grouped collection accepts 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

data/test/inputs/hidden_input_test.rb

@@ -1,26 +1,27 @@
+# frozen_string_literal: true
 # encoding: UTF-8
 require 'test_helper'
 
 class HiddenInputTest < ActionView::TestCase
-  test 'input should generate a hidden field' do
+  test 'input generates a hidden field' do
     with_input_for @user, :name, :hidden
     assert_no_select 'input[type=text]'
     assert_select 'input#user_name[type=hidden]'
   end
 
-  test 'hint should not be generated for hidden fields' do
+  test 'hint does not be generated for hidden fields' do
     store_translations(:en, simple_form: { hints: { user: { name: "text" } } }) do
       with_input_for @user, :name, :hidden
       assert_no_select 'span.hint'
     end
   end
 
-  test 'label should not be generated for hidden inputs' do
+  test 'label does not be generated for hidden inputs' do
     with_input_for @user, :name, :hidden
     assert_no_select 'label'
   end
 
-  test 'required/aria-required/optional options should not be generated for hidden inputs' do
+  test 'required/aria-required/optional options does not be generated for hidden inputs' do
     with_input_for @user, :name, :hidden
     assert_no_select 'input.required'
     assert_no_select 'input[required]'

data/test/inputs/numeric_input_test.rb

@@ -1,141 +1,145 @@
+# frozen_string_literal: true
 # encoding: UTF-8
 require 'test_helper'
 
 class NumericInputTest < ActionView::TestCase
-  test 'input should generate an integer text field for integer attributes ' do
+  test 'input generates an integer text field for integer attributes ' do
     with_input_for @user, :age, :integer
     assert_select 'input[type=number].integer#user_age'
   end
 
-  test 'input should generate a float text field for float attributes ' do
+  test 'input generates a float text field for float attributes ' do
     with_input_for @user, :age, :float
     assert_select 'input[type=number].float#user_age'
   end
 
-  test 'input should generate a decimal text field for decimal attributes ' do
+  test 'input generates a decimal text field for decimal attributes ' do
     with_input_for @user, :age, :decimal
     assert_select 'input[type=number].decimal#user_age'
   end
 
-  test 'input should not generate min attribute by default' do
+  test 'input does not generate min attribute by default' do
     with_input_for @user, :age, :integer
     assert_no_select 'input[min]'
   end
 
-  test 'input should not generate max attribute by default' do
+  test 'input does not generate max attribute by default' do
     with_input_for @user, :age, :integer
     assert_no_select 'input[max]'
   end
 
-  test 'input should infer min value from integer attributes with greater than validation' do
+  test 'input infers min value from integer attributes with greater than validation' do
     with_input_for @other_validating_user, :age, :float
     assert_no_select 'input[min]'
 
     with_input_for @other_validating_user, :age, :integer
-    assert_select 'input[min=18]'
+    assert_select 'input[min="18"]'
   end
 
-  test 'input should infer min value from integer attributes with greater than validation using symbol' do
+  test 'input infers min value from integer attributes with greater than validation using symbol' do
     with_input_for @validating_user, :amount, :float
     assert_no_select 'input[min]'
 
     with_input_for @validating_user, :amount, :integer
-    assert_select 'input[min=11]'
+    assert_select 'input[min="11"]'
   end
 
-  test 'input should infer min value from integer attributes with greater than or equal to validation using symbol' do
+  test 'input infers min value from integer attributes with greater than or equal to validation using symbol' do
     with_input_for @validating_user, :attempts, :float
-    assert_select 'input[min=1]'
+    assert_select 'input[min="1"]'
 
     with_input_for @validating_user, :attempts, :integer
-    assert_select 'input[min=1]'
+    assert_select 'input[min="1"]'
   end
 
-  test 'input should infer min value from integer attributes with greater than validation using proc' do
+  test 'input infers min value from integer attributes with greater than validation using proc' do
     with_input_for @other_validating_user, :amount, :float
     assert_no_select 'input[min]'
 
     with_input_for @other_validating_user, :amount, :integer
-    assert_select 'input[min=20]'
+    assert_select 'input[min="20"]'
   end
 
-  test 'input should infer min value from integer attributes with greater than or equal to validation using proc' do
+  test 'input infers min value from integer attributes with greater than or equal to validation using proc' do
     with_input_for @other_validating_user, :attempts, :float
-    assert_select 'input[min=19]'
+    assert_select 'input[min="19"]'
 
     with_input_for @other_validating_user, :attempts, :integer
-    assert_select 'input[min=19]'
+    assert_select 'input[min="19"]'
   end
 
-  test 'input should infer max value from attributes with less than validation' do
+  test 'input infers max value from attributes with less than validation' do
     with_input_for @other_validating_user, :age, :float
     assert_no_select 'input[max]'
 
     with_input_for @other_validating_user, :age, :integer
-    assert_select 'input[max=99]'
+    assert_select 'input[max="99"]'
   end
 
-  test 'input should infer max value from attributes with less than validation using symbol' do
+  test 'input infers max value from attributes with less than validation using symbol' do
     with_input_for @validating_user, :amount, :float
     assert_no_select 'input[max]'
 
     with_input_for @validating_user, :amount, :integer
-    assert_select 'input[max=99]'
+    assert_select 'input[max="99"]'
   end
 
-  test 'input should infer max value from attributes with less than or equal to validation using symbol' do
+  test 'input infers max value from attributes with less than or equal to validation using symbol' do
     with_input_for @validating_user, :attempts, :float
-    assert_select 'input[max=100]'
+    assert_select 'input[max="100"]'
 
     with_input_for @validating_user, :attempts, :integer
-    assert_select 'input[max=100]'
+    assert_select 'input[max="100"]'
   end
 
-  test 'input should infer max value from attributes with less than validation using proc' do
+  test 'input infers max value from attributes with less than validation using proc' do
     with_input_for @other_validating_user, :amount, :float
     assert_no_select 'input[max]'
 
     with_input_for @other_validating_user, :amount, :integer
-    assert_select 'input[max=118]'
+    assert_select 'input[max="118"]'
   end
 
-  test 'input should infer max value from attributes with less than or equal to validation using proc' do
+  test 'input infers max value from attributes with less than or equal to validation using proc' do
     with_input_for @other_validating_user, :attempts, :float
-    assert_select 'input[max=119]'
+    assert_select 'input[max="119"]'
 
     with_input_for @other_validating_user, :attempts, :integer
-    assert_select 'input[max=119]'
+    assert_select 'input[max="119"]'
   end
 
-  test 'input should have step value of any except for integer attribute' do
+  test 'input has step value of any except for integer attribute' do
     with_input_for @validating_user, :age, :float
     assert_select 'input[step="any"]'
 
     with_input_for @validating_user, :age, :integer
-    assert_select 'input[step=1]'
+    assert_select 'input[step="1"]'
+
+    with_input_for @validating_user, :age, :integer, as: :decimal, input_html: { step: 0.5 }
+    assert_select 'input[step="0.5"]'
   end
 
-  test 'numeric input should not generate placeholder by default' do
+  test 'numeric input does not generate placeholder by default' do
     with_input_for @user, :age, :integer
     assert_no_select 'input[placeholder]'
   end
 
-  test 'numeric input should accept the placeholder option' do
+  test 'numeric input accepts the placeholder option' do
     with_input_for @user, :age, :integer, placeholder: 'Put in your age'
-    assert_select 'input.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
+  test 'numeric input uses i18n to translate placeholder text' do
     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]'
+      assert_select 'input.integer[placeholder="Age goes here"]'
     end
   end
 
   # Numeric input but HTML5 disabled
-  test ' when not using HTML5 input should not generate field with type number and use text instead' do
+  test 'when not using HTML5 input does not generate field with type number and use text instead' do
     swap_wrapper do
       with_input_for @user, :age, :integer
       assert_no_select "input[type=number]"
@@ -143,7 +147,7 @@ class NumericInputTest < ActionView::TestCase
     end
   end
 
-  test 'when not using HTML5 input should not use min or max or step attributes' do
+  test 'when not using HTML5 input does not use min or max or step attributes' do
     swap_wrapper do
       with_input_for @validating_user, :age, :integer
       assert_no_select "input[type=number]"
@@ -153,19 +157,19 @@ class NumericInputTest < ActionView::TestCase
     end
   end
 
-  [:integer, :float, :decimal].each do |type|
-    test "#{type} input should infer min value from attributes with greater than or equal validation" do
+  %i[integer float decimal].each do |type|
+    test "#{type} input infers min value from attributes with greater than or equal validation" do
       with_input_for @validating_user, :age, type
-      assert_select 'input[min=18]'
+      assert_select 'input[min="18"]'
     end
 
-    test "#{type} input should infer the max value from attributes with less than or equal to validation" do
+    test "#{type} input infers the max value from attributes with less than or equal to validation" do
       with_input_for @validating_user, :age, type
-      assert_select 'input[max=99]'
+      assert_select 'input[max="99"]'
     end
   end
 
-  test 'min_max should not emit max value as bare string' do
+  test 'min_max does not emit max value as bare string' do
     with_input_for @other_validating_user, :age, :integer
     assert_select 'input[max]'
     assert_no_select 'div', %r{^99}

data/test/inputs/priority_input_test.rb

@@ -1,49 +1,50 @@
+# frozen_string_literal: true
 # encoding: UTF-8
 require 'test_helper'
 
 class PriorityInputTest < ActionView::TestCase
-  test 'input should generate a country select field' do
+  test 'input generates a country select field' do
     with_input_for @user, :country, :country
     assert_select 'select#user_country'
-    assert_select 'select option[value=Brazil]', 'Brazil'
-    assert_no_select 'select option[value=][disabled=disabled]'
+    assert_select 'select option[value=BR]', 'Brazil'
+    assert_no_select 'select option[value=""][disabled=disabled]'
   end
 
-  test 'input should generate a country select with SimpleForm default' do
+  test 'input generates a country select with SimpleForm default' do
     swap SimpleForm, country_priority: [ 'Brazil' ] do
       with_input_for @user, :country, :country
-      assert_select 'select option[value=][disabled=disabled]'
+      assert_select 'select option[value="---------------"][disabled=disabled]'
     end
   end
 
-  test 'input should generate a time zone select field' do
+  test 'input generates a time zone select field' do
     with_input_for @user, :time_zone, :time_zone
     assert_select 'select#user_time_zone'
     assert_select 'select option[value=Brasilia]', '(GMT-03:00) Brasilia'
-    assert_no_select 'select option[value=][disabled=disabled]'
+    assert_no_select 'select option[value=""][disabled=disabled]'
   end
 
-  test 'input should generate a time zone select field with default' do
+  test 'input generates a time zone select field with default' do
     with_input_for @user, :time_zone, :time_zone, default: 'Brasilia'
     assert_select 'select option[value=Brasilia][selected=selected]'
-    assert_no_select 'select option[value=]'
+    assert_no_select 'select option[value=""]'
   end
 
-  test 'input should generate a time zone select using options priority' do
+  test 'input generates a time zone select using options priority' do
     with_input_for @user, :time_zone, :time_zone, priority: /Brasilia/
-    assert_select 'select option[value=][disabled=disabled]'
-    assert_no_select 'select option[value=]', /^$/
+    assert_select 'select option[value=""][disabled=disabled]'
+    assert_no_select 'select option[value=""]', /^$/
   end
 
-  test 'priority input should not generate invalid required html attribute' do
+  test 'priority input does generate select element with required html attribute' do
     with_input_for @user, :country, :country
     assert_select 'select.required'
-    assert_no_select 'select[required]'
+    assert_select 'select[required]'
   end
 
-  test 'priority input should not generate invalid aria-required html attribute' do
+  test 'priority input does generate select element with aria-required html attribute' do
     with_input_for @user, :country, :country
     assert_select 'select.required'
-    assert_no_select 'select[aria-required]'
+    assert_select 'select[aria-required]'
   end
 end

data/test/inputs/readonly_test.rb

@@ -1,98 +1,99 @@
+# frozen_string_literal: true
 require 'test_helper'
 
 class ReadonlyTest < ActionView::TestCase
-  test 'string input should generate readonly elements when readonly option is true' do
+  test 'string input generates readonly elements when readonly option is true' do
     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
+  test 'text input generates readonly elements when readonly option is true' do
     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
+  test 'numeric input generates readonly elements when readonly option is true' do
     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
+  test 'date input generates readonly elements when readonly option is true' do
     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
+  test 'datetime input generates readonly elements when readonly option is true' do
     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
+  test 'string input generates readonly elements when readonly option is false' do
     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
+  test 'text input generates readonly elements when readonly option is false' do
     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
+  test 'numeric input generates readonly elements when readonly option is false' do
     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
+  test 'date input generates readonly elements when readonly option is false' do
     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
+  test 'datetime input generates readonly elements when readonly option is false' do
     with_input_for @user, :created_at, :datetime, readonly: false
     assert_no_select 'select.datetime.readonly[readonly]'
   end
 
-  test 'string input should generate readonly elements when readonly option is not present' do
+  test 'string input generates readonly elements when readonly option is not present' do
     with_input_for @user, :name, :string
     assert_no_select 'input.string.readonly[readonly]'
   end
 
-  test 'text input should generate readonly elements when readonly option is not present' do
+  test 'text input generates readonly elements when readonly option is not present' do
     with_input_for @user, :description, :text
     assert_no_select 'textarea.text.readonly[readonly]'
   end
 
-  test 'numeric input should generate readonly elements when readonly option is not present' do
+  test 'numeric input generates readonly elements when readonly option is not present' do
     with_input_for @user, :age, :integer
     assert_no_select 'input.integer.readonly[readonly]'
   end
 
-  test 'date input should generate readonly elements when readonly option is not present' do
+  test 'date input generates readonly elements when readonly option is not present' do
     with_input_for @user, :born_at, :date
     assert_no_select 'select.date.readonly[readonly]'
   end
 
-  test 'datetime input should generate readonly elements when readonly option is not present' do
+  test 'datetime input generates readonly elements when readonly option is not present' do
     with_input_for @user, :created_at, :datetime
     assert_no_select 'select.datetime.readonly[readonly]'
   end
 
-  test 'input should generate readonly attribute when the field is readonly and the object is persisted' do
+  test 'input generates readonly attribute when the field is readonly and the object is persisted' do
     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
+  test 'input does 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
     assert_no_select 'input.string.readonly[readonly]'
   end
 
-  test 'input should not generate readonly attribute when the field is not readonly and the object is persisted' do
+  test 'input does not generate readonly attribute when the field is not readonly and the object is persisted' do
     with_input_for @user, :name, :string
     assert_no_select 'input.string.readonly[readonly]'
   end
 
-  test 'input should not generate readonly attribute when the component is not used' do
+  test 'input does not generate readonly attribute when the component is not used' do
     swap_wrapper do
       with_input_for @user, :credit_card, :string
       assert_no_select 'input.string.readonly[readonly]'