ehoch_simple_form 2.0.2.dev

data/test/inputs/required_test.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+
+class RequiredTest < ActionView::TestCase
+  # REQUIRED AND PRESENCE VALIDATION
+  test 'builder input should obtain required from ActiveModel::Validations when it is included' do
+    with_form_for @validating_user, :name
+    assert_select 'input.required[required]#validating_user_name'
+    with_form_for @validating_user, :status
+    assert_select 'input.optional#validating_user_status'
+  end
+
+  test 'builder input should allow overriding required when ActiveModel::Validations is included' do
+    with_form_for @validating_user, :name, :required => false
+    assert_select 'input.optional#validating_user_name'
+    with_form_for @validating_user, :status, :required => true
+    assert_select 'input.required[required]#validating_user_status'
+  end
+
+  test 'builder input should be required by default when ActiveModel::Validations is not included' do
+    with_form_for @user, :name
+    assert_select 'input.required[required]#user_name'
+  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
+      with_form_for @user, :name
+      assert_select 'input.optional#user_name'
+      assert_no_select 'input[required]'
+    end
+  end
+
+  test 'when not using browser validations, input should not generate required html attribute' 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]'
+    end
+  end
+
+  test 'builder input should allow disabling required when ActiveModel::Validations is not included' do
+    with_form_for @user, :name, :required => false
+    assert_no_select 'input.required'
+    assert_no_select 'input[required]'
+    assert_select 'input.optional#user_name'
+  end
+
+  test 'when not the required component the input does not have the required attribute but has the required class' do
+    swap_wrapper do
+      with_input_for @user, :name, :string
+      assert_select 'input[type=text].required'
+      assert_no_select 'input[type=text][required]'
+    end
+  end
+
+  # VALIDATORS :if :unless
+  test 'builder input should not be required when ActiveModel::Validations is included and if option is present' do
+    with_form_for @validating_user, :age
+    assert_no_select 'input.required'
+    assert_no_select 'input[required]'
+    assert_select 'input.optional#validating_user_age'
+  end
+
+  test 'builder input should not be required when ActiveModel::Validations is included and unless option is present' do
+    with_form_for @validating_user, :amount
+    assert_no_select 'input.required'
+    assert_no_select 'input[required]'
+    assert_select 'input.optional#validating_user_amount'
+  end
+
+  # VALIDATORS :on
+  test 'builder input should be required when validation is on create and is not persisted' do
+    @validating_user.new_record!
+    with_form_for @validating_user, :action
+    assert_select 'input.required'
+    assert_select 'input[required]'
+    assert_select 'input.required[required]#validating_user_action'
+  end
+
+  test 'builder input should not be required when validation is on create and is persisted' do
+    with_form_for @validating_user, :action
+    assert_no_select 'input.required'
+    assert_no_select 'input[required]'
+    assert_select 'input.optional#validating_user_action'
+  end
+
+  test 'builder input should be required when validation is on save' do
+    with_form_for @validating_user, :credit_limit
+    assert_select 'input.required'
+    assert_select 'input[required]'
+    assert_select 'input.required[required]#validating_user_credit_limit'
+
+    @validating_user.new_record!
+    with_form_for @validating_user, :credit_limit
+    assert_select 'input.required'
+    assert_select 'input[required]'
+    assert_select 'input.required[required]#validating_user_credit_limit'
+  end
+
+  test 'builder input should be required when validation is on update and is persisted' do
+    with_form_for @validating_user, :phone_number
+    assert_select 'input.required'
+    assert_select 'input[required]'
+    assert_select 'input.required[required]#validating_user_phone_number'
+  end
+
+  test 'builder input should not be required when validation is on update and is not persisted' do
+    @validating_user.new_record!
+    with_form_for @validating_user, :phone_number
+    assert_no_select 'input.required'
+    assert_no_select 'input[required]'
+    assert_select 'input.optional#validating_user_phone_number'
+  end
+end

data/test/inputs/string_input_test.rb

