formtastic 3.1.6 → 4.0.0.rc1

data/spec/helpers/action_helper_spec.rb

@@ -1,19 +1,337 @@
-# encoding: utf-8
 require 'spec_helper'
 
-describe 'Formtastic::FormBuilder#action' do
-  include_context 'Action Helper' # from spec/support/shared_examples.rb
+RSpec.describe 'with action class finder' do
+  include_context 'form builder'
+
+  describe 'arguments and options' do
+
+    it 'should require the first argument (the action method)' do
+      expect {
+        concat(semantic_form_for(@new_post) do |builder|
+          concat(builder.action()) # no args passed in at all
+        end)
+      }.to raise_error(ArgumentError)
+    end
+
+    describe ':as option' do
+
+      describe 'when not provided' do
+
+        it 'should default to a commit for commit' do
+          concat(semantic_form_for(:project, :url => 'http://test.host') do |builder|
+            concat(builder.action(:submit))
+          end)
+          expect(output_buffer).to have_tag('form li.action.input_action', :count => 1)
+        end
+
+        it 'should default to a button for reset' do
+          concat(semantic_form_for(:project, :url => 'http://test.host') do |builder|
+            concat(builder.action(:reset))
+          end)
+          expect(output_buffer).to have_tag('form li.action.input_action', :count => 1)
+        end
+
+        it 'should default to a link for cancel' do
+          concat(semantic_form_for(:project, :url => 'http://test.host') do |builder|
+            concat(builder.action(:cancel))
+          end)
+          expect(output_buffer).to have_tag('form li.action.link_action', :count => 1)
+        end
+      end
+
+      it 'should call the corresponding action class with .to_html' do
+        [:input, :button, :link].each do |action_style|
+          semantic_form_for(:project, :url => "http://test.host") do |builder|
+            action_instance = double('Action instance')
+            action_class = "#{action_style.to_s}_action".classify
+            action_constant = "Formtastic::Actions::#{action_class}".constantize
+
+            expect(action_constant).to receive(:new).and_return(action_instance)
+            expect(action_instance).to receive(:to_html).and_return("some HTML")
+
+            concat(builder.action(:submit, :as => action_style))
+          end
+        end
+      end
+
+    end
+
+    #describe ':label option' do
+    #
+    #  describe 'when provided' do
+    #    it 'should be passed down to the label tag' do
+    #      concat(semantic_form_for(@new_post) do |builder|
+    #        concat(builder.input(:title, :label => "Kustom"))
+    #      end)
+    #      output_buffer.should have_tag("form li label", /Kustom/)
+    #    end
+    #
+    #    it 'should not generate a label if false' do
+    #      concat(semantic_form_for(@new_post) do |builder|
+    #        concat(builder.input(:title, :label => false))
+    #      end)
+    #      output_buffer.should_not have_tag("form li label")
+    #    end
+    #
+    #    it 'should be dupped if frozen' do
+    #      concat(semantic_form_for(@new_post) do |builder|
+    #        concat(builder.input(:title, :label => "Kustom".freeze))
+    #      end)
+    #      output_buffer.should have_tag("form li label", /Kustom/)
+    #    end
+    #  end
+    #
+    #  describe 'when not provided' do
+    #    describe 'when localized label is provided' do
+    #      describe 'and object is given' do
+    #        describe 'and label_str_method not :humanize' do
+    #          it 'should render a label with localized text and not apply the label_str_method' do
+    #            with_config :label_str_method, :reverse do
+    #              @localized_label_text = 'Localized title'
+    #              @new_post.stub(:meta_description)
+    #              ::I18n.backend.store_translations :en,
+    #                :formtastic => {
+    #                  :labels => {
+    #                    :meta_description => @localized_label_text
+    #                  }
+    #                }
+    #
+    #              concat(semantic_form_for(@new_post) do |builder|
+    #                concat(builder.input(:meta_description))
+    #              end)
+    #              output_buffer.should have_tag('form li label', /Localized title/)
+    #            end
+    #          end
+    #        end
+    #      end
+    #    end
+    #
+    #    describe 'when localized label is NOT provided' do
+    #      describe 'and object is not given' do
+    #        it 'should default the humanized method name, passing it down to the label tag' do
+    #          ::I18n.backend.store_translations :en, :formtastic => {}
+    #          with_config :label_str_method, :humanize do
+    #            concat(semantic_form_for(:project, :url => 'http://test.host') do |builder|
+    #              concat(builder.input(:meta_description))
+    #            end)
+    #            output_buffer.should have_tag("form li label", /#{'meta_description'.humanize}/)
+    #          end
+    #        end
+    #      end
+    #
+    #      describe 'and object is given' do
+    #        it 'should delegate the label logic to class human attribute name and pass it down to the label tag' do
+    #          @new_post.stub(:meta_description) # a two word method name
+    #          @new_post.class.should_receive(:human_attribute_name).with('meta_description').and_return('meta_description'.humanize)
+    #
+    #          concat(semantic_form_for(@new_post) do |builder|
+    #            concat(builder.input(:meta_description))
+    #          end)
+    #          output_buffer.should have_tag("form li label", /#{'meta_description'.humanize}/)
+    #        end
+    #      end
+    #
+    #      describe 'and object is given with label_str_method set to :capitalize' do
+    #        it 'should capitalize method name, passing it down to the label tag' do
+    #          with_config :label_str_method, :capitalize do
+    #            @new_post.stub(:meta_description)
+    #
+    #            concat(semantic_form_for(@new_post) do |builder|
+    #              concat(builder.input(:meta_description))
+    #            end)
+    #            output_buffer.should have_tag("form li label", /#{'meta_description'.capitalize}/)
+    #          end
+    #        end
+    #      end
+    #    end
+    #
+    #    describe 'when localized label is provided' do
+    #      before do
+    #        @localized_label_text = 'Localized title'
+    #        @default_localized_label_text = 'Default localized title'
+    #        ::I18n.backend.store_translations :en,
+    #          :formtastic => {
+    #              :labels => {
+    #                :title => @default_localized_label_text,
+    #                :published => @default_localized_label_text,
+    #                :post => {
+    #                  :title => @localized_label_text,
+    #                  :published => @default_localized_label_text
+    #                 }
+    #               }
+    #            }
+    #      end
+    #
+    #      it 'should render a label with localized label (I18n)' do
+    #        with_config :i18n_lookups_by_default, false do
+    #          concat(semantic_form_for(@new_post) do |builder|
+    #            concat(builder.input(:title, :label => true))
+    #            concat(builder.input(:published, :as => :boolean, :label => true))
+    #          end)
+    #          output_buffer.should have_tag('form li label', Regexp.new('^' + @localized_label_text))
+    #        end
+    #      end
+    #
+    #      it 'should render a hint paragraph containing an optional localized label (I18n) if first is not set' do
+    #        with_config :i18n_lookups_by_default, false do
+    #          ::I18n.backend.store_translations :en,
+    #            :formtastic => {
+    #                :labels => {
+    #                  :post => {
+    #                    :title => nil,
+    #                    :published => nil
+    #                   }
+    #                 }
+    #              }
+    #          concat(semantic_form_for(@new_post) do |builder|
+    #            concat(builder.input(:title, :label => true))
+    #            concat(builder.input(:published, :as => :boolean, :label => true))
+    #          end)
+    #          output_buffer.should have_tag('form li label', Regexp.new('^' + @default_localized_label_text))
+    #        end
+    #      end
+    #    end
+    #  end
+    #
+    #end
+    #
+    describe ':wrapper_html option' do
+
+      describe 'when provided' do
+        it 'should be passed down to the li tag' do
+          concat(semantic_form_for(@new_post) do |builder|
+            concat(builder.action(:submit, :wrapper_html => {:id => :another_id}))
+          end)
+          expect(output_buffer).to have_tag("form li#another_id")
+        end
+
+        it 'should append given classes to li default classes' do
+          concat(semantic_form_for(@new_post) do |builder|
+            concat(builder.action(:submit, :wrapper_html => {:class => :another_class}))
+          end)
+          expect(output_buffer).to have_tag("form li.action")
+          expect(output_buffer).to have_tag("form li.input_action")
+          expect(output_buffer).to have_tag("form li.another_class")
+        end
+
+        it 'should allow classes to be an array' do
+          concat(semantic_form_for(@new_post) do |builder|
+            concat(builder.action(:submit, :wrapper_html => {:class => [ :my_class, :another_class ]}))
+          end)
+          expect(output_buffer).to have_tag("form li.action")
+          expect(output_buffer).to have_tag("form li.input_action")
+          expect(output_buffer).to have_tag("form li.my_class")
+          expect(output_buffer).to have_tag("form li.another_class")
+        end
+      end
+
+      describe 'when not provided' do
+        it 'should use default id and class' do
+          concat(semantic_form_for(@new_post) do |builder|
+            concat(builder.action(:submit))
+          end)
+          expect(output_buffer).to have_tag("form li#post_submit_action")
+          expect(output_buffer).to have_tag("form li.action")
+          expect(output_buffer).to have_tag("form li.input_action")
+        end
+      end
+
+    end
+
+  end
 
