simple_form 3.0.1 → 3.1.0

data/test/inputs/string_input_test.rb

@@ -2,116 +2,136 @@
 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 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 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 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]"
+    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
+  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]'
+    assert_select 'input.string[placeholder="Put in some text"]'
   end
 
-  test 'input should generate a password field for password attributes that accept placeholder' do
+  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'
+    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
+  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
+  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
+  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 not use pattern if model has :without validation option' do
+  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 should use i18n to translate placeholder text' do
+  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
+
+  test 'input translates a key prefixed with _html and return the html markup' do
+    store_translations(:en, simple_form: { labels: { user: {
+      name_html: '<b>Name</b>'
+    } } }) do
+      with_input_for @user, :name, :string
+      assert_select 'label b', 'Name'
     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]"

data/test/inputs/text_input_test.rb

@@ -2,23 +2,23 @@
 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
+  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]'
+    assert_select 'textarea.text[placeholder="Put in some text"]'
   end
 
-  test 'input should get maxlength from column definition for text attributes' do
+  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

@@ -46,12 +46,12 @@ module MiscHelpers
     end
   end
 
-  def swap_wrapper(name=:default, wrapper=self.custom_wrapper)
-    old = SimpleForm.wrappers[name]
-    SimpleForm.wrappers[name] = wrapper
+  def swap_wrapper(name = :default, wrapper = self.custom_wrapper)
+    old = SimpleForm.wrappers[name.to_s]
+    SimpleForm.wrappers[name.to_s] = wrapper
     yield
   ensure
-    SimpleForm.wrappers[name] = old
+    SimpleForm.wrappers[name.to_s] = old
   end
 
   def custom_wrapper
@@ -68,6 +68,48 @@ module MiscHelpers
     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
+    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|
@@ -112,6 +154,36 @@ module MiscHelpers
     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_form_for(object, *args, &block)
     simple_form_for(object, *args, { builder: CustomFormBuilder }, &block)
   end
@@ -142,7 +214,7 @@ 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))
     end

data/test/support/models.rb

@@ -1,4 +1,4 @@
-Association = Struct.new(:klass, :name, :macro, :options)
+Association = Struct.new(:klass, :name, :macro, :scope, :options)
 
 Column = Struct.new(:name, :type, :limit) do
   # Returns +true+ if the column is either of type integer, float or decimal.
@@ -7,16 +7,36 @@ Column = Struct.new(:name, :type, :limit) do
   end
 end
 
-Relation = Struct.new(:all) do
+Relation = Struct.new(:records) do
+  delegate :each, to: :records
+
   def where(conditions = nil)
-    self.class.new conditions ? all.first : all
+    self.class.new conditions ? records.first : records
   end
 
   def order(conditions = nil)
-    self.class.new conditions ? all.last : all
+    self.class.new conditions ? records.last : records
+  end
+
+  alias_method :to_a,   :records
+  alias_method :to_ary, :records
+end
+
+Picture = Struct.new(:id, :name) do
+  extend ActiveModel::Naming
+  include ActiveModel::Conversion
+
+  def self.where(conditions = nil)
+    if conditions.is_a?(Hash) && conditions[:name]
+      all.to_a.last
+    else
+      all
+    end
   end
 
-  alias_method :to_a, :all
+  def self.all
+    Relation.new((1..3).map { |i| new(i, "#{name} #{i}") })
+  end
 end
 
 Company = Struct.new(:id, :name) do
@@ -28,11 +48,11 @@ Company = Struct.new(:id, :name) do
   end
 
   def self._relation
-    Relation.new(all)
+    all
   end
 
   def self.all
-    (1..3).map { |i| new(i, "#{name} #{i}") }
+    Relation.new((1..3).map { |i| new(i, "#{name} #{i}") })
   end
 
   def persisted?
@@ -53,7 +73,8 @@ class User
     :delivery_time, :born_at, :special_company_id, :country, :tags, :tag_ids,
     :avatar, :home_picture, :email, :status, :residence_country, :phone_number,
     :post_count, :lock_version, :amount, :attempts, :action, :credit_card, :gender,