@@ -0,0 +1,140 @@
+# encoding: UTF-8
+require 'test_helper'
+
+class StringInputTest < ActionView::TestCase
+  test 'input should map 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!]"
+  end
+
+  test 'input should generate 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 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]'
+  end
+
+  test 'input should 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 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]'
+  end
+
+  test 'input should infer maxlength column definition from validation when present' do
+    with_input_for @validating_user, :name, :string
+    assert_select 'input.string[maxlength=25]'
+  end
+
+  test 'input should 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
+    with_input_for @validating_user, :home_picture, :string
+    assert_select 'input.string[maxlength=12]'
+  end
+
+  test 'input should 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
+    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'
+    assert_select 'input[type=password].password[placeholder=Password Confirmation]#user_password'
+  end
+
+  test 'input should 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
+    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
+    assert_select 'input[pattern="\w+"]'
+  end
+
+  test 'input should 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
+    with_input_for @other_validating_user, :country, :string, :input_html => { :pattern => "\\d+" }
+    assert_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'
+    } } }) do
+      with_input_for @user, :name, :string
+      assert_select 'input.string[placeholder=Name goes here]'
+    end
+  end
+
+  [:email, :url, :search, :tel].each do |type|
+    test "input should allow 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
+      swap_wrapper do
+        with_input_for @user, :name, type
+        assert_select "input[type=text]"
+        assert_no_select "input[type=#{type}]"
+      end
+    end
+  end
+
+  test 'input strips extra spaces from class html attribute with default classes' do
+    with_input_for @user, :name, :string
+    assert_select "input[class='string required']"
+    assert_no_select "input[class='string required ']"
+    assert_no_select "input[class=' string required']"
+  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" }
+    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']"
+  end
+end

data/test/inputs/text_input_test.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+require 'test_helper'
+
+class TextInputTest < ActionView::TestCase
+  test 'input should generate 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
+    with_input_for @user, :description, :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
+    with_input_for @user, :description, :text
+    assert_select 'textarea.text[maxlength=200]'
+  end
+
+  test 'input should infer maxlength column definition from validation when present for text attributes' do
+    with_input_for @validating_user, :description, :text
+    assert_select 'textarea.text[maxlength=50]'
+  end
+end

data/test/simple_form_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class SimpleFormTest < ActiveSupport::TestCase
+  test 'setup block yields self' do
+    SimpleForm.setup do |config|
+      assert_equal SimpleForm, config
+    end
+  end
+end

data/test/support/discovery_inputs.rb

@@ -0,0 +1,21 @@
+class StringInput < SimpleForm::Inputs::StringInput
+  def input
+    "<section>#{super}</section>".html_safe
+  end
+end
+
+class NumericInput < SimpleForm::Inputs::NumericInput
+  def input
+    "<section>#{super}</section>".html_safe
+  end
+end
+
+class CustomizedInput < SimpleForm::Inputs::StringInput
+  def input
+    "<section>#{super}</section>".html_safe
+  end
+
+  def input_method
+    :text_field
+  end
+end

data/test/support/misc_helpers.rb

@@ -0,0 +1,102 @@
+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 swap_wrapper(name=:default, wrapper=self.custom_wrapper)
+    old = SimpleForm.wrappers[name]
+    SimpleForm.wrappers[name] = wrapper
+    yield
+  ensure
+    SimpleForm.wrappers[name] = 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_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_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
+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

@@ -0,0 +1,24 @@
+class MockController
+  attr_writer :action_name
+
+  def _routes
+    self
+  end
+
+  def action_name
+    defined?(@action_name) ? @action_name : "edit"
+  end
+
+  def url_for(*args)
+    "http://example.com"
+  end
+
+  def url_helpers
+    self
+  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
+end

data/test/support/models.rb

@@ -0,0 +1,210 @@
+Column = Struct.new(:name, :type, :limit)
+Association = Struct.new(:klass, :name, :macro, :options)
+
+class Company < Struct.new(:id, :name)
+  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?
+    all
+  end
+
+  def self.merge_conditions(a, b)
+    (a || {}).merge(b || {})
+  end
+
+  def persisted?
+    true
+  end
+end
+
+class Tag < Company
+  def self.all(options={})
+    (1..3).map{|i| Tag.new(i, "Tag #{i}")}
+  end
+end
+
+class TagGroup < Struct.new(:id, :name, :tags)
+end
+
+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
+
+  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
+    end
+    Column.new(attribute, column_type, limit)
+  end
+
+  def self.human_attribute_name(attribute)
+    case attribute
+      when 'name'
+        'Super User Name!'
+      when 'description'
+        'User Description!'
+      when 'company'
+        'Company Human Name!'
+      else
+        attribute.humanize
+    end
+  end
+
+  def self.reflect_on_association(association)
+    case association
+      when :company
+        Association.new(Company, association, :belongs_to, {})
+      when :tags
+        Association.new(Tag, association, :has_many, {})
+      when :first_company
+        Association.new(Company, association, :has_one, {})
+      when :special_company
+        Association.new(Company, association, :belongs_to, { :conditions => { :id => 1 } })
+    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"]
+      )
+    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.new { |user| user.name }
+  validates :amount, :presence => true, :unless => Proc.new { |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
+  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
+
+  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.new { |user| user.age },
+    :less_than => Proc.new { |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+/
+
+  # 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
+end
+
+class HashBackedAuthor < Hash
+  extend ActiveModel::Naming
+  include ActiveModel::Conversion
+
+  def persisted?; false; end
+
+  def name
+    'hash backed author'
+  end
+end