-  # TODO: remove this in Formtastic 4.0
   describe 'instantiating an action class' do
-    context 'of unknown action' do
-      it "should try to load class named as the action" do
+    context 'when a class does not exist' do
+      it "should raise an error" do
         expect {
-          semantic_form_for(@new_post) do |builder|
-            builder.action(:destroy)
-          end
-        }.to raise_error(Formtastic::UnknownActionError, 'Unable to find action destroy')
+          concat(semantic_form_for(@new_post) do |builder|
+            builder.action(:submit, :as => :non_existant)
+          end)
+        }.to raise_error(Formtastic::UnknownActionError)
       end
     end
+
+    context 'when a customized top-level class does not exist' do
+      it 'should instantiate the Formtastic action' do
+        action = double('action', :to_html => 'some HTML')
+        expect(Formtastic::Actions::ButtonAction).to receive(:new).and_return(action)
+        concat(semantic_form_for(@new_post) do |builder|
+          builder.action(:commit, :as => :button)
+        end)
+      end
+    end
+
+    describe 'when a top-level (custom) action class exists' do
+      it "should instantiate the top-level action instead of the Formtastic one" do
+        class ::ButtonAction < Formtastic::Actions::ButtonAction
+        end
+
+        action = double('action', :to_html => 'some HTML')
+        expect(Formtastic::Actions::ButtonAction).not_to receive(:new)
+        expect(::ButtonAction).to receive(:new).and_return(action)
+
+        concat(semantic_form_for(@new_post) do |builder|
+          builder.action(:commit, :as => :button)
+        end)
+      end
+    end
+
+    describe 'support for :as on each action' do
+
+      it "should raise an error when the action does not support the :as" do
+        expect {
+          concat(semantic_form_for(@new_post) do |builder|
+            concat(builder.action(:submit, :as => :link))
+          end)
+        }.to raise_error(Formtastic::UnsupportedMethodForAction)
+
+        expect {
+          concat(semantic_form_for(@new_post) do |builder|
+            concat(builder.action(:cancel, :as => :input))
+          end)
+        }.to raise_error(Formtastic::UnsupportedMethodForAction)
+
+        expect {
+          concat(semantic_form_for(@new_post) do |builder|
+            concat(builder.action(:cancel, :as => :button))
+          end)
+        }.to raise_error(Formtastic::UnsupportedMethodForAction)
+      end
+
+      it "should not raise an error when the action does not support the :as" do
+        expect {
+          concat(semantic_form_for(@new_post) do |builder|
+            concat(builder.action(:cancel, :as => :link))
+          end)
+        }.not_to raise_error
+
+        expect {
+          concat(semantic_form_for(@new_post) do |builder|
+            concat(builder.action(:submit, :as => :input))
+          end)
+        }.not_to raise_error
+
+        expect {
+          concat(semantic_form_for(@new_post) do |builder|
+            concat(builder.action(:submit, :as => :button))
+          end)
+        }.not_to raise_error
+
+        expect {
+          concat(semantic_form_for(@new_post) do |builder|
+            concat(builder.action(:reset, :as => :input))
+          end)
+        }.not_to raise_error
+
+        expect {
+          concat(semantic_form_for(@new_post) do |builder|
+            concat(builder.action(:reset, :as => :button))
+          end)
+        }.not_to raise_error
+      end
+
+    end
+
   end
