simple_form 2.0.0 → 3.5.1

data/test/support/misc_helpers.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module MiscHelpers
   def store_translations(locale, translations, &block)
     I18n.backend.store_translations locale, translations
@@ -8,7 +9,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,46 +25,201 @@ module MiscHelpers
     end
   end
 
-  def swap_wrapper(name=:default, wrapper=self.custom_wrapper)
-    old = SimpleForm.wrappers[name]
-    SimpleForm.wrappers[name] = wrapper
+  def stub_any_instance(klass, method, value)
+    klass.class_eval do
+      alias_method :"new_#{method}", method
+
+      define_method(method) do
+        if value.respond_to?(:call)
+          value.call
+        else
+          value
+        end
+      end
+    end
+
+    yield
+  ensure
+    klass.class_eval do
+      undef_method method
+      alias_method method, :"new_#{method}"
+      undef_method :"new_#{method}"
+    end
+  end
+
+  def swap_wrapper(name = :default, wrapper = custom_wrapper)
+    old = SimpleForm.wrappers[name.to_s]
+    SimpleForm.wrappers[name.to_s] = wrapper
     yield
   ensure
-    SimpleForm.wrappers[name] = old
+    SimpleForm.wrappers[name.to_s] = old
   end
 
   def custom_wrapper
-    SimpleForm.build :tag => :section, :class => "custom_wrapper", :pattern => false do |b|
+    SimpleForm.build tag: :section, class: "custom_wrapper", pattern: false do |b|
       b.use :pattern
-      b.wrapper :another, :class => "another_wrapper" do |ba|
+      b.wrapper :another, class: "another_wrapper" do |ba|
         ba.use :label
         ba.use :input
       end
-      b.wrapper :error_wrapper, :tag => :div, :class => "error_wrapper" do |be|
-        be.use :error, :wrap_with => { :tag => :span, :class => "omg_error" }
+      b.wrapper :error_wrapper, tag: :div, class: "error_wrapper" do |be|
+        be.use :error, wrap_with: { tag: :span, class: "omg_error" }
+      end
+      b.use :hint, wrap_with: { class: "omg_hint" }
+    end
+  end
+
+  def custom_wrapper_with_wrapped_optional_component
+    SimpleForm.build tag: :section, class: "custom_wrapper" do |b|
+      b.wrapper tag: :div, class: 'no_output_wrapper' do |ba|
+        ba.optional :hint, wrap_with: { tag: :p, class: 'omg_hint' }
+      end
+    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_input_data_modal
+    SimpleForm.build tag: :div, class: "custom_wrapper" do |b|
+      b.use :label
+      b.use :input, data: { modal: 'data-modal', wrapper: 'data-wrapper' }
+    end
+  end
+
+  def custom_wrapper_with_input_aria_modal
+    SimpleForm.build tag: :div, class: "custom_wrapper" do |b|
+      b.use :label
+      b.use :input, aria: { modal: 'aria-modal', wrapper: 'aria-wrapper' }
+    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|
+        component.use :label
+        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' }
+        component.use :input
       end
-      b.use :hint, :wrap_with => { :class => "omg_hint" }
     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 }
+    end
+  end
+
+  def custom_wrapper_without_class
+    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|
+      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 }
+    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
-      b.use :hint,  :wrap_with => { :tag => :span, :class => :hint }
-      b.use :error, :wrap_with => { :tag => :span, :class => :error }
+    end
+  end
+
+  def custom_wrapper_with_custom_label_component
+    SimpleForm.build tag: :span, class: 'custom_wrapper' do |b|
+      b.use :label_text
+    end
+  end
+
+  def custom_wrapper_with_html5_components
+    SimpleForm.build tag: :span, class: 'custom_wrapper' do |b|
+      b.use :label_text
+    end
+  end
+
+  def custom_wrapper_with_required_input
+    SimpleForm.build tag: :span, class: 'custom_wrapper' do |b|
+      b.use :html5
+      b.use :input, required: true
     end
   end
 
   def custom_form_for(object, *args, &block)
-    simple_form_for(object, *(args << { :builder => CustomFormBuilder }), &block)
+    simple_form_for(object, *args, { builder: CustomFormBuilder }, &block)
   end
 
   def custom_mapping_form_for(object, *args, &block)
-    simple_form_for(object, *(args << { :builder => CustomMapTypeFormBuilder }), &block)
+    simple_form_for(object, *args, { builder: CustomMapTypeFormBuilder }, &block)
   end
 
   def with_concat_form_for(*args, &block)
-    concat simple_form_for(*args, &block)
+    concat simple_form_for(*args, &(block || proc {}))
+  end
+
+  def with_concat_fields_for(*args, &block)
+    concat simple_fields_for(*args, &block)
   end
 
   def with_concat_custom_form_for(*args, &block)
@@ -80,19 +236,19 @@ module MiscHelpers
     end
   end
 
-  def with_input_for(object, attribute_name, type, options={})
+  def with_input_for(object, attribute_name, type, options = {})
     with_concat_form_for(object) do |f|
