formtastic 1.2.4 → 3.1.5

data/spec/inputs/base/collections_spec.rb

@@ -0,0 +1,76 @@
+require 'fast_spec_helper'
+require 'inputs/base/collections'
+
+class MyInput
+  include Formtastic::Inputs::Base::Collections
+end
+
+describe MyInput do
+  let(:builder) { double }
+  let(:template) { double }
+  let(:model_class) { double }
+  let(:model) { double(:class => model_class) }
+  let(:model_name) { "post" }
+  let(:method) { double }
+  let(:options) { Hash.new }
+  
+  let(:instance) { MyInput.new(builder, template, model, model_name, method, options) }
+
+  # class Whatever < ActiveRecord::Base
+  #   enum :status => [:active, :archived]
+  # end
+  #
+  # Whatever.statuses
+  #
+  # Whatever.new.status
+  #
+  # f.input :status
+  describe "#collection_from_enum" do
+    
+    let(:method) { :status }
+
+    context "when an enum is defined for the method" do
+      before do
+        statuses = ActiveSupport::HashWithIndifferentAccess.new("active"=>0, "inactive"=>1)
+        model_class.stub(:statuses) { statuses }
+        model.stub(:defined_enums) { {"status" => statuses } }
+      end
+
+      context 'no translations available' do
+        it 'returns an Array of EnumOption objects based on the enum options hash' do
+          instance.collection_from_enum.should eq [["Active", "active"],["Inactive", "inactive"]]
+        end
+      end
+
+      context 'with translations' do
+        before do
+          ::I18n.backend.store_translations :en, :activerecord => {
+            :attributes => {
+              :post => {
+                :statuses => {
+                  :active => "I am active",
+                  :inactive => "I am inactive"
+                }
+              }
+            }
+          }
+        end
+        it 'returns an Array of EnumOption objects based on the enum options hash' do
+          instance.collection_from_enum.should eq [["I am active", "active"],["I am inactive", "inactive"]]
+        end
+
+        after do
+          ::I18n.backend.store_translations :en, {}
+        end
+      end
+    end
+
+    context "when an enum is not defined" do
+      it 'returns nil' do
+        instance.collection_from_enum.should eq nil
+      end
+    end
+  end
+
+end
+

data/spec/inputs/base/validations_spec.rb