+
 end

data/spec/helpers/actions_helper_spec.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require 'spec_helper'
 
-describe 'Formtastic::FormBuilder#actions' do
+RSpec.describe 'Formtastic::FormBuilder#actions' do
 
   include FormtasticSpecHelper
 
@@ -21,19 +21,19 @@ describe 'Formtastic::FormBuilder#actions' do
       end
 
       it 'should render a fieldset inside the form, with a class of "actions"' do
-        output_buffer.should have_tag("form fieldset.actions")
+        expect(output_buffer).to have_tag("form fieldset.actions")
       end
 
       it 'should render an ol inside the fieldset' do
-        output_buffer.should have_tag("form fieldset.actions ol")
+        expect(output_buffer).to have_tag("form fieldset.actions ol")
       end
 
       it 'should render the contents of the block inside the ol' do
-        output_buffer.should have_tag("form fieldset.actions ol", /hello/)
+        expect(output_buffer).to have_tag("form fieldset.actions ol", :text => /hello/)
       end
 
       it 'should not render a legend inside the fieldset' do
-        output_buffer.should_not have_tag("form fieldset.actions legend")
+        expect(output_buffer).not_to have_tag("form fieldset.actions legend")
       end
     end
 
@@ -47,7 +47,7 @@ describe 'Formtastic::FormBuilder#actions' do
         end)
       end
       it 'should render a fieldset inside the form' do
