deface 1.0.1 → 1.0.2

data/spec/deface/environment_spec.rb

@@ -24,70 +24,70 @@ module Deface
     describe ".overrides" do
 
       it "should return all overrides" do
-        Rails.application.config.deface.overrides.all.size.should == 2
-        Rails.application.config.deface.overrides.all.should == Deface::Override.all
+        expect(Rails.application.config.deface.overrides.all.size).to eq(2)
+        expect(Rails.application.config.deface.overrides.all).to eq(Deface::Override.all)
       end
 
       it "should find overrides" do
-        Rails.application.config.deface.overrides.find(:virtual_path => "posts/new").size.should == 1
+        expect(Rails.application.config.deface.overrides.find(:virtual_path => "posts/new").size).to eq(1)
       end
 
       describe "load_all" do
 
         before do
-          Rails.application.stub :root => Pathname.new(File.join(File.dirname(__FILE__), '..', "assets"))
-          Rails.application.stub :paths => {}
-          Rails.application.stub_chain :railties, railties_collection_accessor => []
+          allow(Rails.application).to receive_messages :root => Pathname.new(File.join(File.dirname(__FILE__), '..', "assets"))
+          allow(Rails.application).to receive_messages :paths => {}
+          allow(Rails.application).to receive_message_chain :railties, railties_collection_accessor => []
 
-          Deface::DSL::Loader.should_receive(:register)
+          expect(Deface::DSL::Loader).to receive(:register)
         end
 
         it "should enumerate_and_load nil when app has no app/overrides path set" do
-          Rails.application.config.deface.overrides.should_receive(:enumerate_and_load).with(nil, Rails.application.root)
+          expect(Rails.application.config.deface.overrides).to receive(:enumerate_and_load).with(nil, Rails.application.root)
           Rails.application.config.deface.overrides.load_all(Rails.application)
         end
 
         it "should enumerate_and_load path when app has app/overrides path set" do
-          Rails.application.stub :paths => {"app/overrides" => ["app/some_path"] }
-          Rails.application.config.deface.overrides.should_receive(:enumerate_and_load).with(["app/some_path"] , Rails.application.root)
+          allow(Rails.application).to receive_messages :paths => {"app/overrides" => ["app/some_path"] }
+          expect(Rails.application.config.deface.overrides).to receive(:enumerate_and_load).with(["app/some_path"] , Rails.application.root)
           Rails.application.config.deface.overrides.load_all(Rails.application)
         end
 
         it "should enumerate_and_load nil when railtie has no app/overrides path set" do
-          Rails.application.stub_chain :railties, railties_collection_accessor => [double('railtie', :root => "/some/path")]
+          allow(Rails.application).to receive_message_chain :railties, railties_collection_accessor => [double('railtie', :root => "/some/path")]
 
-          Rails.application.config.deface.overrides.should_receive(:enumerate_and_load).with(nil, Rails.application.root)
-          Rails.application.config.deface.overrides.should_receive(:enumerate_and_load).with(nil, "/some/path")
+          expect(Rails.application.config.deface.overrides).to receive(:enumerate_and_load).with(nil, Rails.application.root)
+          expect(Rails.application.config.deface.overrides).to receive(:enumerate_and_load).with(nil, "/some/path")
           Rails.application.config.deface.overrides.load_all(Rails.application)
         end
 
         it "should enumerate_and_load path when railtie has app/overrides path set" do
-          Rails.application.stub_chain :railties, railties_collection_accessor => [ double('railtie', :root => "/some/path", :paths => {"app/overrides" => ["app/some_path"] } )]
+          allow(Rails.application).to receive_message_chain :railties, railties_collection_accessor => [ double('railtie', :root => "/some/path", :paths => {"app/overrides" => ["app/some_path"] } )]
 
-          Rails.application.config.deface.overrides.should_receive(:enumerate_and_load).with(nil, Rails.application.root)
-          Rails.application.config.deface.overrides.should_receive(:enumerate_and_load).with(["app/some_path"] , "/some/path")
+          expect(Rails.application.config.deface.overrides).to receive(:enumerate_and_load).with(nil, Rails.application.root)
+          expect(Rails.application.config.deface.overrides).to receive(:enumerate_and_load).with(["app/some_path"] , "/some/path")
           Rails.application.config.deface.overrides.load_all(Rails.application)
         end
 
         it "should enumerate_and_load railties first, followed by the application iteslf" do
-          Rails.application.stub_chain :railties, railties_collection_accessor => [ double('railtie', :root => "/some/path", :paths => {"app/overrides" => ["app/some_path"] } )]
+          allow(Rails.application).to receive_message_chain :railties, railties_collection_accessor => [ double('railtie', :root => "/some/path", :paths => {"app/overrides" => ["app/some_path"] } )]
 
