formtastic 3.1.2 → 4.0.0

data/spec/localizer_spec.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 require 'spec_helper'
 
-describe 'Formtastic::Localizer' do
+RSpec.describe 'Formtastic::Localizer' do
   describe "Cache" do
     before do
       @cache = Formtastic::Localizer::Cache.new
@@ -11,27 +11,27 @@ describe 'Formtastic::Localizer' do
     end
     
     it "should get value" do
-      @cache.get(@key).should == 'value'
-      @cache.get(@undefined_key).should be_nil
+      expect(@cache.get(@key)).to eq('value')
+      expect(@cache.get(@undefined_key)).to be_nil
     end
     
     it "should check if key exists?" do
-      @cache.has_key?(@key).should be_truthy
-      @cache.has_key?(@undefined_key).should be_falsey
+      expect(@cache.has_key?(@key)).to be_truthy
+      expect(@cache.has_key?(@undefined_key)).to be_falsey
     end
     
     it "should set a key" do
       @cache.set(['model', 'name2'], 'value2')
-      @cache.get(['model', 'name2']).should == 'value2'
+      expect(@cache.get(['model', 'name2'])).to eq('value2')
     end
     
     it "should return hash" do
-      @cache.cache.should be_an_instance_of(Hash)
+      expect(@cache.cache).to be_an_instance_of(Hash)
     end
     
     it "should clear the cache" do
       @cache.clear!
-      @cache.get(@key).should be_nil
+      expect(@cache.get(@key)).to be_nil
     end
   end
   
@@ -53,11 +53,11 @@ describe 'Formtastic::Localizer' do
     end
     
     it "should be defined" do
-      lambda { Formtastic::Localizer }.should_not raise_error
+      expect { Formtastic::Localizer }.not_to raise_error
     end
     
     it "should have a cache" do
-      Formtastic::Localizer.cache.should be_an_instance_of(Formtastic::Localizer::Cache)
+      expect(Formtastic::Localizer.cache).to be_an_instance_of(Formtastic::Localizer::Cache)
     end
     
     describe "localize" do
@@ -75,19 +75,19 @@ describe 'Formtastic::Localizer' do
       end
 
       it "should translate key with i18n" do
-        @localizer.localize(:name, :name, :label).should == 'POST.NAME'
+        expect(@localizer.localize(:name, :name, :label)).to eq('POST.NAME')
       end
       
       describe "with caching" do
         it "should not update translation when stored translations change" do
           with_config :i18n_cache_lookups, true do
-            @localizer.localize(:name, :name, :label).should == 'POST.NAME'
+            expect(@localizer.localize(:name, :name, :label)).to eq('POST.NAME')
             store_post_translations('POST.NEW_NAME')
             
-            @localizer.localize(:name, :name, :label).should == 'POST.NAME'       
+            expect(@localizer.localize(:name, :name, :label)).to eq('POST.NAME')       
             
             Formtastic::Localizer.cache.clear!
-            @localizer.localize(:name, :name, :label).should == 'POST.NEW_NAME'                  
+            expect(@localizer.localize(:name, :name, :label)).to eq('POST.NEW_NAME')                  
           end
         end        
       end
@@ -95,9 +95,9 @@ describe 'Formtastic::Localizer' do
       describe "without caching" do
         it "should update translation when stored translations change" do
           with_config :i18n_cache_lookups, false do
-            @localizer.localize(:name, :name, :label).should == 'POST.NAME'
+            expect(@localizer.localize(:name, :name, :label)).to eq('POST.NAME')
             store_post_translations('POST.NEW_NAME')
-            @localizer.localize(:name, :name, :label).should == 'POST.NEW_NAME'            
+            expect(@localizer.localize(:name, :name, :label)).to eq('POST.NEW_NAME')            
           end
         end
       end
@@ -120,7 +120,7 @@ describe 'Formtastic::Localizer' do
         end
 
         it "should translate custom key with i18n" do
-          @localizer.localize(:name, :name, :label).should == 'MESSAGE.NAME'
+          expect(@localizer.localize(:name, :name, :label)).to eq('MESSAGE.NAME')
         end
       end 
     end

data/spec/namespaced_class_finder_spec.rb

@@ -2,7 +2,7 @@
 require 'spec_helper'
 require 'formtastic/namespaced_class_finder'
 