-        output_buffer.should have_tag("form fieldset.actions legend", /#{@legend_text}/)
+        expect(output_buffer).to have_tag("form fieldset.actions legend", :text => /#{@legend_text}/)
       end
     end
     
@@ -62,8 +62,8 @@ describe 'Formtastic::FormBuilder#actions' do
         end)
       end
       it 'should pass the options into the fieldset tag as attributes' do
-        output_buffer.should have_tag("form fieldset##{@id_option}")
-        output_buffer.should have_tag("form fieldset.#{@class_option}")
+        expect(output_buffer).to have_tag("form fieldset##{@id_option}")
+        expect(output_buffer).to have_tag("form fieldset.#{@class_option}")
       end
     end
     
@@ -80,23 +80,23 @@ describe 'Formtastic::FormBuilder#actions' do
       end
   
       it 'should render a form' do
-        output_buffer.should have_tag('form')
+        expect(output_buffer).to have_tag('form')
       end
   
       it 'should render an actions fieldset inside the form' do
-        output_buffer.should have_tag('form fieldset.actions')
+        expect(output_buffer).to have_tag('form fieldset.actions')
       end
   
       it 'should not render a legend in the fieldset' do
-        output_buffer.should_not have_tag('form fieldset.actions legend')
+        expect(output_buffer).not_to have_tag('form fieldset.actions legend')
       end
   
       it 'should render an ol in the fieldset' do
-        output_buffer.should have_tag('form fieldset.actions ol')
+        expect(output_buffer).to have_tag('form fieldset.actions ol')
       end
   
       it 'should render a list item in the ol for each default action' do
-        output_buffer.should have_tag('form fieldset.actions ol li.action.input_action', :count => 1)
+        expect(output_buffer).to have_tag('form fieldset.actions ol li.action.input_action', :count => 1)
       end
   
     end
@@ -110,7 +110,7 @@ describe 'Formtastic::FormBuilder#actions' do
       end
     
       it 'should render a form with a fieldset containing a list item for each button arg' do
-        output_buffer.should have_tag('form > fieldset.actions > ol > li.action', :count => 3)
+        expect(output_buffer).to have_tag('form > fieldset.actions > ol > li.action', :count => 3)
       end
     
     end
@@ -124,15 +124,15 @@ describe 'Formtastic::FormBuilder#actions' do
      end
     
      it 'should render a form with a fieldset containing a list item for each button arg' do
-       output_buffer.should have_tag('form > fieldset.actions > ol > li.action', :count => 3)
+       expect(output_buffer).to have_tag('form > fieldset.actions > ol > li.action', :count => 3)
      end
     
      it 'should pass the options down to the fieldset' do
-       output_buffer.should have_tag('form > fieldset#my-id.actions')
+       expect(output_buffer).to have_tag('form > fieldset#my-id.actions')
      end
     
      it 'should use the special :name option as a text for the legend tag' do
-       output_buffer.should have_tag('form > fieldset#my-id.actions > legend', /Now click a button/)
+       expect(output_buffer).to have_tag('form > fieldset#my-id.actions > legend', :text => /Now click a button/)
      end
     
     end

data/spec/helpers/form_helper_spec.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require 'spec_helper'
 
-describe 'FormHelper' do
+RSpec.describe 'FormHelper' do
 
   include FormtasticSpecHelper
 
@@ -14,21 +14,21 @@ describe 'FormHelper' do
 
     it 'yields an instance of Formtastic::FormBuilder' do
       semantic_form_for(@new_post, :url => '/hello') do |builder|
-        builder.class.should == Formtastic::FormBuilder
+        expect(builder.class).to eq(Formtastic::FormBuilder)
       end
     end
 
     it 'adds a class of "formtastic" to the generated form' do
       concat(semantic_form_for(@new_post, :url => '/hello') do |builder|
       end)
-      output_buffer.should have_tag("form.formtastic")
+      expect(output_buffer).to have_tag("form.formtastic")
     end
 
     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)
