simple_form 5.1.0 → 5.3.0

data/test/support/misc_helpers.rb

@@ -1,274 +0,0 @@
-# frozen_string_literal: true
-module MiscHelpers
-  def store_translations(locale, translations, &block)
-    I18n.backend.store_translations locale, translations
-    yield
-  ensure
-    I18n.reload!
-    I18n.backend.send :init_translations
-  end
-
-  def assert_no_select(selector, value = nil)
-    assert_select(selector, text: value, count: 0)
-  end
-
-  def swap(object, new_values)
-    old_values = {}
-    new_values.each do |key, value|
-      old_values[key] = object.send key
-      object.send :"#{key}=", value
-    end
-    yield
-  ensure
-    old_values.each do |key, value|
-      object.send :"#{key}=", value
-    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 = custom_wrapper)
-    old = SimpleForm.wrappers[name.to_s]
-    SimpleForm.wrappers[name.to_s] = wrapper
-    yield
-  ensure
-    SimpleForm.wrappers[name.to_s] = old
-  end
-
-  def custom_wrapper
-    SimpleForm.build tag: :section, class: "custom_wrapper", pattern: false do |b|
-      b.use :pattern
-      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" }
-      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
-    end
-  end
-
-  def custom_wrapper_without_top_level
-    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
-    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_wrapper_with_input_error_class
-    SimpleForm.build tag: :div, class: "custom_wrapper", error_class: :field_with_errors do |b|
-      b.use :label
-      b.use :input, class: 'inline-class', error_class: 'is-invalid'
-    end
-  end
-
-  def custom_wrapper_with_input_valid_class(valid_class: :field_without_errors)
-    SimpleForm.build tag: :div, class: "custom_wrapper", valid_class: valid_class do |b|
-      b.use :label
-      b.use :input, class: 'inline-class', valid_class: 'is-valid'
-    end
-  end
-
-  def custom_form_for(object, *args, &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)
-  end
-
-  def with_concat_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)
-    concat custom_form_for(*args, &block)
-  end
-
-  def with_concat_custom_mapping_form_for(*args, &block)
-    concat custom_mapping_form_for(*args, &block)
-  end
-
-  def with_form_for(object, *args, &block)
-    with_concat_form_for(object) do |f|
-      f.input(*args, &block)
-    end
-  end
-
-  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
-  end
-
-  def with_input_field_for(object, *args)
-    with_concat_form_for(object) do |f|
-      f.input_field(*args)
-    end
-  end
-end
-
-class CustomFormBuilder < SimpleForm::FormBuilder
-  def input(attribute_name, *args, &block)
-    super(attribute_name, *args, { input_html: { class: 'custom' } }, &block)
-  end
-end
-
-class CustomMapTypeFormBuilder < SimpleForm::FormBuilder
-  map_type :custom_type, to: SimpleForm::Inputs::StringInput
-end

data/test/support/mock_controller.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-class MockController
-  attr_writer :action_name
-
-  def _routes
-    self
-  end
-
-  def action_name
-    defined?(@action_name) ? @action_name : "edit"
-  end
-
-  def url_for(*)
-    "http://example.com"
-  end
-
-  def url_options
-    {}
-  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,357 +0,0 @@
-# frozen_string_literal: true
-Association = Struct.new(:klass, :name, :macro, :scope, :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
-
-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
-
-  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.all
-    Relation.new((1..3).map { |i| new(i, "#{name} #{i}") })
-  end
-
-  def persisted?
-    true
-  end
-end
-
-Friend = Struct.new(:id, :name) do
-  extend ActiveModel::Naming
-  include ActiveModel::Conversion
-
-  def self.all
-    (1..3).map { |i| new(i, "#{name} #{i}") }
-  end
-
-  def persisted?
-    true
-  end
-end
-
-class Tag < Company
-  def group_method
-    ["category-1"]
-  end
-end
-
-TagGroup = Struct.new(:id, :name, :tags)
-
-class User
-  extend ActiveModel::Naming
-  include ActiveModel::Conversion
-
-  attr_accessor :id, :name, :company, :company_id, :time_zone, :active, :age,
-    :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,
-    :extra_special_company_id, :pictures, :picture_ids, :special_pictures,
-    :special_picture_ids, :uuid, :friends, :friend_ids, :special_tags, :special_tag_ids,
-    :citext, :hstore, :json, :jsonb, :hourly, :favorite_color
-
-  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 = {})
-    @new_record = false
-    options.each do |key, value|
-      send("#{key}=", value)
-    end if options
-  end
-
-  def new_record!
-    @new_record = true
-  end
-
-  def persisted?
-    !@new_record
-  end
-
-  def company_attributes=(*)
-  end
-
-  def tags_attributes=(*)
-  end
-
-  def column_for_attribute(attribute)
-    column_type, limit = case attribute.to_sym
-      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 :timestamp
-      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
-      else attribute.to_sym
-    end
-    Column.new(attribute, column_type, limit)
-  end
-
-  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
-        when 'citext'        then :string
-        when 'hstore'        then [:text, 200]
-        when 'json'          then [:text, 200]
-        when 'jsonb'         then [:text, 200]
-      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,
-        :citext, :hstore, :json, :jsonb then true
-      else false
-    end
-  end
-
-  def self.human_attribute_name(attribute, options = {})
-    case attribute
-      when 'name', :name
-        'Super User Name!'
-      when 'description'
-        'User Description!'
-      when 'company'
-        'Company Human Name!'
-      else
-        attribute.to_s.humanize
-    end
-  end
-
-  def self.reflect_on_association(association)
-    case association
-      when :company
-        Association.new(Company, association, :belongs_to, nil, {})
-      when :tags
-        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, nil, {})
-      when :special_company
-        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
-      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"]
-  end
-end
-
-class ValidatingUser < User
-  include ActiveModel::Validations
-  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_numericality_of :age,
-    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
-  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, minimum: 5
-  validates_length_of :description, in: 15..50
-  validates_length_of :home_picture, is: 12
-
-  def min_amount
-    10
-  end
-
-  def max_amount
-    100
-  end
-
-  def min_attempts
-    1
-  end
-
-  def max_attempts
-    100
-  end
-end
-
-class OtherValidatingUser < User
-  include ActiveModel::Validations
-  validates_numericality_of :age,
-    greater_than: 17,
-    less_than: 100,
-    only_integer: true
-  validates_numericality_of :amount,
-    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 { |user| user.age },
-    less_than_or_equal_to: proc { |user| user.age + 100 },
-    only_integer: true
-
-  validates_format_of :country, with: /\w+/
-  validates_format_of :name, with: proc { /\w+/ }
-  validates_format_of :description, without: /\d+/
-end
-
-class HashBackedAuthor < Hash
-  extend ActiveModel::Naming
-  include ActiveModel::Conversion
-
-  def persisted?; false; end
-
-  def name
-    'hash backed author'
-  end
-end
-
-class UserNumber1And2 < User
-end
-
-class UserWithAttachment < User
-  def avatar_attachment
-    OpenStruct.new
-  end
-
-  def avatars_attachments
-    OpenStruct.new
-  end
-
-  def remote_cover_url
-    "/uploads/cover.png"
-  end
-
-  def profile_image_attacher
-    OpenStruct.new
-  end
-
-  def portrait_file_name
-    "portrait.png"
-  end
-end