@@ -0,0 +1,342 @@
+require 'fast_spec_helper'
+require 'inputs/base/validations'
+
+class MyInput
+  include Formtastic::Inputs::Base::Validations
+end
+
+describe MyInput do
+  let(:builder) { double }
+  let(:template) { double }
+  let(:model_class) { double }
+  let(:model) { double(:class => model_class) }
+  let(:model_name) { "post" }
+  let(:method) { double }
+  let(:options) { Hash.new }
+  let(:validator) { double }
+  let(:instance) { MyInput.new(builder, template, model, model_name, method, options) }
+
+  describe '#required?' do
+    context 'with a single validator' do
+      before :each do
+        allow(instance).to receive(:validations?).and_return(:true)
+        allow(instance).to receive(:validations).and_return([validator])
+      end
+
+      context 'with options[:required] being true' do
+        let(:options) { {required: true} }
+
+        it 'is required' do
+          expect(instance.required?).to be_truthy
+        end
+      end
+
+      context 'with options[:required] being false' do
+        let(:options) { {required: false} }
+
+        it 'is not required' do
+          expect(instance.required?).to be_falsey
+        end
+      end
+
+      context 'with negated validation' do
+        it 'is not required' do
+          instance.not_required_through_negated_validation!
+          expect(instance.required?).to be_falsey
+        end
+      end
+
+      context 'with presence validator' do
+        let (:validator) { double(options: {}, kind: :presence) }
+
+        it 'is required' do
+          expect(instance.required?).to be_truthy
+        end
+
+        context 'with options[:on] as symbol' do
+          context 'with save context' do
+            let (:validator) { double(options: {on: :save}, kind: :presence) }
+
+            it 'is required' do
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with create context' do
+            let (:validator) { double(options: {on: :create}, kind: :presence) }
+
+            it 'is required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_truthy
+            end
+
+            it 'is not required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_falsey
+            end
+          end
+
+          context 'with update context' do
+            let (:validator) { double(options: {on: :update}, kind: :presence) }
+
+            it 'is not required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_falsey
+            end
+
+            it 'is required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_truthy
+            end
+          end
+        end
+
+        context 'with options[:on] as array' do
+          context 'with save context' do
+            let (:validator) { double(options: {on: [:save]}, kind: :presence) }
+
+            it 'is required' do
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with create context' do
+            let (:validator) { double(options: {on: [:create]}, kind: :presence) }
+
+            it 'is required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_truthy
+            end
+
+            it 'is not required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_falsey
+            end
+          end
+
+          context 'with update context' do
+            let (:validator) { double(options: {on: [:update]}, kind: :presence) }
+
+            it 'is not required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_falsey
+            end
+
+            it 'is required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with save and create context' do
+            let (:validator) { double(options: {on: [:save, :create]}, kind: :presence) }
+
+            it 'is required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_truthy
+            end
+
+            it 'is required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with save and update context' do
+            let (:validator) { double(options: {on: [:save, :create]}, kind: :presence) }
+
+            it 'is required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_truthy
+            end
+
+            it 'is required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with create and update context' do
+            let (:validator) { double(options: {on: [:create, :update]}, kind: :presence) }
+
+            it 'is required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_truthy
+            end
+
+            it 'is required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with save and other context' do
+            let (:validator) { double(options: {on: [:save, :foo]}, kind: :presence) }
+
+            it 'is required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_truthy
+            end
+
+            it 'is required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with create and other context' do
+            let (:validator) { double(options: {on: [:create, :foo]}, kind: :presence) }
+
+            it 'is required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_truthy
+            end
+
+            it 'is not required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_falsey
+            end
+          end
+
+          context 'with update and other context' do
+            let (:validator) { double(options: {on: [:update, :foo]}, kind: :presence) }
+
+            it 'is not required for new records' do
+              allow(model).to receive(:new_record?).and_return(true)
+              expect(instance.required?).to be_falsey
+            end
+
+            it 'is required for existing records' do
+              allow(model).to receive(:new_record?).and_return(false)
+              expect(instance.required?).to be_truthy
+            end
+          end
+        end
+      end
+
+      context 'with inclusion validator' do
+        context 'with allow blank' do
+          let (:validator) { double(options: {allow_blank: true}, kind: :inclusion) }
+
+          it 'is not required' do
+            expect(instance.required?).to be_falsey
+          end
+        end
+
+        context 'without allow blank' do
+          let (:validator) { double(options: {allow_blank: false}, kind: :inclusion) }
+
+          it 'is required' do
+            expect(instance.required?).to be_truthy
+          end
+        end
+      end
+
+      context 'with a length validator' do
+        context 'with allow blank' do
+          let (:validator) { double(options: {allow_blank: true}, kind: :length) }
+
+          it 'is not required' do
+            expect(instance.required?).to be_falsey
+          end
+        end
+
+        context 'without allow blank' do
+          let (:validator) { double(options: {allow_blank: false}, kind: :length) }
+
+          it 'is not required' do
+            expect(instance.required?).to be_falsey
+          end
+
+          context 'with a minimum > 0' do
+            let (:validator) { double(options: {allow_blank: false, minimum: 1}, kind: :length) }
+
+            it 'is required' do
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with a minimum <= 0' do
+            let (:validator) { double(options: {allow_blank: false, minimum: 0}, kind: :length) }
+
+            it 'is not required' do
+              expect(instance.required?).to be_falsey
+            end
+          end
+
+          context 'with a defined range starting with > 0' do
+            let (:validator) { double(options: {allow_blank: false, within: 1..5}, kind: :length) }
+
+            it 'is required' do
+              expect(instance.required?).to be_truthy
+            end
+          end
+
+          context 'with a defined range starting with <= 0' do
+            let (:validator) { double(options: {allow_blank: false, within: 0..5}, kind: :length) }
+
+            it 'is not required' do
+              expect(instance.required?).to be_falsey
+            end
+          end
+        end
+      end
+
+      context 'with another validator' do
+        let (:validator) { double(options: {allow_blank: true}, kind: :foo) }
+
+        it 'is not required' do
+          expect(instance.required?).to be_falsey
+        end
+      end
+    end
+
+    context 'with multiple validators' do
+      context 'with a on create presence validator and a on update presence validator' do
+        let (:validator1) { double(options: {on: :create}, kind: :presence) }
+        let (:validator2) { double(options: {}, kind: :presence) }
+
+        before :each do
+          allow(model).to receive(:new_record?).and_return(false)
+          allow(instance).to receive(:validations?).and_return(:true)
+          allow(instance).to receive(:validations).and_return([validator1, validator2])
+        end
+
+        it 'is required' do
+          expect(instance.required?).to be_truthy
+        end
+      end
+
+      context 'with a on create presence validator and a presence validator' do
+        let (:validator1) { double(options: {on: :create}, kind: :presence) }
+        let (:validator2) { double(options: {}, kind: :presence) }
+
+        before :each do
+          allow(model).to receive(:new_record?).and_return(false)
+          allow(instance).to receive(:validations?).and_return(:true)
+          allow(instance).to receive(:validations).and_return([validator1, validator2])
+        end
+
+        it 'is required' do
+          expect(instance.required?).to be_truthy
+        end
+      end
+
+      context 'with a on create presence validator and a allow blank inclusion validator' do
+        let (:validator1) { double(options: {on: :create}, kind: :presence) }
+        let (:validator2) { double(options: {allow_blank: true}, kind: :inclusion) }
+
+        before :each do
+          allow(model).to receive(:new_record?).and_return(false)
+          allow(instance).to receive(:validations?).and_return(:true)
+          allow(instance).to receive(:validations).and_return([validator1, validator2])
+        end
+
+        it 'is required' do
+          expect(instance.required?).to be_falsey
+        end
+      end
+    end
+  end
+end
+