-        output_buffer.should_not have_tag("form[@novalidate]")
+        expect(output_buffer).not_to have_tag("form[@novalidate]")
       end
     end
 
@@ -36,7 +36,7 @@ describe 'FormHelper' do
       with_config :perform_browser_validations, false do
         concat(semantic_form_for(@new_post, :url => '/hello') do |builder|
         end)
-        output_buffer.should have_tag("form[@novalidate]")
+        expect(output_buffer).to have_tag("form[@novalidate]")
       end
     end
 
@@ -44,7 +44,7 @@ describe 'FormHelper' do
       with_config :perform_browser_validations, false do
         concat(semantic_form_for(@new_post, :url => '/hello', :html => { :novalidate => true }) do |builder|
         end)
-        output_buffer.should have_tag("form[@novalidate]")
+        expect(output_buffer).to have_tag("form[@novalidate]")
       end
     end
 
@@ -52,7 +52,7 @@ describe 'FormHelper' do
       with_config :perform_browser_validations, true do
         concat(semantic_form_for(@new_post, :url => '/hello', :html => { :novalidate => false }) do |builder|
         end)
-        output_buffer.should_not have_tag("form[@novalidate]")
+        expect(output_buffer).not_to have_tag("form[@novalidate]")
       end
     end
 
@@ -60,103 +60,103 @@ describe 'FormHelper' do
       Formtastic::Helpers::FormHelper.default_form_class = 'xyz'
       concat(semantic_form_for(::Post.new, :as => :post, :url => '/hello') do |builder|
       end)
-      output_buffer.should have_tag("form.xyz")
+      expect(output_buffer).to have_tag("form.xyz")
     end
 
     it 'omits the leading spaces from the classes in the generated form when the default class is nil' do
       Formtastic::Helpers::FormHelper.default_form_class = nil
       concat(semantic_form_for(::Post.new, :as => :post, :url => '/hello') do |builder|
       end)
-      output_buffer.should have_tag("form[class='post']")
+      expect(output_buffer).to have_tag("form[class='post']")
     end
 
     it 'adds class matching the object name to the generated form when a symbol is provided' do
       concat(semantic_form_for(@new_post, :url => '/hello') do |builder|
       end)
-      output_buffer.should have_tag("form.post")
+      expect(output_buffer).to have_tag("form.post")
 
       concat(semantic_form_for(:project, :url => '/hello') do |builder|
       end)
-      output_buffer.should have_tag("form.project")
+      expect(output_buffer).to have_tag("form.project")
     end
 
     it 'adds class matching the :as option when provided' do
       concat(semantic_form_for(@new_post, :as => :message, :url => '/hello') do |builder|
       end)
-      output_buffer.should have_tag("form.message")
+      expect(output_buffer).to have_tag("form.message")
 
       concat(semantic_form_for([:admins, @new_post], :as => :message, :url => '/hello') do |builder|
       end)
-      output_buffer.should have_tag("form.message")
+      expect(output_buffer).to have_tag("form.message")
     end
 
     it 'adds class matching the object\'s class to the generated form when an object is provided' do
       concat(semantic_form_for(@new_post) do |builder|
       end)
-      output_buffer.should have_tag("form.post")
+      expect(output_buffer).to have_tag("form.post")
     end
 
     it 'adds a namespaced class to the generated form' do
       concat(semantic_form_for(::Namespaced::Post.new, :url => '/hello') do |builder|
       end)
-      output_buffer.should have_tag("form.namespaced_post")
+      expect(output_buffer).to have_tag("form.namespaced_post")
     end
 
     it 'adds a customized class to the generated form' do
       Formtastic::Helpers::FormHelper.default_form_model_class_proc = lambda { |model_class_name| "#{model_class_name}_form" }
       concat(semantic_form_for(@new_post, :url => '/hello') do |builder|
       end)
