formtastic 1.2.4 → 3.1.5

data/spec/inputs/with_options_spec.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'string input' do
+
+  include FormtasticSpecHelper
+
+  before do
+    @output_buffer = ''
+    mock_everything
+  end
+
+  describe "with_options and :wrapper_html" do
+    before do
+      concat(semantic_form_for(@new_post) do |builder|
+        builder.with_options :wrapper_html => { :class => ['extra'] } do |opt_builder|
+          concat(opt_builder.input(:title, :as => :string))
+          concat(opt_builder.input(:author, :as => :radio))
+        end
+      end)
+    end
+
+    it "should have extra class on title" do
+      output_buffer.should have_tag("form li#post_title_input.extra")
+    end
+    it "should have title as string" do
+      output_buffer.should have_tag("form li#post_title_input.string")
+    end
+    it "should not have title as radio" do
+      output_buffer.should_not have_tag("form li#post_title_input.radio")
+    end
+
+    it "should have extra class on author" do
+      output_buffer.should have_tag("form li#post_author_input.extra")
+    end
+    it "should not have author as string" do
+      output_buffer.should_not have_tag("form li#post_author_input.string")
+    end
+    it "should have author as radio" do
+      output_buffer.should have_tag("form li#post_author_input.radio")
+    end
+  end
+end

data/spec/localizer_spec.rb

@@ -0,0 +1,130 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'Formtastic::Localizer' do
+  describe "Cache" do
+    before do
+      @cache = Formtastic::Localizer::Cache.new
+      @key = ['model', 'name']
+      @undefined_key = ['model', 'undefined']
+      @cache.set(@key, 'value')
+    end
+    
+    it "should get value" do
+      @cache.get(@key).should == 'value'
+      @cache.get(@undefined_key).should 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
+    end
+    
+    it "should set a key" do
+      @cache.set(['model', 'name2'], 'value2')
+      @cache.get(['model', 'name2']).should == 'value2'
+    end
+    
+    it "should return hash" do
+      @cache.cache.should be_an_instance_of(Hash)
+    end
+    
+    it "should clear the cache" do
+      @cache.clear!
+      @cache.get(@key).should be_nil
+    end
+  end
+  
+  describe "Localizer" do
+    include FormtasticSpecHelper      
+    
+    before do
+      mock_everything    
+
+      with_config :i18n_lookups_by_default, true do
+        semantic_form_for(@new_post) do |builder|
+          @localizer = Formtastic::Localizer.new(builder)
+        end
+      end
+    end
+
+    after do
+      ::I18n.backend.reload!
+    end
+    
+    it "should be defined" do
+      lambda { Formtastic::Localizer }.should_not raise_error
+    end
+    
+    it "should have a cache" do
+      Formtastic::Localizer.cache.should be_an_instance_of(Formtastic::Localizer::Cache)
+    end
+    
+    describe "localize" do
+      def store_post_translations(value)
+        ::I18n.backend.store_translations :en, {:formtastic => {
+            :labels => {
+              :post => { :name => value }
+            }
+          }
+        }        
+      end
+      
+      before do
+        store_post_translations('POST.NAME')
+      end
+
+      it "should translate key with i18n" do
+        @localizer.localize(:name, :name, :label).should == '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'
+            store_post_translations('POST.NEW_NAME')
+            
+            @localizer.localize(:name, :name, :label).should == 'POST.NAME'       
+            
+            Formtastic::Localizer.cache.clear!
+            @localizer.localize(:name, :name, :label).should == 'POST.NEW_NAME'                  
+          end
+        end        
+      end
+      
+      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'
+            store_post_translations('POST.NEW_NAME')
+            @localizer.localize(:name, :name, :label).should == 'POST.NEW_NAME'            
+          end
+        end
+      end
+
+      describe "with custom resource name" do
+        before do
+          ::I18n.backend.store_translations :en, {:formtastic => {
+              :labels => {
+                :post => { :name => 'POST.NAME' },
+                :message => { :name => 'MESSAGE.NAME' }
+              }
+            }
+          }
+
+          with_config :i18n_lookups_by_default, true do
+            semantic_form_for(@new_post, :as => :message) do |builder|
+              @localizer = Formtastic::Localizer.new(builder)
+            end
+          end
+        end
+
+        it "should translate custom key with i18n" do
+          @localizer.localize(:name, :name, :label).should == 'MESSAGE.NAME'
+        end
+      end 
+    end
+
+  end
+
+end