-          Rails.application.config.deface.overrides.should_receive(:enumerate_and_load).with(["app/some_path"] , "/some/path").ordered
-          Rails.application.config.deface.overrides.should_receive(:enumerate_and_load).with(nil, Rails.application.root).ordered
+          expect(Rails.application.config.deface.overrides).to receive(:enumerate_and_load).with(["app/some_path"] , "/some/path").ordered
+          expect(Rails.application.config.deface.overrides).to receive(:enumerate_and_load).with(nil, Rails.application.root).ordered
           Rails.application.config.deface.overrides.load_all(Rails.application)
         end
 
         it "should ignore railtie with no root" do
           railtie = double('railtie')
-          Rails.application.stub_chain :railties, railties_collection_accessor => [railtie]
+          allow(Rails.application).to receive_message_chain :railties, railties_collection_accessor => [railtie]
 
-          railtie.should_receive(:respond_to?).with(:root)
-          railtie.should_not_receive(:respond_to?).with(:paths)
+          expect(railtie).to receive(:respond_to?).with(:root)
+          expect(railtie).not_to receive(:respond_to?).with(:paths)
           Rails.application.config.deface.overrides.load_all(Rails.application)
         end
 
         it "should clear any previously loaded overrides" do
-          Rails.application.config.deface.overrides.all.should_receive(:clear)
+          expect(Rails.application.config.deface.overrides.all).to receive(:clear)
           Rails.application.config.deface.overrides.load_all(Rails.application)
         end
 
@@ -97,15 +97,15 @@ module Deface
       describe 'load_overrides' do
         let(:assets_path) { Pathname.new(File.join(File.dirname(__FILE__), '..', "assets")) }
         let(:engine) { double('railtie', :root => assets_path, :class => "DummyEngine", :paths => {"app/overrides" => ["dummy_engine"]}) }
-        before { Rails.application.stub(:class => 'RailsAppl') }
+        before { allow(Rails.application).to receive_messages(:class => 'RailsAppl') }
 
         it "should keep a reference to which railtie/app defined the override" do
-          Rails.application.stub :root => assets_path, :paths => {"app/overrides" => ["dummy_app"] }
-          Rails.application.stub_chain :railties, railties_collection_accessor => [ engine ]
+          allow(Rails.application).to receive_messages :root => assets_path, :paths => {"app/overrides" => ["dummy_app"] }
+          allow(Rails.application).to receive_message_chain :railties, railties_collection_accessor => [ engine ]
 
           Rails.application.config.deface.overrides.load_all(Rails.application)
 
-          Deface::Override.all.values.map(&:values).flatten.map(&:railtie_class).should include('RailsAppl', 'DummyEngine')
+          expect(Deface::Override.all.values.map(&:values).flatten.map(&:railtie_class)).to include('RailsAppl', 'DummyEngine')
         end
       end
 
@@ -113,23 +113,23 @@ module Deface
         let(:root) { Pathname.new("/some/path") }
 
         it "should be enumerate default path when none supplied" do
-          Dir.should_receive(:glob).with(root.join "app/overrides", "**", "*.rb")
-          Dir.should_receive(:glob).with(root.join "app/overrides", "**", "*.deface")
+          expect(Dir).to receive(:glob).with(root.join "app/overrides", "**", "*.rb")
+          expect(Dir).to receive(:glob).with(root.join "app/overrides", "**", "*.deface")
           Rails.application.config.deface.overrides.send(:enumerate_and_load, nil, root)
         end
 
         it "should enumerate supplied paths" do
-          Dir.should_receive(:glob).with(root.join "app/junk", "**", "*.rb" )
-          Dir.should_receive(:glob).with(root.join "app/junk", "**", "*.deface" )
-          Dir.should_receive(:glob).with(root.join "app/gold", "**", "*.rb" )
-          Dir.should_receive(:glob).with(root.join "app/gold", "**", "*.deface" )
+          expect(Dir).to receive(:glob).with(root.join "app/junk", "**", "*.rb" )
+          expect(Dir).to receive(:glob).with(root.join "app/junk", "**", "*.deface" )
+          expect(Dir).to receive(:glob).with(root.join "app/gold", "**", "*.rb" )
+          expect(Dir).to receive(:glob).with(root.join "app/gold", "**", "*.deface" )
           Rails.application.config.deface.overrides.send(:enumerate_and_load, ["app/junk", "app/gold"], root)
         end
 
         it "should add paths to watchable_dir when running Rails 3.2" do
-          if Rails.version[0..2] == '3.2'
+          if Rails.version[0..2] >= '3.2'
             Rails.application.config.deface.overrides.send(:enumerate_and_load, ["app/gold"], root)
-            Rails.application.config.watchable_dirs.should == {"/some/path/app/gold" => [:rb, :deface] }
+            expect(Rails.application.config.watchable_dirs).to eq({"/some/path/app/gold" => [:rb, :deface] })
           end
         end
 
@@ -138,15 +138,15 @@ module Deface
 
     describe "#_early" do
       it "should contain one override" do
-        Deface::Override._early.size.should == 1
+        expect(Deface::Override._early.size).to eq(1)
       end
 
       it "should initialize override and be emtpy after early_check" do
         before_count = Rails.application.config.deface.overrides.all.size
         Rails.application.config.deface.overrides.early_check
 