-describe Formtastic::NamespacedClassFinder do
+RSpec.describe Formtastic::NamespacedClassFinder do
   include FormtasticSpecHelper
 
   before do
@@ -54,7 +54,7 @@ describe Formtastic::NamespacedClassFinder do
 
   context '#finder' do
     before do
-      Rails.application.config.stub(:cache_classes).and_return(cache_classes)
+      allow(Rails.application.config).to receive(:cache_classes).and_return(cache_classes)
     end
 
     context 'when cache_classes is on' do

data/spec/schema.rb

@@ -0,0 +1,21 @@
+ActiveRecord::Schema.define(version: 20170208011723) do
+
+  create_table "posts", force: :cascade do |t|
+    t.integer "author_id",  limit: 4,     null: false
+  end
+
+  create_table "authors", force: :cascade do |t|
+    t.integer "age",   limit: 4,     null: false
+    t.string  "name",  limit: 255,   null: false
+    t.string  "surname",  limit: 255,   null: false
+    t.string  "login", limit: 255
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+  #non-rails foreign id convention
+  create_table "legacy_posts", force: :cascade do |t|
+    t.integer "post_author",  limit: 4,     null: false
+  end
+
+end

data/spec/spec_helper.rb

@@ -6,16 +6,12 @@ require 'action_pack'
 require 'action_view'
 require 'action_controller'
 require 'action_dispatch'
+require 'active_record'
 
-require File.expand_path(File.join(File.dirname(__FILE__), '../lib/formtastic/util'))
-require File.expand_path(File.join(File.dirname(__FILE__), '../lib/formtastic'))
+ActiveRecord::Base.establish_connection('url' => 'sqlite3::memory:', 'pool' => 1)
+load 'spec/schema.rb'
 
-#rspec-rails 2-14 assumes a full rails install
-module Rails
-  module VERSION
-    include ActionPack::VERSION
-  end
-end
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/formtastic'))
 
 require 'ammeter/init'
 
@@ -52,8 +48,8 @@ module FormtasticSpecHelper
   include Formtastic::Helpers::FormHelper
 
   def default_input_type(column_type, column_name = :generic_column_name)
-    @new_post.stub(column_name)
-    @new_post.stub(:column_for_attribute).and_return(double('column', :type => column_type)) unless column_type.nil?
+    allow(@new_post).to receive(column_name)
+    allow(@new_post).to receive(:column_for_attribute).and_return(double('column', :type => column_type)) unless column_type.nil?
 
     semantic_form_for(@new_post) do |builder|
       @default_type = builder.send(:default_input_type, column_name)
@@ -64,7 +60,7 @@ module FormtasticSpecHelper
 
   def active_model_validator(kind, attributes, options = {})
     validator = double("ActiveModel::Validations::#{kind.to_s.titlecase}Validator", :attributes => attributes, :options => options)
-    validator.stub(:kind).and_return(kind)
+    allow(validator).to receive(:kind).and_return(kind)
     validator
   end
 
@@ -107,26 +103,17 @@ module FormtasticSpecHelper
   end
 
   module ::Namespaced
-    class Post
-      extend ActiveModel::Naming if defined?(ActiveModel::Naming)
-      include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
-
-      def id
-      end
-
-      def persisted?
-      end
+    class Post < ActiveRecord::Base
     end
   end
 
-  class ::Author
-    extend ActiveModel::Naming if defined?(ActiveModel::Naming)
-    include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
-
-    def to_label
+  class ::Author < ActiveRecord::Base
+    def new_record?
+      !id
     end
 
-    def persisted?
+    def to_label
+      [name, surname].compact.join(' ')
     end
   end
 
@@ -139,6 +126,10 @@ module FormtasticSpecHelper
     end
   end
 
+  class ::LegacyPost < ActiveRecord::Base
+     belongs_to :author, foreign_key: :post_author
+  end
+
   class ::Continent
     extend ActiveModel::Naming if defined?(ActiveModel::Naming)
     include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
@@ -161,9 +152,8 @@ module FormtasticSpecHelper
     end
   end
   
-  # In Rails 3 Model.all returns an array. In Rails 4, it returns an
-  # association proxy, which quacks a lot like an array. We use this in stubs 
-  # or mocks where we need to return the later.
+  # Model.all returns an association proxy, which quacks a lot like an array.
+  # We use this in stubs or mocks where we need to return the later.
   # 
   # TODO try delegate?
   # delegate :map, :size, :length, :first, :to_ary, :each, :include?, :to => :array