-    :extra_special_company_id
+    :extra_special_company_id, :pictures, :picture_ids, :special_pictures,
+    :special_picture_ids, :uuid
 
   def self.build(extra_attributes = {})
     attributes = {
@@ -66,7 +87,7 @@ class User
     new attributes
   end
 
-  def initialize(options={})
+  def initialize(options = {})
     @new_record = false
     options.each do |key, value|
       send("#{key}=", value)
@@ -104,11 +125,22 @@ class User
       when :attempts      then :integer
       when :action        then :string
       when :credit_card   then :string
+      when :uuid          then :uuid
     end
     Column.new(attribute, column_type, limit)
   end
 
-  def self.human_attribute_name(attribute)
+  def has_attribute?(attribute)
+    case attribute.to_sym
+      when :name, :status, :password, :description, :age,
+        :credit_limit, :active, :born_at, :delivery_time,
+        :created_at, :updated_at, :lock_version, :home_picture,
+        :amount, :attempts, :action, :credit_card, :uuid then true
+      else false
+    end
+  end
+
+  def self.human_attribute_name(attribute, options = {})
     case attribute
       when 'name'
         'Super User Name!'
@@ -117,35 +149,39 @@ class User
       when 'company'
         'Company Human Name!'
       else
-        attribute.humanize
+        attribute.to_s.humanize
     end
   end
 
   def self.reflect_on_association(association)
     case association
       when :company
-        Association.new(Company, association, :belongs_to, {})
+        Association.new(Company, association, :belongs_to, nil, {})
       when :tags
-        Association.new(Tag, association, :has_many, {})
+        Association.new(Tag, association, :has_many, nil, {})
       when :first_company
-        Association.new(Company, association, :has_one, {})
+        Association.new(Company, association, :has_one, nil, {})
       when :special_company
-        Association.new(Company, association, :belongs_to, { conditions: { id: 1 } })
+        Association.new(Company, association, :belongs_to, nil, { conditions: { id: 1 } })
       when :extra_special_company
-        Association.new(Company, association, :belongs_to, { conditions: proc { { id: 1 } } })
+        Association.new(Company, association, :belongs_to, nil, { conditions: proc { { id: self.id } } })
+      when :pictures
+        Association.new(Picture, association, :has_many, nil, {})
+      when :special_pictures
+        Association.new(Picture, association, :has_many, proc { where(name: self.name) }, {})
     end
   end
 
   def errors
     @errors ||= begin
-      hash = Hash.new { |h,k| h[k] = [] }
-      hash.merge!(
-        name: ["can't be blank"],
-        description: ["must be longer than 15 characters"],
-        age: ["is not a number", "must be greater than 18"],
-        company: ["company must be present"],
-        company_id: ["must be valid"]
-      )
+      errors = ActiveModel::Errors.new(self)
+      errors.add(:name, "cannot be blank")
+      errors.add(:description, 'must be longer than 15 characters')
+      errors.add(:age, 'is not a number')
+      errors.add(:age, 'must be greater than 18')
+      errors.add(:company, 'company must be present')
+      errors.add(:company_id, 'must be valid')
+      errors
     end
   end
 

data/test/test_helper.rb

@@ -5,6 +5,8 @@ require 'minitest/autorun'
 require 'active_model'
 require 'action_controller'
 require 'action_view'
+ActionView::RoutingUrlFor.send(:include, ActionDispatch::Routing::UrlFor)
+
 require 'action_view/template'
 
 require 'action_view/test_case'
@@ -28,7 +30,11 @@ I18n.default_locale = :en
 
 require 'country_select'
 
-ActionDispatch::Assertions::NO_STRIP << "label"
+if defined?(HTMLSelector::NO_STRIP)
+  HTMLSelector::NO_STRIP << "label"
+else
+  ActionDispatch::Assertions::NO_STRIP << "label"
+end
 
 class ActionView::TestCase
   include MiscHelpers