-         Deface::Override._early.size.should == 0
-         Rails.application.config.deface.overrides.all.size.should == (before_count + 1)
+         expect(Deface::Override._early.size).to eq(0)
+         expect(Rails.application.config.deface.overrides.all.size).to eq(before_count + 1)
       end
     end
 

data/spec/deface/haml_converter_spec.rb

@@ -11,77 +11,77 @@ module Deface
 
     describe "convert haml to erb" do
       it "should hanlde simple tags" do
-        haml_to_erb("%%strong.code#message Hello, World!").should == "<strong class='code' id='message'>Hello, World!</strong>"
+        expect(haml_to_erb("%%strong.code#message Hello, World!")).to eq("<strong class='code' id='message'>Hello, World!</strong>")
       end
 
       it "should handle complex tags" do
-        haml_to_erb(%q{#content
+        expect(haml_to_erb(%q{#content
   .left.column
     %h2 Welcome to our site!
     %p= print_information
   .right.column
-    = render :partial => "sidebar"}).should == "<div id='content'>  <div class='left column'>    <h2>Welcome to our site!</h2>    <p>    <%= print_information %></p>  </div>  <div class='right column'>    <%= render :partial => \"sidebar\" %>  </div></div>"
+    = render :partial => "sidebar"})).to eq("<div id='content'>  <div class='left column'>    <h2>Welcome to our site!</h2>    <p>    <%= print_information %></p>  </div>  <div class='right column'>    <%= render :partial => \"sidebar\" %>  </div></div>")
       end
 
       it "should handle simple haml attributes" do
-        haml_to_erb("%meta{:charset => 'utf-8'}").should == "<meta charset='utf-8' />"
-        haml_to_erb("%p(alt='hello world')Hello World!").should == "<p alt='hello world'>Hello World!</p>"
+        expect(haml_to_erb("%meta{:charset => 'utf-8'}")).to eq("<meta charset='utf-8' />")
+        expect(haml_to_erb("%p(alt='hello world')Hello World!")).to eq("<p alt='hello world'>Hello World!</p>")
       end
 
       it "should handle haml attributes with commas" do
-        haml_to_erb("%meta{'http-equiv' => 'X-UA-Compatible', :content => 'IE=edge,chrome=1'}").should == "<meta content='IE=edge,chrome=1' http-equiv='X-UA-Compatible' />"
-        haml_to_erb("%meta(http-equiv='X-UA-Compatible' content='IE=edge,chrome=1')").should == "<meta content='IE=edge,chrome=1' http-equiv='X-UA-Compatible' />"
-        haml_to_erb('%meta{:name => "author", :content => "Example, Inc."}').should == "<meta content='Example, Inc.' name='author' />"
-        haml_to_erb('%meta(name="author" content="Example, Inc.")').should == "<meta content='Example, Inc.' name='author' />"
+        expect(haml_to_erb("%meta{'http-equiv' => 'X-UA-Compatible', :content => 'IE=edge,chrome=1'}")).to eq("<meta content='IE=edge,chrome=1' http-equiv='X-UA-Compatible' />")
+        expect(haml_to_erb("%meta(http-equiv='X-UA-Compatible' content='IE=edge,chrome=1')")).to eq("<meta content='IE=edge,chrome=1' http-equiv='X-UA-Compatible' />")
+        expect(haml_to_erb('%meta{:name => "author", :content => "Example, Inc."}')).to eq("<meta content='Example, Inc.' name='author' />")
+        expect(haml_to_erb('%meta(name="author" content="Example, Inc.")')).to eq("<meta content='Example, Inc.' name='author' />")
 
         if RUBY_VERSION > "1.9"
-          haml_to_erb('%meta{name: "author", content: "Example, Inc."}').should == "<meta content='Example, Inc.' name='author' />"
+          expect(haml_to_erb('%meta{name: "author", content: "Example, Inc."}')).to eq("<meta content='Example, Inc.' name='author' />")
         end
       end
 
       it "should handle haml attributes with evaluated values" do
-        haml_to_erb("%p{ :alt => hello_world}Hello World!").should == "<p data-erb-alt='&lt;%= hello_world %&gt;'>Hello World!</p>"
+        expect(haml_to_erb("%p{ :alt => hello_world}Hello World!")).to eq("<p data-erb-alt='&lt;%= hello_world %&gt;'>Hello World!</p>")
 
         if RUBY_VERSION > "1.9"
-          haml_to_erb("%p{ alt: @hello_world}Hello World!").should == "<p data-erb-alt='&lt;%= @hello_world %&gt;'>Hello World!</p>"
+          expect(haml_to_erb("%p{ alt: @hello_world}Hello World!")).to eq("<p data-erb-alt='&lt;%= @hello_world %&gt;'>Hello World!</p>")
         end
 