@@ -211,14 +201,15 @@ module FormtasticSpecHelper
 
   def _routes
     url_helpers = double('url_helpers')
-    url_helpers.stub(:hash_for_posts_path).and_return({})
-    url_helpers.stub(:hash_for_post_path).and_return({})
-    url_helpers.stub(:hash_for_post_models_path).and_return({})
-    url_helpers.stub(:hash_for_authors_path).and_return({})
+    allow(url_helpers).to receive(:hash_for_posts_path).and_return({})
+    allow(url_helpers).to receive(:hash_for_post_path).and_return({})
+    allow(url_helpers).to receive(:hash_for_post_models_path).and_return({})
+    allow(url_helpers).to receive(:hash_for_authors_path).and_return({})
 
     double('_routes',
       :url_helpers => url_helpers,
-      :url_for => "/mock/path"
+      :url_for => "/mock/path",
+      :polymorphic_mappings => {}
     )
   end
 
@@ -246,121 +237,79 @@ module FormtasticSpecHelper
     def authors_path(*args); "/authors"; end
     def new_author_path(*args); "/authors/new"; end
     
-    # Returns the array for Rails 3 and a thing that looks looks like an 
-    # association proxy for Rails 4+
     def author_array_or_scope(the_array = [@fred, @bob])
-      if ::Formtastic::Util.rails3?
-        the_array
-      else
-        MockScope.new(the_array)
-      end
+      MockScope.new(the_array)
     end
-    
-    @fred = ::Author.new
-    @fred.stub(:class).and_return(::Author)
-    @fred.stub(:to_label).and_return('Fred Smith')
-    @fred.stub(:login).and_return('fred_smith')
-    @fred.stub(:age).and_return(27)
-    @fred.stub(:id).and_return(37)
-    @fred.stub(:new_record?).and_return(false)
-    @fred.stub(:errors).and_return(double('errors', :[] => nil))
-    @fred.stub(:to_key).and_return(nil)
-    @fred.stub(:persisted?).and_return(nil)
-    @fred.stub(:name).and_return('Fred')
-
-    @bob = ::Author.new
-    @bob.stub(:to_label).and_return('Bob Rock')
-    @bob.stub(:login).and_return('bob')
-    @bob.stub(:age).and_return(43)
-    @bob.stub(:created_at)
-    @bob.stub(:id).and_return(42)
-    @bob.stub(:posts).and_return([])
-    @bob.stub(:post_ids).and_return([])
-    @bob.stub(:new_record?).and_return(false)
-    @bob.stub(:errors).and_return(double('errors', :[] => nil))
-    @bob.stub(:to_key).and_return(nil)
-    @bob.stub(:persisted?).and_return(nil)
-    @bob.stub(:name).and_return('Bob')
-
-    @james = ::Author.new
-    @james.stub(:to_label).and_return('James Shock')
-    @james.stub(:login).and_return('james')
-    @james.stub(:age).and_return(38)
-    @james.stub(:id).and_return(75)
-    @james.stub(:posts).and_return([])
-    @james.stub(:post_ids).and_return([])
-    @james.stub(:new_record?).and_return(false)
-    @james.stub(:errors).and_return(double('errors', :[] => nil))
-    @james.stub(:to_key).and_return(nil)
-    @james.stub(:persisted?).and_return(nil)
-    @james.stub(:name).and_return('James')
-
-
-    ::Author.stub(:scoped).and_return(::Author)
-    ::Author.stub(:find).and_return(author_array_or_scope)
-    ::Author.stub(:all).and_return(author_array_or_scope)
-    ::Author.stub(:where).and_return(author_array_or_scope)
-    ::Author.stub(:human_attribute_name) { |column_name| column_name.humanize }
-    ::Author.stub(:human_name).and_return('::Author')
-    ::Author.stub(:reflect_on_association) { |column_name| double('reflection', :options => {}, :klass => Post, :macro => :has_many) if column_name == :posts }
-    ::Author.stub(:content_columns).and_return([double('column', :name => 'login'), double('column', :name => 'created_at')])
-    ::Author.stub(:to_key).and_return(nil)
-    ::Author.stub(:persisted?).and_return(nil)
+
+    @fred = ::Author.new(login: 'fred_smith', age: 27, name: 'Fred', id: 37)
+    @bob = ::Author.new(login: 'bob', age: 43, name: 'Bob', id: 42)
+    @james = ::Author.new(age: 38, id: 75)
+
+    allow(::Author).to receive(:scoped).and_return(::Author)
+    allow(::Author).to receive(:find).and_return(author_array_or_scope)
+    allow(::Author).to receive(:all).and_return(author_array_or_scope)
+    allow(::Author).to receive(:where).and_return(author_array_or_scope)
+    allow(::Author).to receive(:human_attribute_name) { |column_name| column_name.humanize }
+    allow(::Author).to receive(:human_name).and_return('::Author')
+    allow(::Author).to receive(:reflect_on_association) { |column_name| double('reflection', :options => {}, :klass => Post, :macro => :has_many) if column_name == :posts }
+    allow(::Author).to receive(:content_columns).and_return([double('column', :name => 'login'), double('column', :name => 'created_at')])
+    allow(::Author).to receive(:to_key).and_return(nil)
+    allow(::Author).to receive(:persisted?).and_return(nil)
 
     @hash_backed_author = HashBackedAuthor.new
 
     # Sometimes we need a mock @post object and some Authors for belongs_to
     @new_post = double('post')