-      output_buffer.should have_tag("form.post_form")
+      expect(output_buffer).to have_tag("form.post_form")
 
       concat(semantic_form_for(:project, :url => '/hello') do |builder|
       end)
-      output_buffer.should have_tag("form.project_form")
+      expect(output_buffer).to have_tag("form.project_form")
     end
 
     describe 'allows :html options' do
-      before(:each) do
+      before(:example) do
         concat(semantic_form_for(@new_post, :url => '/hello', :html => { :id => "something-special", :class => "something-extra", :multipart => true }) do |builder|
         end)
       end
 
       it 'to add a id of "something-special" to generated form' do
-        output_buffer.should have_tag("form#something-special")
+        expect(output_buffer).to have_tag("form#something-special")
       end
 
       it 'to add a class of "something-extra" to generated form' do
-        output_buffer.should have_tag("form.something-extra")
+        expect(output_buffer).to have_tag("form.something-extra")
       end
 
       it 'to add enctype="multipart/form-data"' do
-        output_buffer.should have_tag('form[@enctype="multipart/form-data"]')
+        expect(output_buffer).to have_tag('form[@enctype="multipart/form-data"]')
       end
     end
 
     it 'can be called with a resource-oriented style' do
       semantic_form_for(@new_post) do |builder|
-        builder.object.class.should == ::Post
-        builder.object_name.should == "post"
+        expect(builder.object.class).to eq(::Post)
+        expect(builder.object_name).to eq("post")
       end
     end
 
     it 'can be called with a generic style and instance variable' do
       semantic_form_for(@new_post, :as => :post, :url => new_post_path) do |builder|
-        builder.object.class.should == ::Post
-        builder.object_name.to_s.should == "post" # TODO: is this forced .to_s a bad assumption somewhere?
+        expect(builder.object.class).to eq(::Post)
+        expect(builder.object_name.to_s).to eq("post") # TODO: is this forced .to_s a bad assumption somewhere?
       end
     end
 
     it 'can be called with a generic style and inline object' do
       semantic_form_for(@new_post, :url => new_post_path) do |builder|
-        builder.object.class.should == ::Post
-        builder.object_name.to_s.should == "post" # TODO: is this forced .to_s a bad assumption somewhere?
+        expect(builder.object.class).to eq(::Post)
+        expect(builder.object_name.to_s).to eq("post") # TODO: is this forced .to_s a bad assumption somewhere?
       end
     end
 
     describe 'ActionView::Base.field_error_proc' do
       it 'is set to no-op wrapper by default' do
         semantic_form_for(@new_post, :url => '/hello') do |builder|
-          ::ActionView::Base.field_error_proc.call("html", nil).should == "html"
+          expect(::ActionView::Base.field_error_proc.call("html", nil)).to eq("html")
         end
       end
 
@@ -164,15 +164,15 @@ describe 'FormHelper' do
         field_error_proc = double()
         Formtastic::Helpers::FormHelper.formtastic_field_error_proc = field_error_proc
         semantic_form_for(@new_post, :url => '/hello') do |builder|
-          ::ActionView::Base.field_error_proc.should == field_error_proc
+          expect(::ActionView::Base.field_error_proc).to eq(field_error_proc)
         end
       end
 
       it 'is restored to its original value after the form is rendered' do
-        lambda do
+        expect do
           Formtastic::Helpers::FormHelper.formtastic_field_error_proc = proc {""}
           semantic_form_for(@new_post, :url => '/hello') { |builder| }
-        end.should_not change(::ActionView::Base, :field_error_proc)
+        end.not_to change(::ActionView::Base, :field_error_proc)
       end
     end
 
@@ -181,7 +181,7 @@ describe 'FormHelper' do
         class MyAwesomeCustomBuilder < Formtastic::FormBuilder
         end
         semantic_form_for(@new_post, :url => '/hello', :builder => MyAwesomeCustomBuilder) do |builder|
-          builder.class.should == MyAwesomeCustomBuilder
+          expect(builder.class).to eq(MyAwesomeCustomBuilder)
         end
       end
     end
@@ -209,7 +209,7 @@ describe 'FormHelper' do
   describe '#semantic_fields_for' do
     it 'yields an instance of Formtastic::FormBuilder' do
       semantic_fields_for(@new_post) do |builder|
-        builder.class.should.kind_of?(Formtastic::FormBuilder)
+        expect(builder.class).to be(Formtastic::FormBuilder)
       end
     end
   end