data/spec/inputs/boolean_input_spec.rb

@@ -0,0 +1,254 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'boolean input' do
+
+  include FormtasticSpecHelper
+
+  before do
+    @output_buffer = ''
+    mock_everything
+  end
+
+  describe 'generic' do
+    before do
+      concat(semantic_form_for(@new_post) do |builder|
+        concat(builder.input(:allow_comments, :as => :boolean))
+      end)
+    end
+    
+    it_should_have_input_wrapper_with_class("boolean")
+    it_should_have_input_wrapper_with_class(:input)
+    it_should_have_input_wrapper_with_id("post_allow_comments_input")
+    it_should_apply_error_logic_for_input_type(:boolean)
+  
+    it 'should generate a label containing the input' do
+    output_buffer.should_not have_tag('label.label')
+    output_buffer.should have_tag('form li label', :count => 1)
+    output_buffer.should have_tag('form li label[@for="post_allow_comments"]')
+    output_buffer.should have_tag('form li label', /Allow comments/)
+    output_buffer.should have_tag('form li label input[@type="checkbox"]', :count => 1)
+    output_buffer.should have_tag('form li input[@type="hidden"]', :count => 1)
+    output_buffer.should_not have_tag('form li label input[@type="hidden"]', :count => 1) # invalid HTML5
+    end
+  
+    it 'should not add a "name" attribute to the label' do
+      output_buffer.should_not have_tag('form li label[@name]')
+    end
+  
+    it 'should generate a checkbox input' do
+      output_buffer.should have_tag('form li label input')
+      output_buffer.should have_tag('form li label input#post_allow_comments')
+      output_buffer.should have_tag('form li label input[@type="checkbox"]')
+      output_buffer.should have_tag('form li label input[@name="post[allow_comments]"]')
+      output_buffer.should have_tag('form li label input[@type="checkbox"][@value="1"]')
+    end
+  
+    it 'should generate a checked input if object.method returns true' do
+      output_buffer.should have_tag('form li label input[@checked="checked"]')
+      output_buffer.should have_tag('form li input[@name="post[allow_comments]"]', :count => 2)
+      output_buffer.should have_tag('form li input#post_allow_comments', :count => 1)
+    end
+  end
+
+  it 'should generate a checked input if :input_html is passed :checked => checked' do
+    concat(semantic_form_for(@new_post) do |builder|
+      concat(builder.input(:answer_comments, :as => :boolean, :input_html => {:checked => 'checked'}))
+    end)
+    output_buffer.should have_tag('form li label input[@checked="checked"]')
+  end
+
+  it 'should name the hidden input with the :name html_option' do
+    concat(semantic_form_for(@new_post) do |builder|
+      concat(builder.input(:answer_comments, :as => :boolean, :input_html => { :name => "foo" }))
+    end)
+
+    output_buffer.should have_tag('form li input[@type="checkbox"][@name="foo"]', :count => 1)
+    output_buffer.should have_tag('form li input[@type="hidden"][@name="foo"]', :count => 1)
+  end
+
+  it 'should name the hidden input with the :name html_option' do
+    concat(semantic_form_for(@new_post) do |builder|
+      concat(builder.input(:answer_comments, :as => :boolean, :input_html => { :name => "foo" }))
+    end)
+
+    output_buffer.should have_tag('form li input[@type="checkbox"][@name="foo"]', :count => 1)
+    output_buffer.should have_tag('form li input[@type="hidden"][@name="foo"]', :count => 1)
+  end
+
+  it "should generate a disabled input and hidden input if :input_html is passed :disabled => 'disabled' " do
+    concat(semantic_form_for(@new_post) do |builder|
+      concat(builder.input(:allow_comments, :as => :boolean, :input_html => {:disabled => 'disabled'}))
+    end)
+    output_buffer.should have_tag('form li label input[@disabled="disabled"]', :count => 1)
+    output_buffer.should have_tag('form li input[@type="hidden"][@disabled="disabled"]', :count => 1)
+  end
+
+  it 'should generate an input[id] with matching label[for] when id passed in :input_html' do
+    concat(semantic_form_for(@new_post) do |builder|
+      concat(builder.input(:allow_comments, :as => :boolean, :input_html => {:id => 'custom_id'}))
+    end)
+    output_buffer.should have_tag('form li label input[@id="custom_id"]')
+    output_buffer.should have_tag('form li label[@for="custom_id"]')
+  end
+
+  it 'should allow checked and unchecked values to be sent' do
+    concat(semantic_form_for(@new_post) do |builder|
+      concat(builder.input(:allow_comments, :as => :boolean, :checked_value => 'checked', :unchecked_value => 'unchecked'))
+    end)
+    output_buffer.should have_tag('form li label input[@type="checkbox"][@value="checked"]:not([@unchecked_value][@checked_value])')
+    output_buffer.should have_tag('form li input[@type="hidden"][@value="unchecked"]')
+    output_buffer.should_not have_tag('form li label input[@type="hidden"]') # invalid HTML5
+  end
+
+  it 'should generate a checked input if object.method returns checked value' do
+    @new_post.stub(:allow_comments).and_return('yes')
+
+    concat(semantic_form_for(@new_post) do |builder|
+      concat(builder.input(:allow_comments, :as => :boolean, :checked_value => 'yes', :unchecked_value => 'no'))
+    end)
+
+    output_buffer.should have_tag('form li label input[@type="checkbox"][@value="yes"][@checked="checked"]')
+  end
+
+  it 'should not generate a checked input if object.method returns unchecked value' do
+    @new_post.stub(:allow_comments).and_return('no')
+
+    concat(semantic_form_for(@new_post) do |builder|
+      concat(builder.input(:allow_comments, :as => :boolean, :checked_value => 'yes', :unchecked_value => 'no'))
+    end)
+
+    output_buffer.should have_tag('form li label input[@type="checkbox"][@value="yes"]:not([@checked])')
+  end
+
+  it 'should generate a checked input if object.method returns checked value' do
+    @new_post.stub(:allow_comments).and_return('yes')
+
+    concat(semantic_form_for(@new_post) do |builder|
+      concat(builder.input(:allow_comments, :as => :boolean, :checked_value => 'yes', :unchecked_value => 'no'))
+    end)
+
+    output_buffer.should have_tag('form li label input[@type="checkbox"][@value="yes"][@checked="checked"]')
+  end
+
+  it 'should generate a checked input for boolean database values compared to string checked values' do
+    @new_post.stub(:foo).and_return(1)
+
+    concat(semantic_form_for(@new_post) do |builder|
+      concat(builder.input(:foo, :as => :boolean))
+    end)
+
+    output_buffer.should have_tag('form li label input[@type="checkbox"][@value="1"][@checked="checked"]')
+  end
+
+  it 'should generate a checked input if object.method returns checked value when inverted' do
+    @new_post.stub(:allow_comments).and_return(0)
+
+    concat(semantic_form_for(@new_post) do |builder|
+      concat(builder.input(:allow_comments, :as => :boolean, :checked_value => 0, :unchecked_value => 1))
+    end)
+
+    output_buffer.should have_tag('form li label input[@type="checkbox"][@value="0"][@checked="checked"]')
+  end
+
+  it 'should not generate a checked input if object.method returns unchecked value' do
+    @new_post.stub(:allow_comments).and_return('no')
+
+    concat(semantic_form_for(@new_post) do |builder|
+      concat(builder.input(:allow_comments, :as => :boolean, :checked_value => 'yes', :unchecked_value => 'no'))
+    end)
+
+    output_buffer.should have_tag('form li label input[@type="checkbox"][@value="yes"]:not([@checked])')
+  end
+
+  it 'should generate a label and a checkbox even if no object is given' do
+    concat(semantic_form_for(:project, :url => 'http://test.host') do |builder|
+      concat(builder.input(:allow_comments, :as => :boolean))
+    end)
+
+    output_buffer.should have_tag('form li label[@for="project_allow_comments"]')
+    output_buffer.should have_tag('form li label', /Allow comments/)
+    output_buffer.should have_tag('form li label input[@type="checkbox"]')
+
+    output_buffer.should have_tag('form li label input#project_allow_comments')
+    output_buffer.should have_tag('form li label input[@type="checkbox"]')
+    output_buffer.should have_tag('form li label input[@name="project[allow_comments]"]')
+  end
+  
+  it 'should not pass input_html options down to the label html' do
+    concat(semantic_form_for(@new_post) do |builder|
+      builder.input(:title, :as => :boolean, :input_html => { :tabindex => 2, :x => "X" })
+    end)
+    output_buffer.should_not have_tag('label[tabindex]')
+    output_buffer.should_not have_tag('label[x]')
+  end
+
+  context "when required" do
+    
+    it "should add the required attribute to the input's html options" do
+      with_config :use_required_attribute, true do
+        concat(semantic_form_for(@new_post) do |builder|
+          concat(builder.input(:title, :as => :boolean, :required => true))
+        end)
+        output_buffer.should have_tag("input[@required]")
+      end
+    end
+      
+    it "should not add the required attribute to the boolean fields input's html options" do
+      with_config :use_required_attribute, true do
+        concat(semantic_form_for(@new_post) do |builder|
+          concat(builder.input(:title, :as => :boolean))
+        end)
+        output_buffer.should_not have_tag("input[@required]")
+      end
+    end
+    
+  end
+
+  describe "when namespace is provided" do
+
+    before do
+      @output_buffer = ''
+      mock_everything
+
+      concat(semantic_form_for(@new_post, :namespace => "context2") do |builder|
+        concat(builder.input(:allow_comments, :as => :boolean))
+      end)
+    end
+
+    it_should_have_input_wrapper_with_id("context2_post_allow_comments_input")
+    it_should_have_an_inline_label_for("context2_post_allow_comments")
+
+  end
+  
+  describe "when index is provided" do
+
+    before do
+      @output_buffer = ''
+      mock_everything
+
+      concat(semantic_form_for(@new_post) do |builder|
+        concat(builder.fields_for(:author, :index => 3) do |author|
+          concat(author.input(:name, :as => :boolean))
+        end)
+      end)
+    end
+    
+    it 'should index the id of the wrapper' do
+      output_buffer.should have_tag("li#post_author_attributes_3_name_input")
+    end
+    
+    it 'should index the id of the input tag' do
+      output_buffer.should have_tag("input#post_author_attributes_3_name")
+    end
+    
+    it 'should index the name of the hidden input' do
+      output_buffer.should have_tag("input[@type='hidden'][@name='post[author_attributes][3][name]']")
+    end
+
+    it 'should index the name of the checkbox input' do
+      output_buffer.should have_tag("input[@type='checkbox'][@name='post[author_attributes][3][name]']")
+    end
+    
+  end
+end