-    @new_post.stub(:class).and_return(::Post)
-    @new_post.stub(:id).and_return(nil)
-    @new_post.stub(:new_record?).and_return(true)
-    @new_post.stub(:errors).and_return(double('errors', :[] => nil))
-    @new_post.stub(:author).and_return(nil)
-    @new_post.stub(:author_attributes=).and_return(nil)
-    @new_post.stub(:authors).and_return(author_array_or_scope([@fred]))
-    @new_post.stub(:authors_attributes=)
-    @new_post.stub(:reviewer).and_return(nil)
-    @new_post.stub(:main_post).and_return(nil)
-    @new_post.stub(:sub_posts).and_return([]) #TODO should be a mock with methods for adding sub posts
-    @new_post.stub(:to_key).and_return(nil)
-    @new_post.stub(:to_model).and_return(@new_post)
-    @new_post.stub(:persisted?).and_return(nil)
-    @new_post.stub(:model_name){ @new_post.class.model_name}
+    allow(@new_post).to receive(:class).and_return(::Post)
+    allow(@new_post).to receive(:id).and_return(nil)
+    allow(@new_post).to receive(:new_record?).and_return(true)
+    allow(@new_post).to receive(:errors).and_return(double('errors', :[] => nil))
+    allow(@new_post).to receive(:author).and_return(nil)
+    allow(@new_post).to receive(:author_attributes=).and_return(nil)
+    allow(@new_post).to receive(:authors).and_return(author_array_or_scope([@fred]))
+    allow(@new_post).to receive(:authors_attributes=)
+    allow(@new_post).to receive(:reviewer).and_return(nil)
+    allow(@new_post).to receive(:main_post).and_return(nil)
+    allow(@new_post).to receive(:sub_posts).and_return([]) #TODO should be a mock with methods for adding sub posts
+    allow(@new_post).to receive(:to_key).and_return(nil)
+    allow(@new_post).to receive(:to_model).and_return(@new_post)
+    allow(@new_post).to receive(:persisted?).and_return(nil)
+    allow(@new_post).to receive(:model_name){ @new_post.class.model_name}
 
     @freds_post = double('post')