data/spec/namespaced_class_finder_spec.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'formtastic/namespaced_class_finder'
+
+describe Formtastic::NamespacedClassFinder do
+  include FormtasticSpecHelper
+
+  before do
+    stub_const('SearchPath', Module.new)
+  end
+
+  let(:search_path) { [ SearchPath ] }
+  subject(:finder) { Formtastic::NamespacedClassFinder.new(search_path) }
+
+  shared_examples 'Namespaced Class Finder' do
+    subject(:found_class) { finder.find(:custom_class) }
+
+    context 'Input defined in the Object scope' do
+      before do
+        stub_const('CustomClass', Class.new)
+      end
+
+      it { expect(found_class).to be(CustomClass) }
+    end
+
+    context 'Input defined in the search path' do
+      before do
+        stub_const('SearchPath::CustomClass', Class.new)
+      end
+
+      it { expect(found_class).to be(SearchPath::CustomClass) }
+    end
+
+    context 'Input defined both in the Object scope and the search path' do
+      before do
+        stub_const('CustomClass', Class.new)
+        stub_const('SearchPath::CustomClass', Class.new)
+      end
+
+      it { expect(found_class).to be(SearchPath::CustomClass) }
+    end
+
+    context 'Input defined outside the search path' do
+      before do
+        stub_const('Foo', Module.new)
+        stub_const('Foo::CustomClass', Class.new)
+      end
+
+      let(:error) { Formtastic::NamespacedClassFinder::NotFoundError }
+
+      it { expect { found_class }.to raise_error(error) }
+    end
+  end
+
+  context '#finder' do
+    before do
+      Rails.application.config.stub(:cache_classes).and_return(cache_classes)
+    end
+
+    context 'when cache_classes is on' do
+      let(:cache_classes) { true }
+      it_behaves_like 'Namespaced Class Finder'
+    end
+
+    context 'when cache_classes is off' do
+      let(:cache_classes) { false }
+      it_behaves_like 'Namespaced Class Finder'
+    end
+  end
+
+  context '#find' do
+    it 'caches calls' do
+      expect(subject).to receive(:resolve).once.and_call_original
+      subject.find(:object)
+      subject.find(:object)
+    end
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--format=progress

data/spec/spec_helper.rb

