formtastic 3.1.3 → 3.1.4

data/spec/fast_spec_helper.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+$LOAD_PATH << 'lib/formtastic'
+require 'active_support/all'
+require 'localized_string'
+require 'inputs'
+require 'helpers'
+
+class MyInput
+  include Formtastic::Inputs::Base
+end
+
+I18n.enforce_available_locales = false if I18n.respond_to?(:enforce_available_locales)

data/spec/generators/formtastic/input/input_generator_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+require 'generators/formtastic/input/input_generator'
+
+describe Formtastic::InputGenerator do
+  include FormtasticSpecHelper
+
+  destination File.expand_path("../../../../../tmp", __FILE__)
+
+  before do
+    prepare_destination
+  end
+
+  after do
+    FileUtils.rm_rf(File.expand_path("../../../../../tmp", __FILE__))
+  end
+
+  describe 'without file name' do
+    it 'should raise Thor::RequiredArgumentMissingError' do
+      lambda { run_generator }.should raise_error(Thor::RequiredArgumentMissingError)
+    end
+  end
+
+  describe "input generator with underscore definition" do
+    before { run_generator %w(hat_size)}
+
+    describe 'generate an input in its respective folder' do
+      subject{ file('app/inputs/hat_size_input.rb')}
+      it { should exist}
+      it { should contain "class HatSizeInput"}
+      it { should contain "def to_html"}
+      it { should contain "include Formtastic::Inputs::Base"}
+      it { should_not contain "super"}
+    end
+  end
+
+  describe "input generator with camelcase definition" do
+    before { run_generator %w(HatSize)}
+
+    describe 'generate an input in its respective folder' do
+      subject{ file('app/inputs/hat_size_input.rb')}
+      it { should exist}
+      it { should contain "class HatSizeInput"}
+    end
+  end
+
+  describe "input generator with camelcase Input name sufixed" do
+    before { run_generator %w(HatSizeInput)}
+
+    describe 'generate an input in its respective folder' do
+      subject{ file('app/inputs/hat_size_input.rb')}
+      it { should exist}
+      it { should contain "class HatSizeInput"}
+    end
+  end
+
+  describe "input generator with underscore _input name sufixed" do
+    before { run_generator %w(hat_size_input)}
+
+    describe 'generate an input in its respective folder' do
+      subject{ file('app/inputs/hat_size_input.rb')}
+      it { should exist}
+      it { should contain "class HatSizeInput"}
+    end
+  end
+
+  describe "input generator with underscore input name sufixed" do
+    before { run_generator %w(hat_sizeinput)}
+
+    describe 'generate an input in its respective folder' do
+      subject{ file('app/inputs/hat_size_input.rb')}
+      it { should exist}
+      it { should contain "class HatSizeInput"}
+    end
+  end
+
+  describe "override an existing input using extend" do
+    before { run_generator %w(string --extend)}
+
+    describe 'app/inputs/string_input.rb' do
+      subject{ file('app/inputs/string_input.rb')}
+      it { should exist }
+      it { should contain "class StringInput < Formtastic::Inputs::StringInput" }
+      it { should contain "def to_html" }
+      it { should_not contain "include Formtastic::Inputs::Base" }
+      it { should contain "super" }
+      it { should_not contain "def input_html_options" }
+    end
+  end
+
+  describe "extend an existing input" do
+    before { run_generator %w(FlexibleText --extend string)}
+
+    describe 'app/inputs/flexible_text_input.rb' do
+      subject{ file('app/inputs/flexible_text_input.rb')}
+      it { should contain "class FlexibleTextInput < Formtastic::Inputs::StringInput" }
+      it { should contain "def input_html_options" }
+      it { should_not contain "include Formtastic::Inputs::Base" }
+      it { should_not contain "def to_html" }
+    end
+  end
+
+  describe "provide a slashed namespace" do
+    before { run_generator %w(stuff/foo)}
+
+    describe 'app/inputs/stuff/foo_input.rb' do
+      subject{ file('app/inputs/stuff/foo_input.rb')}
+      it {should exist}
+      it { should contain "class Stuff::FooInput" }
+      it { should contain "include Formtastic::Inputs::Base" }
+    end
+  end
+
+  describe "provide a camelized namespace" do
+    before { run_generator %w(Stuff::Foo)}
+
+    describe 'app/inputs/stuff/foo_input.rb' do
+      subject{ file('app/inputs/stuff/foo_input.rb')}
+      it {should exist}
+      it { should contain "class Stuff::FooInput" }
+      it { should contain "include Formtastic::Inputs::Base" }
+    end
+  end
+end

data/spec/helpers/form_helper_spec.rb

@@ -24,7 +24,7 @@ describe 'FormHelper' do
       output_buffer.should have_tag("form.formtastic")
     end
 
-    it 'adds a "novalidate" attribute to the generated form when configured to do so' do
+    it 'does not add "novalidate" attribute to the generated form when configured to do so' do
       with_config :perform_browser_validations, true do
         concat(semantic_form_for(@new_post, :url => '/hello') do |builder|
         end)
@@ -32,7 +32,7 @@ describe 'FormHelper' do
       end
     end
 
-    it 'omits a "novalidate" attribute to the generated form when configured to do so' do
+    it 'adds "novalidate" attribute to the generated form when configured to do so' do
       with_config :perform_browser_validations, false do
         concat(semantic_form_for(@new_post, :url => '/hello') do |builder|
         end)
@@ -40,7 +40,7 @@ describe 'FormHelper' do
       end
     end
 
-    it 'allows form HTML to override "novalidate" attribute when configure to not show' do
+    it 'allows form HTML to override "novalidate" attribute when configured to validate' do
       with_config :perform_browser_validations, false do
         concat(semantic_form_for(@new_post, :url => '/hello', :html => { :novalidate => true }) do |builder|
         end)
@@ -48,7 +48,7 @@ describe 'FormHelper' do
       end
     end
 
-    it 'allows form HTML to override "novalidate" attribute when configure to show' do
+    it 'allows form HTML to override "novalidate" attribute when configured to not validate' do
       with_config :perform_browser_validations, true do
         concat(semantic_form_for(@new_post, :url => '/hello', :html => { :novalidate => false }) do |builder|
         end)

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
+