-    @freds_post.stub(:to_ary)
-    @freds_post.stub(:class).and_return(::Post)
-    @freds_post.stub(:to_label).and_return('Fred Smith')
-    @freds_post.stub(:id).and_return(19)
-    @freds_post.stub(:title).and_return("Hello World")
-    @freds_post.stub(:author).and_return(@fred)
-    @freds_post.stub(:author_id).and_return(@fred.id)
-    @freds_post.stub(:authors).and_return([@fred])
-    @freds_post.stub(:author_ids).and_return([@fred.id])
-    @freds_post.stub(:new_record?).and_return(false)
-    @freds_post.stub(:errors).and_return(double('errors', :[] => nil))
-    @freds_post.stub(:to_key).and_return(nil)
-    @freds_post.stub(:persisted?).and_return(nil)
-    @freds_post.stub(:model_name){ @freds_post.class.model_name}
-    @freds_post.stub(:to_model).and_return(@freds_post)
-    @fred.stub(:posts).and_return(author_array_or_scope([@freds_post]))
-    @fred.stub(:post_ids).and_return([@freds_post.id])
-
-    ::Post.stub(:scoped).and_return(::Post)
-    ::Post.stub(:human_attribute_name) { |column_name| column_name.humanize }
-    ::Post.stub(:human_name).and_return('Post')
-    ::Post.stub(:reflect_on_all_validations).and_return([])
-    ::Post.stub(:reflect_on_validations_for).and_return([])
-    ::Post.stub(:reflections).and_return({})
-    ::Post.stub(:reflect_on_association) { |column_name|
+    allow(@freds_post).to receive(:to_ary)
+    allow(@freds_post).to receive(:class).and_return(::Post)
+    allow(@freds_post).to receive(:to_label).and_return('Fred Smith')
+    allow(@freds_post).to receive(:id).and_return(19)
+    allow(@freds_post).to receive(:title).and_return("Hello World")
+    allow(@freds_post).to receive(:author).and_return(@fred)
+    allow(@freds_post).to receive(:author_id).and_return(@fred.id)
+    allow(@freds_post).to receive(:authors).and_return([@fred])
+    allow(@freds_post).to receive(:author_ids).and_return([@fred.id])
+    allow(@freds_post).to receive(:new_record?).and_return(false)
+    allow(@freds_post).to receive(:errors).and_return(double('errors', :[] => nil))
+    allow(@freds_post).to receive(:to_key).and_return(nil)
+    allow(@freds_post).to receive(:persisted?).and_return(nil)
+    allow(@freds_post).to receive(:model_name){ @freds_post.class.model_name}
+    allow(@freds_post).to receive(:to_model).and_return(@freds_post)
+    allow(@fred).to receive(:posts).and_return(author_array_or_scope([@freds_post]))
+    allow(@fred).to receive(:post_ids).and_return([@freds_post.id])
+
+    allow(::Post).to receive(:scoped).and_return(::Post)
+    allow(::Post).to receive(:human_attribute_name) { |column_name| column_name.humanize }
+    allow(::Post).to receive(:human_name).and_return('Post')
+    allow(::Post).to receive(:reflect_on_all_validations).and_return([])
+    allow(::Post).to receive(:reflect_on_validations_for).and_return([])
+    allow(::Post).to receive(:reflections).and_return({})
+    allow(::Post).to receive(:reflect_on_association) { |column_name|
       case column_name
       when :author, :author_status
         mock = double('reflection', :options => {}, :klass => ::Author, :macro => :belongs_to)
-        mock.stub(:[]).with(:class_name).and_return("Author")
+        allow(mock).to receive(:[]).with(:class_name).and_return("Author")
         mock
       when :reviewer
         mock = double('reflection', :options => {:class_name => 'Author'}, :klass => ::Author, :macro => :belongs_to)
-        mock.stub(:[]).with(:class_name).and_return("Author")
+        allow(mock).to receive(:[]).with(:class_name).and_return("Author")
         mock
       when :authors
         double('reflection', :options => {}, :klass => ::Author, :macro => :has_and_belongs_to_many)
@@ -374,98 +323,98 @@ module FormtasticSpecHelper
              :klass => ::Author, :macro => :referenced_in, :foreign_key => "reviewer_id") # custom id
       end
     }