@@ -0,0 +1,525 @@
+# encoding: utf-8
+require 'rubygems'
+require 'bundler/setup'
+require 'active_support'
+require 'action_pack'
+require 'action_view'
+require 'action_controller'
+require 'action_dispatch'
+
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/formtastic/util'))
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/formtastic'))
+
+#rspec-rails 2-14 assumes a full rails install
+module Rails
+  module VERSION
+    include ActionPack::VERSION
+  end
+end
+
+require 'ammeter/init'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories in alphabetic order.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].sort.each {|f| require f}
+
+I18n.enforce_available_locales = false if I18n.respond_to?(:enforce_available_locales)
+
+module FakeHelpersModule
+end
+
+module FormtasticSpecHelper
+  include ActionPack
+  include ActionView::Context if defined?(ActionView::Context)
+  include ActionController::RecordIdentifier if defined?(ActionController::RecordIdentifier)
+  include ActionView::Helpers::FormHelper
+  include ActionView::Helpers::FormTagHelper
+  include ActionView::Helpers::FormOptionsHelper
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::TextHelper
+  include ActionView::Helpers::ActiveRecordHelper if defined?(ActionView::Helpers::ActiveRecordHelper)
+  include ActionView::Helpers::ActiveModelHelper if defined?(ActionView::Helpers::ActiveModelHelper)
+  include ActionView::Helpers::DateHelper
+  include ActionView::Helpers::CaptureHelper
+  include ActionView::Helpers::AssetTagHelper
+  include ActiveSupport
+  include ActionController::PolymorphicRoutes if defined?(ActionController::PolymorphicRoutes)
+  include ActionDispatch::Routing::PolymorphicRoutes 
+  include AbstractController::UrlFor if defined?(AbstractController::UrlFor)
+  include ActionView::RecordIdentifier if defined?(ActionView::RecordIdentifier)
+  
+  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?
+
+    semantic_form_for(@new_post) do |builder|
+      @default_type = builder.send(:default_input_type, column_name)
+    end
+
+    return @default_type
+  end
+
+  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)
+    validator
+  end
+
+  def active_model_presence_validator(attributes, options = {})
+    active_model_validator(:presence, attributes, options)
+  end
+
+  def active_model_length_validator(attributes, options = {})
+    active_model_validator(:length, attributes, options)
+  end
+
+  def active_model_inclusion_validator(attributes, options = {})
+    active_model_validator(:inclusion, attributes, options)
+  end
+
+  def active_model_numericality_validator(attributes, options = {})
+    active_model_validator(:numericality, attributes, options)
+  end
+
+  class ::MongoPost
+    include MongoMapper::Document if defined?(MongoMapper::Document)
+
+    def id
+    end
+
+    def persisted?
+    end
+  end
+
+
+  class ::Post
+    extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+    include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+
+    def id
+    end
+
+    def persisted?
+    end
+  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
+    end
+  end
+
+  class ::Author
+    extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+    include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+
+    def to_label
+    end
+
+    def persisted?
+    end
+  end
+
+  class ::HashBackedAuthor < Hash
+    extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+    include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+    def persisted?; false; end
+    def name
+      'hash backed author'
+    end
+  end
+
+  class ::Continent
+    extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+    include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+  end
+
+  class ::PostModel
+    extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+    include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+  end
+
+  ##
+  # We can't mock :respond_to?, so we need a concrete class override
+  class ::MongoidReflectionMock < RSpec::Mocks::Double
+    def initialize(name=nil, stubs_and_options={})
+      super name, stubs_and_options
+    end
+
+    def respond_to?(sym)
+      sym == :options ? false : super
+    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.
+  # 
+  # TODO try delegate?
+  # delegate :map, :size, :length, :first, :to_ary, :each, :include?, :to => :array
+  class MockScope
+    attr_reader :array
+    
+    def initialize(the_array)
+      @array = the_array
+    end
+    
+    def map(&block)
+      array.map(&block)
+    end
+    
+    def where(*args)
+      # array
+      self
+    end
+    
+    def includes(*args)
+      self
+    end
+    
+    def size
+      array.size
+    end
+    alias_method :length, :size
+    
+    def first
+      array.first
+    end
+    
+    def to_ary
+      array
+    end
+    
+    def each(&block)
+      array.each(&block)
+    end
+    
+    def include?(*args)
+      array.include?(*args)
+    end
+  end
+
+  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({})
+
+    double('_routes',
+      :url_helpers => url_helpers,
+      :url_for => "/mock/path"
+    )
+  end
+
+  def controller
+    env = double('env', :[] => nil)
+    request = double('request', :env => env)
+    double('controller', :controller_path= => '', :params => {}, :request => request)
+  end
+
+  def default_url_options
+    {}
+  end
+
+  def mock_everything
+
+    # Resource-oriented styles like form_for(@post) will expect a path method for the object,
+    # so we're defining some here.
+    def post_models_path(*args); "/postmodels/1"; end
+
+    def post_path(*args); "/posts/1"; end
+    def posts_path(*args); "/posts"; end
+    def new_post_path(*args); "/posts/new"; end
+
+    def author_path(*args); "/authors/1"; end
+    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
+    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)
+
+    @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}
+
+    @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|
+      case column_name
+      when :author, :author_status
+        mock = double('reflection', :options => {}, :klass => ::Author, :macro => :belongs_to)
+        mock.stub(:[]).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")
+        mock
+      when :authors
+        double('reflection', :options => {}, :klass => ::Author, :macro => :has_and_belongs_to_many)
+      when :sub_posts
+        double('reflection', :options => {}, :klass => ::Post, :macro => :has_many)
+      when :main_post
+        double('reflection', :options => {}, :klass => ::Post, :macro => :belongs_to)
+      when :mongoid_reviewer
+        ::MongoidReflectionMock.new('reflection',
+             :options => Proc.new { raise NoMethodError, "Mongoid has no reflection.options" },
+             :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({
+      :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") )
+
+    @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)
+
+    @mock_file = double('file')
+    Formtastic::FormBuilder.file_methods.each do |method|
+      @mock_file.stub(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)
+
+    # @new_post.should_receive(:publish_at=).at_least(:once)
+    @new_post.stub(:publish_at=)
+    # @new_post.should_receive(:title=).at_least(:once)
+    @new_post.stub(:title=)
+    @new_post.stub(:main_post_id).and_return(nil)
+
+  end
+
+  def self.included(base)
+    base.class_eval do
+
+      attr_accessor :output_buffer
+
+      def protect_against_forgery?
+        false
+      end
+
+      def _helpers
+        FakeHelpersModule
+      end
+
+    end
+  end
+
+  def with_config(config_method_name, value, &block)
+    old_value = Formtastic::FormBuilder.send(config_method_name)
+    Formtastic::FormBuilder.send(:"#{config_method_name}=", value)
+    yield
+    Formtastic::FormBuilder.send(:"#{config_method_name}=", old_value)
+  end
+  
+  RSpec::Matchers.define :errors_matcher do |expected|
+    match { |actual| actual.to_s == expected.to_s }
+  end
+end
+
+class ::ActionView::Base
+  include Formtastic::Helpers::FormHelper
+end
+
+::ActiveSupport::Deprecation.silenced = false
+
+RSpec.configure do |config|
+  config.infer_spec_type_from_file_location!
+
+  config.filter_run focus: true
+  config.filter_run_excluding skip: true
+  config.run_all_when_everything_filtered = true
+
+  config.before(:each) 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
+end