-        haml_to_erb("%p(alt=hello_world)Hello World!").should == "<p data-erb-alt='&lt;%= hello_world %&gt;'>Hello World!</p>"
-        haml_to_erb("%p(alt=@hello_world)Hello World!").should == "<p data-erb-alt='&lt;%= @hello_world %&gt;'>Hello World!</p>"
+        expect(haml_to_erb("%p(alt=hello_world)Hello World!")).to eq("<p data-erb-alt='&lt;%= hello_world %&gt;'>Hello World!</p>")
+        expect(haml_to_erb("%p(alt=@hello_world)Hello World!")).to eq("<p data-erb-alt='&lt;%= @hello_world %&gt;'>Hello World!</p>")
       end
 
       it "should handle erb loud" do
-        haml_to_erb("%h3.title= entry.title").should == "<h3 class='title'><%= entry.title %></h3>"
+        expect(haml_to_erb("%h3.title= entry.title")).to eq("<h3 class='title'><%= entry.title %></h3>")
       end
 
       it "should handle single erb silent" do
-        haml_to_erb("- some_method").should == "<% some_method %>"
+        expect(haml_to_erb("- some_method")).to eq("<% some_method %>")
       end
 
       it "should handle implicitly closed erb loud" do
-        haml_to_erb("= if @this == 'this'
+        expect(haml_to_erb("= if @this == 'this'
   %p hello
-").should == "<%= if @this == 'this' %><p>hello</p><% end %>"
+")).to eq("<%= if @this == 'this' %><p>hello</p><% end %>")
       end
 
       it "should handle implicitly closed erb silent" do
-        haml_to_erb("- if foo?
+        expect(haml_to_erb("- if foo?
   %p hello
-").should == "<% if foo? %><p>hello</p><% end %>"
+")).to eq("<% if foo? %><p>hello</p><% end %>")
       end
 
       it "should handle blocks passed to erb loud" do
-        haml_to_erb("= form_for Post.new do |f|
+        expect(haml_to_erb("= form_for Post.new do |f|
   %p
-    = f.text_field :name").should == "<%= form_for Post.new do |f| %><p>  <%= f.text_field :name %></p><% end %>"
+    = f.text_field :name")).to eq("<%= form_for Post.new do |f| %><p>  <%= f.text_field :name %></p><% end %>")
 
       end
 
 
        it "should handle blocks passed to erb silent" do
-        haml_to_erb("- @posts.each do |post|
+        expect(haml_to_erb("- @posts.each do |post|
   %p
-    = post.name").should == "<% @posts.each do |post| %><p>  <%= post.name %></p><% end %>"
+    = post.name")).to eq("<% @posts.each do |post| %><p>  <%= post.name %></p><% end %>")
 
       end
     end

data/spec/deface/override_spec.rb

@@ -12,35 +12,35 @@ module Deface
       Deface::Override.actions.each do |action|
         Rails.application.config.deface.overrides.all.clear
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", action => "h1", :text => "<h1>Argh!</h1>")
-        @override.action.should == action
+        expect(@override.action).to eq(action)
       end
     end
 
     it "should have a sources method" do
-      Deface::DEFAULT_SOURCES.map(&:to_sym).should include(:text)
+      expect(Deface::DEFAULT_SOURCES.map(&:to_sym)).to include(:text)
     end
 
     it "should return correct selector" do
-      @override.selector.should == "h1"
+      expect(@override.selector).to eq("h1")
     end
 
     it "should set default :updated_at" do
-      @override.args[:updated_at].should_not be_nil
+      expect(@override.args[:updated_at]).not_to be_nil
     end
 
     describe "#original_source" do
       it "should return nil with not specified" do
-        @override.original_source.should be_nil
+        expect(@override.original_source).to be_nil
       end
 
       it "should return parsed nokogiri document when present" do
         @original = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h1", :text => "<h1>Argh!</h1>", :original => "<p><%= something %></p>")
-        @original.original_source.should be_an_instance_of Nokogiri::HTML::DocumentFragment
+        expect(@original.original_source).to be_an_instance_of Nokogiri::HTML::DocumentFragment
 
         if RUBY_PLATFORM == 'java'
-          @original.original_source.to_s.should == "<p><erb loud=\"\"> something </erb></p>"
+          expect(@original.original_source.to_s).to eq("<p><erb loud=\"\"> something </erb></p>")
         else
-          @original.original_source.to_s.should == "<p><erb loud> something </erb></p>"
+          expect(@original.original_source.to_s).to eq("<p><erb loud> something </erb></p>")
         end
       end
     end
@@ -51,8 +51,8 @@ module Deface
       end
 
       it "should warn but not validate" do
-        Rails.logger.should_receive(:info).once
-        @override.validate_original("<p>this gets ignored</p>").should be_nil
+        expect(Rails.logger).to receive(:info).once
+        expect(@override.validate_original("<p>this gets ignored</p>")).to be_nil
       end
 
     end
@@ -109,9 +109,9 @@ module Deface
       end
 
       it "should return un-convert text as source" do
-        @override.source.should == "<h1 id=\"<%= dom_id @pirate %>\">Argh!</h1>"
+        expect(@override.source).to eq("<h1 id=\"<%= dom_id @pirate %>\">Argh!</h1>")
 
-        @override.source_argument.should == :text
+        expect(@override.source_argument).to eq(:text)
       end
     end
 
@@ -122,9 +122,9 @@ module Deface
       end
 
       it "should return un-convert text as source" do
-        @override.source.should == "<h1 id=\"<%= dom_id @pirate %>\">Argh!</h1>"
+        expect(@override.source).to eq("<h1 id=\"<%= dom_id @pirate %>\">Argh!</h1>")
 
-        @override.source_argument.should == :erb
+        expect(@override.source_argument).to eq(:erb)
       end
     end
 
@@ -136,9 +136,9 @@ module Deface
       end
 
       it "should return erb converted from haml as source" do
-        @override.source.should == "<strong class='erb' id='message'><%= 'Hello, World!' %>\n</strong>\n"
+        expect(@override.source).to eq("<strong class='erb' id='message'><%= 'Hello, World!' %>\n</strong>\n")
 
-        @override.source_argument.should == :haml
+        expect(@override.source_argument).to eq(:haml)
       end
     end
 
@@ -150,9 +150,9 @@ module Deface
       end
 
       it "should return erb converted from slim as source" do
-        @override.source.should == "<strong class=\"erb\" id=\"message\"><%= ::Temple::Utils.escape_html_safe(('Hello, World!')) %><%\n%></strong>"
+        expect(@override.source).to eq("<strong class=\"erb\" id=\"message\"><%= ::Temple::Utils.escape_html_safe(('Hello, World!')) %>\n</strong>")
 
-        @override.source_argument.should == :slim
+        expect(@override.source_argument).to eq(:slim)
       end
     end
 
@@ -161,15 +161,15 @@ module Deface
 
       before(:each) do
         #stub view paths to be local spec/assets directory
-        ActionController::Base.stub(:view_paths).and_return([File.join(File.dirname(__FILE__), '..', "assets")])
+        allow(ActionController::Base).to receive(:view_paths).and_return([File.join(File.dirname(__FILE__), '..', "assets")])
 
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h1", :partial => "shared/post")
       end
 
       it "should return un-convert partial contents as source" do
-        @override.source.should == "<p>I'm from shared/post partial</p>\n<%= \"And I've got ERB\" %>\n"
+        expect(@override.source).to eq("<p>I'm from shared/post partial</p>\n<%= \"And I've got ERB\" %>\n")
 
-        @override.source_argument.should == :partial
+        expect(@override.source_argument).to eq(:partial)
       end
 
     end
@@ -178,15 +178,15 @@ module Deface
 
       before(:each) do
         #stub view paths to be local spec/assets directory
-        ActionController::Base.stub(:view_paths).and_return([File.join(File.dirname(__FILE__), '..', "assets")])
+        allow(ActionController::Base).to receive(:view_paths).and_return([File.join(File.dirname(__FILE__), '..', "assets")])
 
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h1", :template => "shared/person")
       end
 
       it "should return un-convert template contents as source" do
-        @override.source.should == "<p>I'm from shared/person template</p>\n<%= \"I've got ERB too\" %>\n"
+        expect(@override.source).to eq("<p>I'm from shared/person template</p>\n<%= \"I've got ERB too\" %>\n")
 
-        @override.source_argument.should == :template
+        expect(@override.source_argument).to eq(:template)
       end
 
     end
@@ -197,29 +197,29 @@ module Deface
 
       before(:each) do
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :insert_after => "h1", :copy => "h1")
-        @override.stub(:parsed_document).and_return(parsed)
+        allow(@override).to receive(:parsed_document).and_return(parsed)
       end
 
       it "should not change original parsed source" do
         @override.source
 
         if RUBY_PLATFORM == 'java'
-          parsed.to_s.gsub(/\n/,'').should == "<div><h1>Manage Posts</h1><erb loud=\"\"> some_method </erb></div>"
+          expect(parsed.to_s.gsub(/\n/,'')).to eq("<div><h1>Manage Posts</h1><erb loud=\"\"> some_method </erb></div>")
         else
-          parsed.to_s.gsub(/\n/,'').should == "<div><h1>Manage Posts</h1><erb loud> some_method </erb></div>"
+          expect(parsed.to_s.gsub(/\n/,'')).to eq("<div><h1>Manage Posts</h1><erb loud> some_method </erb></div>")
         end
 
-        @override.source_argument.should == :copy
+        expect(@override.source_argument).to eq(:copy)
       end
 
       it "should return copy of content from source document" do
-        @override.source.to_s.strip.should == "<h1>Manage Posts</h1>"
+        expect(@override.source.to_s.strip).to eq("<h1>Manage Posts</h1>")
       end
 
       it "should return unescaped content for source document" do
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :insert_after => "h1", :copy => "erb[loud]:contains('some_method')")
-        @override.stub(:parsed_document).and_return(parsed)
-        @override.source.should == "<%= some_method %>"
+        allow(@override).to receive(:parsed_document).and_return(parsed)
+        expect(@override.source).to eq("<%= some_method %>")
       end
 
     end
@@ -232,23 +232,23 @@ module Deface
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :insert_after => "h1",
                                          :copy => {:start => "erb:contains('if true')", :end => "erb:contains('end')"})
 
-        @override.stub(:parsed_document).and_return(parsed)
+        allow(@override).to receive(:parsed_document).and_return(parsed)
       end
 
       it "should not change original parsed source" do
         @override.source
 
         if RUBY_PLATFORM == 'java'
-          parsed.to_s.gsub(/\n/,'').should == "<h1>World</h1><erb silent=\"\"> if true </erb><p>True that!</p><erb silent=\"\"> end </erb><p>Hello</p>"
+          expect(parsed.to_s.gsub(/\n/,'')).to eq("<h1>World</h1><erb silent=\"\"> if true </erb><p>True that!</p><erb silent=\"\"> end </erb><p>Hello</p>")
         else
-          parsed.to_s.gsub(/\n/,'').should == "<h1>World</h1><erb silent> if true </erb><p>True that!</p><erb silent> end </erb><p>Hello</p>"
+          expect(parsed.to_s.gsub(/\n/,'')).to eq("<h1>World</h1><erb silent> if true </erb><p>True that!</p><erb silent> end </erb><p>Hello</p>")
         end
 
-        @override.source_argument.should == :copy
+        expect(@override.source_argument).to eq(:copy)
       end
 
       it "should return copy of content from source document" do
-        @override.source.should == "<% if true %><p>True that!</p><% end %>"
+        expect(@override.source).to eq("<% if true %><p>True that!</p><% end %>")
       end
     end
 
@@ -256,28 +256,28 @@ module Deface
       let(:parsed) { Deface::Parser.convert("<div><h1>Manage Posts</h1><%= some_method %></div>") }
       before(:each) do
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :insert_after => "h1", :cut => "h1")
-        @override.stub(:parsed_document).and_return(parsed)
+        allow(@override).to receive(:parsed_document).and_return(parsed)
       end
 
       it "should remove cut element from original parsed source" do
         @override.source
         if RUBY_PLATFORM == 'java'
-          parsed.to_s.gsub(/\n/,'').should == "<div><erb loud=\"\"> some_method </erb></div>"
+          expect(parsed.to_s.gsub(/\n/,'')).to eq("<div><erb loud=\"\"> some_method </erb></div>")
         else
-          parsed.to_s.gsub(/\n/,'').should == "<div><erb loud> some_method </erb></div>"
+          expect(parsed.to_s.gsub(/\n/,'')).to eq("<div><erb loud> some_method </erb></div>")
         end
 
-        @override.source_argument.should == :cut
+        expect(@override.source_argument).to eq(:cut)
       end
 
       it "should remove and return content from source document" do
-        @override.source.should == "<h1>Manage Posts</h1>"
+        expect(@override.source).to eq("<h1>Manage Posts</h1>")
       end
 
       it "should return unescaped content for source document" do
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :insert_after => "h1", :cut => "erb[loud]:contains('some_method')")
-        @override.stub(:parsed_document).and_return(parsed)
-        @override.source.should == "<%= some_method %>"
+        allow(@override).to receive(:parsed_document).and_return(parsed)
+        expect(@override.source).to eq("<%= some_method %>")
       end
 
     end
@@ -291,29 +291,29 @@ module Deface
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :insert_after => "h1",
                                          :cut => {:start => "erb:contains('if true')", :end => "erb:contains('end')"})
 
-        @override.stub(:parsed_document).and_return(parsed)
+        allow(@override).to receive(:parsed_document).and_return(parsed)
       end
 
       it "should remove cut element from original parsed source" do
         @override.source
         if RUBY_PLATFORM == 'java'
-          parsed.to_s.gsub(/\n/,'').should == "<h1>World</h1><erb loud=\"\"> hello </erb>"
+          expect(parsed.to_s.gsub(/\n/,'')).to eq("<h1>World</h1><erb loud=\"\"> hello </erb>")
         else
-          parsed.to_s.gsub(/\n/,'').should == "<h1>World</h1><erb loud> hello </erb>"
+          expect(parsed.to_s.gsub(/\n/,'')).to eq("<h1>World</h1><erb loud> hello </erb>")
         end
 
-        @override.source_argument.should == :cut
+        expect(@override.source_argument).to eq(:cut)
       end
 
       it "should return copy of content from source document" do
-        @override.source.should == "<% if true %><p>True that!</p><% end %>"
+        expect(@override.source).to eq("<% if true %><p>True that!</p><% end %>")
       end
     end
 
     describe "with block" do
       before(:each) do
         #stub view paths to be local spec/assets directory
-        ActionController::Base.stub(:view_paths).and_return([File.join(File.dirname(__FILE__), '..', "assets")])
+        allow(ActionController::Base).to receive(:view_paths).and_return([File.join(File.dirname(__FILE__), '..', "assets")])
 
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h1") do
           "This is replacement text for the h1"
@@ -321,7 +321,7 @@ module Deface
       end
 
       it "should set source to block content" do
-        @override.source.should == "This is replacement text for the h1"
+        expect(@override.source).to eq("This is replacement text for the h1")
       end
     end
 
@@ -332,7 +332,7 @@ module Deface
       end
 
       it "should namespace the override's name" do
-        @override.name.should == 'spree_engine_sample_name'
+        expect(@override.name).to eq('spree_engine_sample_name')
       end
     end
 
@@ -344,7 +344,7 @@ module Deface
       end
 
       it "should namespace the override's name" do
-        @override.name.should == 'spree_engine_sample_name'
+        expect(@override.name).to eq('spree_engine_sample_name')
       end
     end
 
@@ -354,18 +354,18 @@ module Deface
       end
 
       it "should return escaped source" do
-        @override.source_element.should be_an_instance_of Nokogiri::HTML::DocumentFragment
+        expect(@override.source_element).to be_an_instance_of Nokogiri::HTML::DocumentFragment
 
         if RUBY_PLATFORM == 'java'
           source = "<erb loud=\"\"> method :opt =&gt; 'x' &amp; 'y' </erb>"
-          @override.source_element.to_s.should ==  source
+          expect(@override.source_element.to_s).to eq(source)
           #do it twice to ensure it doesn't change as it's destructive
-          @override.source_element.to_s.should == source
+          expect(@override.source_element.to_s).to eq(source)
         else
           source = "<erb loud> method :opt =&gt; 'x' &amp; 'y' </erb>"
-          @override.source_element.to_s.should == source
+          expect(@override.source_element.to_s).to eq(source)
           #do it twice to ensure it doesn't change as it's destructive
-          @override.source_element.to_s.should == source
+          expect(@override.source_element.to_s).to eq(source)
         end
       end
     end
@@ -380,8 +380,8 @@ module Deface
       end
 
       it "should return new source" do
-        @replacement.source.should_not == "<h1>Argh!</h1>"
-        @replacement.source.should == "<h1>Arrrr!</h1>"
+        expect(@replacement.source).not_to eq("<h1>Argh!</h1>")
+        expect(@replacement.source).to eq("<h1>Arrrr!</h1>")
       end
 
     end
@@ -396,7 +396,7 @@ module Deface
       end
 
       it "should return new action" do
-        @replacement.action.should == :insert_after
+        expect(@replacement.action).to eq(:insert_after)
       end
 
       it "should remove old action" do
@@ -408,7 +408,7 @@ module Deface
     describe "when redefining an override when changing source type" do
       before(:each) do
         #stub view paths to be local spec/assets directory
-        ActionController::Base.stub(:view_paths).and_return([File.join(File.dirname(__FILE__), '..', "assets")])
+        allow(ActionController::Base).to receive(:view_paths).and_return([File.join(File.dirname(__FILE__), '..', "assets")])
 
         Rails.application.config.deface.overrides.all.clear
         @override    = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :partial => "shared/post", :replace => "h1", :text => "<span>I'm text</span>")
@@ -418,7 +418,7 @@ module Deface
       end
 
       it "should return new source" do
-        @override.source.should == "<p>I do be a pirate!</p>"
+        expect(@override.source).to eq("<p>I do be a pirate!</p>")
       end
 
     end
@@ -430,56 +430,56 @@ module Deface
         @second = Deface::Override.new(:virtual_path => "posts/index", :name => "second", :insert_after => "li", :text => "<li>second</li>", :sequence => {:after => "first"})
         @first = Deface::Override.new(:virtual_path => "posts/index", :name => "first", :replace => "li", :text => "<li>first</li>")
 
-        @third.sequence.should == 102
-        @second.sequence.should == 101
-        @first.sequence.should == 100
+        expect(@third.sequence).to eq(102)
+        expect(@second.sequence).to eq(101)
+        expect(@first.sequence).to eq(100)
       end
 
       it "should calculate correct before sequences" do
         @second = Deface::Override.new(:virtual_path => "posts/index", :name => "second", :insert_after => "li", :text => "<li>second</li>", :sequence => 99)
         @first = Deface::Override.new(:virtual_path => "posts/index", :name => "first", :replace => "li", :text => "<li>first</li>", :sequence => {:before => "second"})
 
-        @second.sequence.should == 99
-        @first.sequence.should == 98
+        expect(@second.sequence).to eq(99)
+        expect(@first.sequence).to eq(98)
       end
 
       it "should calculate correct sequences with invalid hash" do
         @second = Deface::Override.new(:virtual_path => "posts/index", :name => "second", :insert_after => "li", :text => "<li>second</li>", :sequence => {})
         @first = Deface::Override.new(:virtual_path => "posts/show", :name => "first", :replace => "li", :text => "<li>first</li>", :sequence => {:before => "second"})
 
-        @second.sequence.should == 100
-        @first.sequence.should == 100
+        expect(@second.sequence).to eq(100)
+        expect(@first.sequence).to eq(100)
       end
 
     end
 
     describe "#end_selector" do
       it "should return nil when closing_selector is not defined" do
-        @override.end_selector.should be_nil
+        expect(@override.end_selector).to be_nil
       end
 
       it "should return nil when closing_selector is an empty string" do
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h1", :closing_selector => "", :text => "<h1>Argh!</h1>")
-        @override.end_selector.should be_nil
+        expect(@override.end_selector).to be_nil
       end
 
       it "should return nil when closing_selector is nil" do
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h1", :closing_selector => nil, :text => "<h1>Argh!</h1>")
-        @override.end_selector.should be_nil
+        expect(@override.end_selector).to be_nil
       end
 
       it "should return closing_selector is present" do
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h1", :closing_selector => "h4", :text => "<h1>Argh!</h1>")
-        @override.end_selector.should == "h4"
+        expect(@override.end_selector).to eq("h4")
       end
     end
 
     describe "#touch" do
       it "should change the overrides :updated_at value" do
         before_touch = @override.args[:updated_at]
-        Time.zone.stub(:now).and_return(Time.parse('2006-08-24'))
+        allow(Time.zone).to receive(:now).and_return(Time.parse('2006-08-24'))
         @override.touch
-        @override.args[:updated_at].should_not == before_touch
+        expect(@override.args[:updated_at]).not_to eq(before_touch)
       end
     end
 
@@ -492,18 +492,18 @@ module Deface
       end
 
       it "should return hex digest based on override's args" do
-        @override.digest.should =~ /[a-f0-9]{32}/
+        expect(@override.digest).to match(/[a-f0-9]{32}/)
       end
 
       it "should change the digest when any args change" do
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h2", :text => "<h1>Argh!</h1>")
-        @override.digest.should_not == @digest
+        expect(@override.digest).not_to eq(@digest)
 
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h1", :text => "<h1>Argh!</h1>")
-        @override.digest.should == @digest
+        expect(@override.digest).to eq(@digest)
 
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h2", :text => "<h1>I'm a pirate!</h1>")
-        @override.digest.should_not == @digest
+        expect(@override.digest).not_to eq(@digest)
       end
     end
 
@@ -518,28 +518,28 @@ module Deface
       end
 
       it "should return hex digest based on all applicable overrides" do
-        Deface::Override.digest(:virtual_path =>  "posts/index").should =~ /[a-f0-9]{32}/
+        expect(Deface::Override.digest(:virtual_path =>  "posts/index")).to match(/[a-f0-9]{32}/)
       end
 
       it "should change the digest when any args change for any override" do
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h2", :text => "<h1>Argh!</h1>")
-        Deface::Override.digest(:virtual_path =>  "posts/index").should_not == @digest
+        expect(Deface::Override.digest(:virtual_path =>  "posts/index")).not_to eq(@digest)
 
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h1", :text => "<h1>Argh!</h1>")
-        Deface::Override.digest(:virtual_path =>  "posts/index").should == @digest
+        expect(Deface::Override.digest(:virtual_path =>  "posts/index")).to eq(@digest)
 
         @second = Deface::Override.new(:virtual_path => "posts/index", :name => "2nd", :insert_after => "p", :text => "<pre>this is erb?</pre>")
-        Deface::Override.digest(:virtual_path =>  "posts/index").should_not == @digest
+        expect(Deface::Override.digest(:virtual_path =>  "posts/index")).not_to eq(@digest)
       end
 
       it "should change the digest when overrides are removed / added" do
         Deface::Override.all.clear
 
         @new_digest = Deface::Override.digest(:virtual_path =>  "posts/index")
-        @new_digest.should_not == @digest
+        expect(@new_digest).not_to eq(@digest)
 
         @override = Deface::Override.new(:virtual_path => "posts/index", :name => "Posts#index", :replace => "h1", :text => "<h1>Argh!</h1>")
-        Deface::Override.digest(:virtual_path =>  "posts/index").should_not == @new_digest
+        expect(Deface::Override.digest(:virtual_path =>  "posts/index")).not_to eq(@new_digest)
       end
     end
 
@@ -564,9 +564,9 @@ module Deface
 
         end
 
-        ActionView::CompiledTemplates.instance_methods.size.should == 2
+        expect(ActionView::CompiledTemplates.instance_methods.size).to eq(2)
         @override.send(:expire_compiled_template)
-        ActionView::CompiledTemplates.instance_methods.size.should == 1
+        expect(ActionView::CompiledTemplates.instance_methods.size).to eq(1)
       end
 
       it "should not remove compiled method when virtual path and digest matach" do
@@ -577,11 +577,11 @@ module Deface
           end
         end
 
-        Deface::Override.should_receive(:digest).and_return('e235fa404c3c2281d4f6791162b1c638')
+        expect(Deface::Override).to receive(:digest).and_return('e235fa404c3c2281d4f6791162b1c638')
 
-        ActionView::CompiledTemplates.instance_methods.size.should == 1
+        expect(ActionView::CompiledTemplates.instance_methods.size).to eq(1)
         @override.send(:expire_compiled_template)
-        ActionView::CompiledTemplates.instance_methods.size.should == 1
+        expect(ActionView::CompiledTemplates.instance_methods.size).to eq(1)
       end
     end