-    ::Post.stub(:find).and_return(author_array_or_scope([@freds_post]))
-    ::Post.stub(:all).and_return(author_array_or_scope([@freds_post]))
-    ::Post.stub(:where).and_return(author_array_or_scope([@freds_post]))
-    ::Post.stub(:content_columns).and_return([double('column', :name => 'title'), double('column', :name => 'body'), double('column', :name => 'created_at')])
-    ::Post.stub(:to_key).and_return(nil)
-    ::Post.stub(:persisted?).and_return(nil)
-    ::Post.stub(:to_ary)
-
-    ::MongoPost.stub(:human_attribute_name) { |column_name| column_name.humanize }
-    ::MongoPost.stub(:human_name).and_return('MongoPost')
-    ::MongoPost.stub(:associations).and_return({
+    allow(::Post).to receive(:find).and_return(author_array_or_scope([@freds_post]))
+    allow(::Post).to receive(:all).and_return(author_array_or_scope([@freds_post]))
+    allow(::Post).to receive(:where).and_return(author_array_or_scope([@freds_post]))
+    allow(::Post).to receive(:content_columns).and_return([double('column', :name => 'title'), double('column', :name => 'body'), double('column', :name => 'created_at')])
+    allow(::Post).to receive(:to_key).and_return(nil)
+    allow(::Post).to receive(:persisted?).and_return(nil)
+    allow(::Post).to receive(:to_ary)
+
+    allow(::MongoPost).to receive(:human_attribute_name) { |column_name| column_name.humanize }
+    allow(::MongoPost).to receive(:human_name).and_return('MongoPost')
+    allow(::MongoPost).to receive(:associations).and_return({
       :sub_posts => double('reflection', :options => {:polymorphic => true}, :klass => ::MongoPost, :macro => :has_many),
       :options => []
     })
-    ::MongoPost.stub(:find).and_return(author_array_or_scope([@freds_post]))
-    ::MongoPost.stub(:all).and_return(author_array_or_scope([@freds_post]))
-    ::MongoPost.stub(:where).and_return(author_array_or_scope([@freds_post]))
-    ::MongoPost.stub(:to_key).and_return(nil)
-    ::MongoPost.stub(:persisted?).and_return(nil)
-    ::MongoPost.stub(:to_ary)
-    ::MongoPost.stub(:model_name).and_return( double(:model_name_mock, :singular => "post", :plural => "posts", :param_key => "post", :route_key => "posts") )
+    allow(::MongoPost).to receive(:find).and_return(author_array_or_scope([@freds_post]))
+    allow(::MongoPost).to receive(:all).and_return(author_array_or_scope([@freds_post]))
+    allow(::MongoPost).to receive(:where).and_return(author_array_or_scope([@freds_post]))
+    allow(::MongoPost).to receive(:to_key).and_return(nil)
+    allow(::MongoPost).to receive(:persisted?).and_return(nil)
+    allow(::MongoPost).to receive(:to_ary)
+    allow(::MongoPost).to receive(:model_name).and_return( double(:model_name_mock, :singular => "post", :plural => "posts", :param_key => "post", :route_key => "posts", :name => "post") )
 
     @new_mm_post = double('mm_post')
-    @new_mm_post.stub(:class).and_return(::MongoPost)
-    @new_mm_post.stub(:id).and_return(nil)
-    @new_mm_post.stub(:new_record?).and_return(true)
-    @new_mm_post.stub(:errors).and_return(double('errors', :[] => nil))
-    @new_mm_post.stub(:title).and_return("Hello World")
-    @new_mm_post.stub(:sub_posts).and_return([]) #TODO should be a mock with methods for adding sub posts
-    @new_mm_post.stub(:to_key).and_return(nil)
-    @new_mm_post.stub(:to_model).and_return(@new_mm_post)
-    @new_mm_post.stub(:persisted?).and_return(nil)
-    @new_mm_post.stub(:model_name).and_return(::MongoPost.model_name)
+    allow(@new_mm_post).to receive(:class).and_return(::MongoPost)
+    allow(@new_mm_post).to receive(:id).and_return(nil)
+    allow(@new_mm_post).to receive(:new_record?).and_return(true)
+    allow(@new_mm_post).to receive(:errors).and_return(double('errors', :[] => nil))
+    allow(@new_mm_post).to receive(:title).and_return("Hello World")
+    allow(@new_mm_post).to receive(:sub_posts).and_return([]) #TODO should be a mock with methods for adding sub posts
+    allow(@new_mm_post).to receive(:to_key).and_return(nil)
+    allow(@new_mm_post).to receive(:to_model).and_return(@new_mm_post)
+    allow(@new_mm_post).to receive(:persisted?).and_return(nil)
+    allow(@new_mm_post).to receive(:model_name).and_return(::MongoPost.model_name)
 
     @mock_file = double('file')
     Formtastic::FormBuilder.file_methods.each do |method|
-      @mock_file.stub(method).and_return(true)
+      allow(@mock_file).to receive(method).and_return(true)
     end
 
-    @new_post.stub(:title)
-    @new_post.stub(:email)
-    @new_post.stub(:url)
-    @new_post.stub(:phone)
-    @new_post.stub(:search)
-    @new_post.stub(:to_ary)
-    @new_post.stub(:body)
-    @new_post.stub(:published)
-    @new_post.stub(:publish_at)
-    @new_post.stub(:created_at)
-    @new_post.stub(:secret).and_return(1)
-    @new_post.stub(:url)
-    @new_post.stub(:email)
-    @new_post.stub(:color)
-    @new_post.stub(:search)
-    @new_post.stub(:phone)
-    @new_post.stub(:time_zone)
-    @new_post.stub(:category_name)
-    @new_post.stub(:allow_comments).and_return(true)
-    @new_post.stub(:answer_comments)
-    @new_post.stub(:country)
-    @new_post.stub(:country_subdivision)
-    @new_post.stub(:country_code)
-    @new_post.stub(:document).and_return(@mock_file)
-    @new_post.stub(:column_for_attribute).with(:meta_description).and_return(double('column', :type => :string, :limit => 255))
-    @new_post.stub(:column_for_attribute).with(:title).and_return(double('column', :type => :string, :limit => 50))
-    @new_post.stub(:column_for_attribute).with(:body).and_return(double('column', :type => :text))
-    @new_post.stub(:column_for_attribute).with(:published).and_return(double('column', :type => :boolean))
-    @new_post.stub(:column_for_attribute).with(:publish_at).and_return(double('column', :type => :date))
-    @new_post.stub(:column_for_attribute).with(:time_zone).and_return(double('column', :type => :string))
-    @new_post.stub(:column_for_attribute).with(:allow_comments).and_return(double('column', :type => :boolean))
-    @new_post.stub(:column_for_attribute).with(:author).and_return(double('column', :type => :integer))
-    @new_post.stub(:column_for_attribute).with(:country).and_return(double('column', :type => :string, :limit => 255))
-    @new_post.stub(:column_for_attribute).with(:country_subdivision).and_return(double('column', :type => :string, :limit => 255))
-    @new_post.stub(:column_for_attribute).with(:country_code).and_return(double('column', :type => :string, :limit => 255))
-    @new_post.stub(:column_for_attribute).with(:email).and_return(double('column', :type => :string, :limit => 255))
-    @new_post.stub(:column_for_attribute).with(:color).and_return(double('column', :type => :string, :limit => 255))
-    @new_post.stub(:column_for_attribute).with(:url).and_return(double('column', :type => :string, :limit => 255))
-    @new_post.stub(:column_for_attribute).with(:phone).and_return(double('column', :type => :string, :limit => 255))
-    @new_post.stub(:column_for_attribute).with(:search).and_return(double('column', :type => :string, :limit => 255))
-    @new_post.stub(:column_for_attribute).with(:document).and_return(nil)
-
-    @new_post.stub(:author).and_return(@bob)
-    @new_post.stub(:author_id).and_return(@bob.id)
-
-    @new_post.stub(:reviewer).and_return(@fred)
-    @new_post.stub(:reviewer_id).and_return(@fred.id)
+    allow(@new_post).to receive(:title)
+    allow(@new_post).to receive(:email)
+    allow(@new_post).to receive(:url)
+    allow(@new_post).to receive(:phone)
+    allow(@new_post).to receive(:search)
+    allow(@new_post).to receive(:to_ary)
+    allow(@new_post).to receive(:body)
+    allow(@new_post).to receive(:published)
+    allow(@new_post).to receive(:publish_at)
+    allow(@new_post).to receive(:created_at)
+    allow(@new_post).to receive(:secret).and_return(1)
+    allow(@new_post).to receive(:url)
+    allow(@new_post).to receive(:email)
+    allow(@new_post).to receive(:color)
+    allow(@new_post).to receive(:search)
+    allow(@new_post).to receive(:phone)
+    allow(@new_post).to receive(:time_zone)
+    allow(@new_post).to receive(:category_name)
+    allow(@new_post).to receive(:allow_comments).and_return(true)
+    allow(@new_post).to receive(:answer_comments)
+    allow(@new_post).to receive(:country)
+    allow(@new_post).to receive(:country_subdivision)
+    allow(@new_post).to receive(:country_code)
+    allow(@new_post).to receive(:document).and_return(@mock_file)
+    allow(@new_post).to receive(:column_for_attribute).with(:meta_description).and_return(double('column', :type => :string, :limit => 255))
+    allow(@new_post).to receive(:column_for_attribute).with(:title).and_return(double('column', :type => :string, :limit => 50))
+    allow(@new_post).to receive(:column_for_attribute).with(:body).and_return(double('column', :type => :text))
+    allow(@new_post).to receive(:column_for_attribute).with(:published).and_return(double('column', :type => :boolean))
+    allow(@new_post).to receive(:column_for_attribute).with(:publish_at).and_return(double('column', :type => :date))
+    allow(@new_post).to receive(:column_for_attribute).with(:time_zone).and_return(double('column', :type => :string))
+    allow(@new_post).to receive(:column_for_attribute).with(:allow_comments).and_return(double('column', :type => :boolean))
+    allow(@new_post).to receive(:column_for_attribute).with(:author).and_return(double('column', :type => :integer))
+    allow(@new_post).to receive(:column_for_attribute).with(:country).and_return(double('column', :type => :string, :limit => 255))
+    allow(@new_post).to receive(:column_for_attribute).with(:country_subdivision).and_return(double('column', :type => :string, :limit => 255))
+    allow(@new_post).to receive(:column_for_attribute).with(:country_code).and_return(double('column', :type => :string, :limit => 255))
+    allow(@new_post).to receive(:column_for_attribute).with(:email).and_return(double('column', :type => :string, :limit => 255))
+    allow(@new_post).to receive(:column_for_attribute).with(:color).and_return(double('column', :type => :string, :limit => 255))
+    allow(@new_post).to receive(:column_for_attribute).with(:url).and_return(double('column', :type => :string, :limit => 255))
+    allow(@new_post).to receive(:column_for_attribute).with(:phone).and_return(double('column', :type => :string, :limit => 255))
+    allow(@new_post).to receive(:column_for_attribute).with(:search).and_return(double('column', :type => :string, :limit => 255))
+    allow(@new_post).to receive(:column_for_attribute).with(:document).and_return(nil)
+
+    allow(@new_post).to receive(:author).and_return(@bob)
+    allow(@new_post).to receive(:author_id).and_return(@bob.id)
+
+    allow(@new_post).to receive(:reviewer).and_return(@fred)
+    allow(@new_post).to receive(:reviewer_id).and_return(@fred.id)
 
     # @new_post.should_receive(:publish_at=).at_least(:once)
-    @new_post.stub(:publish_at=)
+    allow(@new_post).to receive(:publish_at=)
     # @new_post.should_receive(:title=).at_least(:once)
-    @new_post.stub(:title=)
-    @new_post.stub(:main_post_id).and_return(nil)
+    allow(@new_post).to receive(:title=)
+    allow(@new_post).to receive(:main_post_id).and_return(nil)
 
   end
 
@@ -492,29 +441,8 @@ module FormtasticSpecHelper
     Formtastic::FormBuilder.send(:"#{config_method_name}=", old_value)
   end
   
-  class ToSMatcher
-    def initialize(str)
-      @str=str.to_s
-    end
-    
-    def matches?(value)
-      value.to_s==@str
-    end
-    
-    def failure_message_for_should
-      "Expected argument that converted to #{@str}"
-    end
-  end
-  
-  def errors_matcher(method)
-    # In edge rails (Rails 4) tags store method_name as a string and index the errors object using a string
-    # therefore allow stubs to match on either string or symbol.  The errors object calls to_sym on all index 
-    # accesses so @object.errors[:abc] is equivalent to @object.errors["abc"]
-    if Rails::VERSION::MAJOR == 4
-      ToSMatcher.new(method)
-    else
-      method
-    end
+  RSpec::Matchers.define :errors_matcher do |expected|
+    match { |actual| actual.to_s == expected.to_s }
   end
 end
 
@@ -531,23 +459,7 @@ RSpec.configure do |config|
   config.filter_run_excluding skip: true
   config.run_all_when_everything_filtered = true
 
-  config.before(:each) do
+  config.before(:example) do
     Formtastic::Localizer.cache.clear!    
   end
-
-  config.before(:each) do
-    allow(Formtastic.deprecation).to receive(:deprecation_warning).and_call_original
-    # TODO: Remove this in Formtastic 4
-    [ :action_class, :standard_action_class_name, :custom_action_class_name,
-      :input_class, :standard_input_class_name, :custom_input_class_name ].each do |method|
-      allow(Formtastic.deprecation).to receive(:deprecation_warning).with(method, instance_of(String), instance_of(Array))
-    end
-  end
-
-  config.before(:all) do
-    DeferredGarbageCollection.start unless ENV["DEFER_GC"] == "false"
-  end
-  config.after(:all) do
-    DeferredGarbageCollection.reconsider unless ENV["DEFER_GC"] == "false"    
-  end
 end