-      f.input(attribute_name, options.merge(:as => type))
+      f.input(attribute_name, options.merge(as: type))
     end
   end
 end
 
 class CustomFormBuilder < SimpleForm::FormBuilder
   def input(attribute_name, *args, &block)
-    super(attribute_name, *(args << { :input_html => { :class => 'custom' } }), &block)
+    super(attribute_name, *args, { input_html: { class: 'custom' } }, &block)
   end
 end
 
 class CustomMapTypeFormBuilder < SimpleForm::FormBuilder
-  map_type :custom_type, :to => SimpleForm::Inputs::StringInput
+  map_type :custom_type, to: SimpleForm::Inputs::StringInput
 end

data/test/support/mock_controller.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class MockController
   attr_writer :action_name
 
@@ -9,16 +10,21 @@ class MockController
     defined?(@action_name) ? @action_name : "edit"
   end
 
-  def url_for(*args)
+  def url_for(*)
     "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 polymorphic_mappings(*); {}; 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

data/test/support/models.rb

@@ -1,23 +1,61 @@
-require 'ostruct'
+# frozen_string_literal: true
+Association = Struct.new(:klass, :name, :macro, :scope, :options)
 
-Column = Struct.new(:name, :type, :limit)
-Association = Struct.new(:klass, :name, :macro, :options)
+Column = Struct.new(:name, :type, :limit) do
+end
+
+Relation = Struct.new(:records) do
+  delegate :each, to: :records
+
+  def where(conditions = nil)
+    self.class.new conditions ? [records.first] : records
+  end
+
+  def order(conditions = nil)
+    self.class.new conditions ? records.last : records
+  end
+
+  alias_method :to_a,   :records
+  alias_method :to_ary, :records
+end
+
+Decorator = Struct.new(:object) do
+  def to_model
+    object
+  end
+end
 
-class Company < Struct.new(:id, :name)
+Picture = Struct.new(:id, :name) do
   extend ActiveModel::Naming
   include ActiveModel::Conversion
 
-  def self.all(options={})
-    all = (1..3).map{|i| Company.new(i, "Company #{i}")}
-    return [all.first] if options[:conditions].present?
-    return [all.last]  if options[:order].present?
-    return all[0..1] if options[:include].present?
-    return all[1..2] if options[:joins].present?
+  def self.where(conditions = nil)
+    if conditions.is_a?(Hash) && conditions[:name]
+      all.to_a.last
+    else
+      all
+    end
+  end
+
+  def self.all
+    Relation.new((1..3).map { |i| new(i, "#{name} #{i}") })
+  end
+end
+
+Company = Struct.new(:id, :name) do
+  extend ActiveModel::Naming
+  include ActiveModel::Conversion
+
+  class << self
+    delegate :order, :where, to: :_relation
+  end
+
+  def self._relation
     all
   end
 
-  def self.merge_conditions(a, b)
-    (a || {}).merge(b || {})
+  def self.all
+    Relation.new((1..3).map { |i| new(i, "#{name} #{i}") })
   end
 
   def persisted?
@@ -25,15 +63,23 @@ class Company < Struct.new(:id, :name)
   end
 end
 
-class Tag < Company
-  def self.all(options={})
-    (1..3).map{|i| Tag.new(i, "Tag #{i}")}
+Friend = Struct.new(:id, :name) do
+  extend ActiveModel::Naming
+  include ActiveModel::Conversion
+
+  def self.all
+    (1..3).map { |i| new(i, "#{name} #{i}") }
   end
-end
 
-class TagGroup < Struct.new(:id, :name, :tags)
+  def persisted?
+    true
+  end
 end
 
+class Tag < Company; end
+
+TagGroup = Struct.new(:id, :name, :tags)
+
 class User
   extend ActiveModel::Naming
   include ActiveModel::Conversion
@@ -42,9 +88,22 @@ class User
     :description, :created_at, :updated_at, :credit_limit, :password, :url,
     :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
+    :post_count, :lock_version, :amount, :attempts, :action, :credit_card, :gender,
+    :extra_special_company_id, :pictures, :picture_ids, :special_pictures,
+    :special_picture_ids, :uuid, :friends, :friend_ids, :special_tags, :special_tag_ids
+
+  def self.build(extra_attributes = {})
+    attributes = {
+      id: 1,
+      name: 'New in SimpleForm!',
+      description: 'Hello!',
+      created_at: Time.now
+    }.merge! extra_attributes
+
+    new attributes
+  end
 
-  def initialize(options={})
+  def initialize(options = {})
     @new_record = false
     options.each do |key, value|
       send("#{key}=", value)
@@ -82,11 +141,58 @@ 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)
+  begin
+    require 'active_model/type'
+    begin
+      ActiveModel::Type.lookup(:text)
+    rescue ArgumentError        # :text is no longer an ActiveModel::Type
+      # But we don't want our tests to depend on ActiveRecord
+      class ::ActiveModel::Type::Text < ActiveModel::Type::String
+        def type; :text; end
+      end
+      ActiveModel::Type.register(:text, ActiveModel::Type::Text)
+    end
+    def type_for_attribute(attribute)
+      column_type, limit = case attribute
+        when 'name', 'status', 'password' then [:string, 100]
+        when 'description'   then [:text, 200]
+        when 'age'           then :integer
+        when 'credit_limit'  then [:decimal, 15]
+        when 'active'        then :boolean
+        when 'born_at'       then :date
+        when 'delivery_time' then :time
+        when 'created_at'    then :datetime
+        when 'updated_at'    then :datetime
+        when 'lock_version'  then :integer
+        when 'home_picture'  then :string
+        when 'amount'        then :integer
+        when 'attempts'      then :integer
+        when 'action'        then :string
+        when 'credit_card'   then :string
+        when 'uuid'          then :string
+      end
+
+      ActiveModel::Type.lookup(column_type, limit: limit)
+    end
+  rescue LoadError
+  end
+
+  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!'
@@ -95,68 +201,80 @@ 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 :special_tags
+        Association.new(Tag, association, :has_many, ->(user) { where(id: user.id) }, {})
       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, 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) }, {})
+      when :friends
+        Association.new(Friend, association, :has_many, nil, {})
     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
 
   def self.readonly_attributes
-    [:credit_card]
+    ["credit_card"]
   end
 end
 
 class ValidatingUser < User
   include ActiveModel::Validations
-  validates :name, :presence => true
-  validates :company, :presence => true
-  validates :age, :presence => true, :if => Proc.new { |user| user.name }
-  validates :amount, :presence => true, :unless => Proc.new { |user| user.age }
+  validates :name, presence: true
+  validates :company, presence: true
+  validates :age, presence: true, if: proc { |user| user.name }
+  validates :amount, presence: true, unless: proc { |user| user.age }
 
-  validates :action,            :presence => true, :on => :create
-  validates :credit_limit,      :presence => true, :on => :save
-  validates :phone_number,      :presence => true, :on => :update
+  validates :action,            presence: true, on: :create
+  validates :credit_limit,      presence: true, on: :save
+  validates :phone_number,      presence: true, on: :update
 
   validates_numericality_of :age,
-    :greater_than_or_equal_to => 18,
-    :less_than_or_equal_to => 99,
-    :only_integer => true
+    greater_than_or_equal_to: 18,
+    less_than_or_equal_to: 99,
+    only_integer: true
   validates_numericality_of :amount,
-    :greater_than => :min_amount,
-    :less_than => :max_amount,
-    :only_integer => true
+    greater_than: :min_amount,
+    less_than: :max_amount,
+    only_integer: true
   validates_numericality_of :attempts,
-    :greater_than_or_equal_to => :min_attempts,
-    :less_than_or_equal_to => :max_attempts,
-    :only_integer => true
-  validates_length_of :name, :maximum => 25
-  validates_length_of :description, :maximum => 50
-  validates_length_of :action, :maximum => 10, :tokenizer => lambda { |str| str.scan(/\w+/) }
-  validates_length_of :home_picture, :is => 12
+    greater_than_or_equal_to: :min_attempts,
+    less_than_or_equal_to: :max_attempts,
+    only_integer: true
+  validates_length_of :name, maximum: 25, minimum: 5
+  validates_length_of :description, in: 15..50
+  if ActionPack::VERSION::STRING < '5'
+    validates_length_of :action, maximum: 10, tokenizer: ->(str) { str.scan(/\w+/) }
+  end
+  validates_length_of :home_picture, is: 12
 
   def min_amount
     10
@@ -178,26 +296,21 @@ end
 class OtherValidatingUser < User
   include ActiveModel::Validations
   validates_numericality_of :age,
-    :greater_than => 17,
-    :less_than => 100,
-    :only_integer => true
+    greater_than: 17,
+    less_than: 100,
+    only_integer: true
   validates_numericality_of :amount,
-    :greater_than => Proc.new { |user| user.age },
-    :less_than => Proc.new { |user| user.age + 100},
-    :only_integer => true
+    greater_than: proc { |user| user.age },
+    less_than: proc { |user| user.age + 100 },
+    only_integer: true
   validates_numericality_of :attempts,
-    :greater_than_or_equal_to => Proc.new { |user| user.age },
-    :less_than_or_equal_to => Proc.new { |user| user.age + 100},
-    :only_integer => true
-
-  validates_format_of :country, :with => /\w+/
+    greater_than_or_equal_to: proc { |user| user.age },
+    less_than_or_equal_to: proc { |user| user.age + 100 },
+    only_integer: true
 
-  # TODO: Remove this check when we drop Rails 3.0 support
-  if ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR >= 1
-    validates_format_of :name, :with => Proc.new { /\w+/ }
-  else
-    validates_format_of :name, :with => /\w+/
-  end
+  validates_format_of :country, with: /\w+/
+  validates_format_of :name, with: proc { /\w+/ }
+  validates_format_of :description, without: /\d+/
 end
 
 class HashBackedAuthor < Hash
@@ -210,3 +323,6 @@ class HashBackedAuthor < Hash
     'hash backed author'
   end
 end
+
+class UserNumber1And2 < User
+end