snippr 0.15.21 → 0.15.22

data/spec/snippr/processor/dynamics_spec.rb

@@ -7,49 +7,49 @@ describe Snippr::Processor::Dynamics do
     def method; "METHOD"; end
     def method2(param); "METHOD WITH #{param}"; end
     def method3(param1, param2); "METHOD WITH #{param1} AND #{param2}"; end
-  def method4; ""; end
-end
+    def method4; ""; end
+  end
 
   it "replaces placeholders with dynamic values" do
     today = Date.today
-    subject.process('Your topup of {topup_amount} at {date_today} was successful.', {
+    expect(subject.process('Your topup of {topup_amount} at {date_today} was successful.', {
       :topup_amount => "15,00 €",
       :date_today   => today
-    }).should == "Your topup of 15,00 € at #{today} was successful."
+    })).to eq("Your topup of 15,00 € at #{today} was successful.")
   end
 
   it "parses multi-line parameters" do
     tpl = "An instance {var.method2(\"PARAM\t\nETER\")}"
-    subject.process(tpl, :var => Klass.new).should == "An instance METHOD WITH PARAMETER"
+    expect(subject.process(tpl, :var => Klass.new)).to eq("An instance METHOD WITH PARAMETER")
   end
 
   it "Does not kill all whitespace" do
     tpl = "An instance {var.method2(\"PART1\t\n SPACE PART2\")}"
-    subject.process(tpl, :var => Klass.new).should == "An instance METHOD WITH PART1 SPACE PART2"
+    expect(subject.process(tpl, :var => Klass.new)).to eq("An instance METHOD WITH PART1 SPACE PART2")
   end
 
   it "allows calling methods on placeholders" do
     tpl = "An instance {var.method()}"
-    subject.process(tpl, :var => Klass.new).should == "An instance METHOD"
+    expect(subject.process(tpl, :var => Klass.new)).to eq("An instance METHOD")
   end
 
   it "allows calling methods with parameters on placeholders" do
     tpl = 'An instance {var.method2("PARAMETER")}'
-    subject.process(tpl, :var => Klass.new).should == "An instance METHOD WITH PARAMETER"
+    expect(subject.process(tpl, :var => Klass.new)).to eq("An instance METHOD WITH PARAMETER")
   end
 
   it "allows calling methods with multiple parameters on placeholders" do
     tpl = 'An instance {var.method3("PARAMETER1","PARAMETER2")}'
-    subject.process(tpl, :var => Klass.new).should == "An instance METHOD WITH PARAMETER1 AND PARAMETER2"
+    expect(subject.process(tpl, :var => Klass.new)).to eq("An instance METHOD WITH PARAMETER1 AND PARAMETER2")
   end
 
   it "keeps the {snip} if calling a method but the method is not defined" do
-  subject.process("An instance {var.method_not_exist()}", :var => Klass.new).should == "An instance {var.method_not_exist()}"
+  expect(subject.process("An instance {var.method_not_exist()}", :var => Klass.new)).to eq("An instance {var.method_not_exist()}")
   end
 
   it "calls a bang(!) method even if the receiver does not respond_to the method" do
     tpl = "An instance {!var.method_not_exist()}"
-    lambda { subject.process(tpl, :var => Klass.new) }.should raise_error(NoMethodError)
+    expect { subject.process(tpl, :var => Klass.new) }.to raise_error(NoMethodError)
   end
 
   it "defaults the value if the content is empty" do
@@ -57,9 +57,20 @@ end
     expect(subject.process(tpl, empty: "")).to eq "default"
   end
 
-  it "defaults the value if the content is  present" do
+  it "defaults the value if the content is present" do
     tpl = "{var.method4()|default2}"
     expect(subject.process(tpl, var: Klass.new )).to eq "default2"
   end
 
+  it "leaves the dynamic vslue untouched if no replacement and default exists" do
+    tpl = <<-HEREDOC
+      .clazz {
+      }
+
+      .clazz {}
+      </style>
+    HEREDOC
+    expect(subject.process(tpl)).to eq "      .clazz {\n      }\n\n      .clazz {}\n      </style>\n"
+  end
+
 end

data/spec/snippr/processor/functions_spec.rb

@@ -6,34 +6,34 @@ describe Snippr::Processor::Functions do
   describe "#cmd_snip" do
 
     it "includes snips inside of snips" do
-      subject.process('Include a {snip:home} inside a snip').should == "Include a <!-- starting snippr: home -->\n<p>Home</p>\n<!-- closing snippr: home --> inside a snip"
+      expect(subject.process('Include a {snip:home} inside a snip')).to eq("Include a <!-- starting snippr: home -->\n<p>Home</p>\n<!-- closing snippr: home --> inside a snip")
     end
 
     it "passes parameters to the include" do
-      subject.process('Include a {snip:topup/success} inside a snip', {
+      expect(subject.process('Include a {snip:topup/success} inside a snip', {
         :topup_amount => '10',
         :date_today => '123'
-      }).should == "Include a <!-- starting snippr: topup/success -->\n<p>You're topup of 10 at 123 was successful.</p>\n<!-- closing snippr: topup/success --> inside a snip"
+      })).to eq("Include a <!-- starting snippr: topup/success -->\n<p>You're topup of 10 at 123 was successful.</p>\n<!-- closing snippr: topup/success --> inside a snip")
     end
 
     it "allows additional parameters to be passed to the included snippet" do
-      subject.process('Include a {snip:topup/success,topup_amount=99} inside a snip', {
+      expect(subject.process('Include a {snip:topup/success,topup_amount=99} inside a snip', {
         :date_today => '123'
-      }).should == "Include a <!-- starting snippr: topup/success -->\n<p>You're topup of 99 at 123 was successful.</p>\n<!-- closing snippr: topup/success --> inside a snip"
+      })).to eq("Include a <!-- starting snippr: topup/success -->\n<p>You're topup of 99 at 123 was successful.</p>\n<!-- closing snippr: topup/success --> inside a snip")
     end
 
     it "allows additional parameters of the snip call to override parent options" do
-      subject.process('Include a {snip:topup/success,topup_amount=99} inside a snip', {
+      expect(subject.process('Include a {snip:topup/success,topup_amount=99} inside a snip', {
         :date_today => '123',
         :topup_amount => '1'
-      }).should == "Include a <!-- starting snippr: topup/success -->\n<p>You're topup of 99 at 123 was successful.</p>\n<!-- closing snippr: topup/success --> inside a snip"
+      })).to eq("Include a <!-- starting snippr: topup/success -->\n<p>You're topup of 99 at 123 was successful.</p>\n<!-- closing snippr: topup/success --> inside a snip")
     end
 
     it "allows additional parameters of the snip call to override parent options" do
-      subject.process('Include a {snip:topup/success,topup_amount="A B C"} inside a snip', {
+      expect(subject.process('Include a {snip:topup/success,topup_amount="A B C"} inside a snip', {
         :date_today => '123',
         :topup_amount => '1'
-      }).should == "Include a <!-- starting snippr: topup/success -->\n<p>You're topup of A B C at 123 was successful.</p>\n<!-- closing snippr: topup/success --> inside a snip"
+      })).to eq("Include a <!-- starting snippr: topup/success -->\n<p>You're topup of A B C at 123 was successful.</p>\n<!-- closing snippr: topup/success --> inside a snip")
     end
 
     context "relative inclusion via {snip:./name}" do
@@ -76,7 +76,7 @@ describe Snippr::Processor::Functions do
       end
 
       it "works" do
-        subject.process("{snip:home/show/blauappOverviewBoxMobile}").should == "<!-- missing snippr: home/show/blauappOverviewBoxMobile_de -->"
+        expect(subject.process("{snip:home/show/blauappOverviewBoxMobile}")).to eq("<!-- missing snippr: home/show/blauappOverviewBoxMobile_de -->")
       end
     end
 
@@ -85,31 +85,31 @@ describe Snippr::Processor::Functions do
   describe "#hashify" do
 
     it "processes a single argument with no value as default" do
-      subject.send(:hashify, "test").should == { :default => "test" }
+      expect(subject.send(:hashify, "test")).to eq({ :default => "test" })
     end
 
     it "processes a single argument with key and value" do
-      subject.send(:hashify, "key=value").should == { :key => "value" }
+      expect(subject.send(:hashify, "key=value")).to eq({ :key => "value" })
     end
 
     it "processes multiple arguments delimited by comma" do
-      subject.send(:hashify, "key=value,key2=value2").should == { :key => "value", :key2 => "value2" }
+      expect(subject.send(:hashify, "key=value,key2=value2")).to eq({ :key => "value", :key2 => "value2" })
     end
 
     it "processes a combination of all arguments" do
-      subject.send(:hashify, "default,key=value,key2=value2").should == { :default => 'default', :key => "value", :key2 => "value2" }
+      expect(subject.send(:hashify, "default,key=value,key2=value2")).to eq({ :default => 'default', :key => "value", :key2 => "value2" })
     end
 
     it "removes leading and trailing quotes" do
-      subject.send(:hashify, "key='quoted'").should == { :key => 'quoted' }
+      expect(subject.send(:hashify, "key='quoted'")).to eq({ :key => 'quoted' })
     end
 
     it "removes leading and trailing double quotes" do
-      subject.send(:hashify, 'key="quoted"').should == { :key => 'quoted' }
+      expect(subject.send(:hashify, 'key="quoted"')).to eq({ :key => 'quoted' })
     end
 
     it "allows a comma inside quotes strings" do
-      subject.send(:hashify, 'key="with,comma"').should == { :key => 'with,comma' }
+      expect(subject.send(:hashify, 'key="with,comma"')).to eq({ :key => 'with,comma' })
     end
   end
 

data/spec/snippr/processor/links_spec.rb

@@ -6,7 +6,7 @@ describe Snippr::Processor::Links do
   it "should call Snippr::Links.adjust_link with the links found and return the results" do
     expect(Snippr::Links).to receive(:adjust_link).with('<a href="http://www.blaulabs.de" onclick="return true;">here</a>').and_return('--here--')
     expect(Snippr::Links).to receive(:adjust_link).with('<A class=\'link\' href="internal.html">or here</A>').and_return('--or here--')
-    subject.process('click <a href="http://www.blaulabs.de" onclick="return true;">here</a> <A class=\'link\' href="internal.html">or here</A>').should == 'click --here-- --or here--'
+    expect(subject.process('click <a href="http://www.blaulabs.de" onclick="return true;">here</a> <A class=\'link\' href="internal.html">or here</A>')).to eq('click --here-- --or here--')
   end
 
 end

data/spec/snippr/processor/wikilinks_spec.rb

@@ -6,7 +6,7 @@ describe Snippr::Processor::Wikilinks do
   it "should call Snippr::Links.adjust_link with the links found and return the results" do
     expect(Snippr::Links).to receive(:adjust_link).with('<a href="http://www.blaulabs.de">here</a>').and_return('--here--')
     expect(Snippr::Links).to receive(:adjust_link).with('<a href="internal.html">or here</a>').and_return('--or here--')
-    subject.process('click [[http://www.blaulabs.de|here]] [[internal.html|or here]]').should == 'click --here-- --or here--'
+    expect(subject.process('click [[http://www.blaulabs.de|here]] [[internal.html|or here]]')).to eq('click --here-- --or here--')
   end
 
 end

data/spec/snippr/processor_spec.rb

@@ -6,17 +6,17 @@ describe Snippr::Processor do
   describe ".processors" do
 
     it "is an array" do
-      subject.processors.should be_an(Array)
+      expect(subject.processors).to be_an(Array)
     end
 
     it "has a set of default processors" do
       processors = subject.processors
-      processors.size.should == 5
-      processors[0].should be_a(Snippr::Processor::Block)
-      processors[1].should be_a(Snippr::Processor::Functions)
-      processors[2].should be_a(Snippr::Processor::Dynamics)
-      processors[3].should be_a(Snippr::Processor::Links)
-      processors[4].should be_a(Snippr::Processor::Wikilinks)
+      expect(processors.size).to eq(5)
+      expect(processors[0]).to be_a(Snippr::Processor::Block)
+      expect(processors[1]).to be_a(Snippr::Processor::Functions)
+      expect(processors[2]).to be_a(Snippr::Processor::Dynamics)
+      expect(processors[3]).to be_a(Snippr::Processor::Links)
+      expect(processors[4]).to be_a(Snippr::Processor::Wikilinks)
     end
 
   end
@@ -26,10 +26,10 @@ describe Snippr::Processor do
     it "calls process on all processors, passing the content between them and returning the last result" do
       parent = Snippr::Snip.new
       subject.processors.each_with_index do |processor, i|
-        processor.should respond_to(:process)
+        expect(processor).to respond_to(:process)
         expect(processor).to receive(:process).with(i.to_s, {'1' => '2', :_parent => parent}).and_return((i + 1).to_s)
       end
-      subject.process('0', {'1' => '2'}, parent).should == subject.processors.size.to_s
+      expect(subject.process('0', {'1' => '2'}, parent)).to eq(subject.processors.size.to_s)
     end
 
   end

data/spec/snippr/segment_filter/base_spec.rb

@@ -3,6 +3,6 @@ require "spec_helper"
 
 describe "Snippr::SegmentFilter::Base" do
   it "remembers its subclasses" do
-    Snippr::SegmentFilter::Base.should have(5).filters
+    expect(Snippr::SegmentFilter::Base.filters.size).to eq(5)
   end
 end

data/spec/snippr/segment_filter/on_host_spec.rb

@@ -7,14 +7,14 @@ describe "Snippr::SegmentFilter::OnHoAst" do
   end
 
   it "is active on the given host" do
-    Snippr::SegmentFilter::OnHost.new("thishost").should be_active
+    expect(Snippr::SegmentFilter::OnHost.new("thishost")).to be_active
   end
 
   it "inactive on other than the given host" do
-    Snippr::SegmentFilter::OnHost.new("thathost").should_not be_active
+    expect(Snippr::SegmentFilter::OnHost.new("thathost")).not_to be_active
   end
 
   it "allows multiple hostnames to be given" do
-    Snippr::SegmentFilter::OnHost.new("ahost, , thishost,     foobarhost").should be_active
+    expect(Snippr::SegmentFilter::OnHost.new("ahost, , thishost,     foobarhost")).to be_active
   end
 end

data/spec/snippr/segment_filter/on_rails_env_spec.rb

@@ -13,14 +13,14 @@ describe "Snippr::SegmentFilter::OnRailsEnv" do
 
   it "is active in the defined environment" do
     expect(Rails).to receive(:env).and_return("test")
-    Snippr::SegmentFilter::OnRailsEnv.new("test").should be_active
+    expect(Snippr::SegmentFilter::OnRailsEnv.new("test")).to be_active
   end
 
   it "is not active in other environments" do
-    Snippr::SegmentFilter::OnRailsEnv.new("non-existing-env").should_not be_active
+    expect(Snippr::SegmentFilter::OnRailsEnv.new("non-existing-env")).not_to be_active
   end
 
   it "allows multiple environments to be given" do
-    Snippr::SegmentFilter::OnRailsEnv.new("a_env, test, development,     foobar").should be_active
+    expect(Snippr::SegmentFilter::OnRailsEnv.new("a_env, test, development,     foobar")).to be_active
   end
 end

data/spec/snippr/segment_filter/valid_between_spec.rb

@@ -3,18 +3,18 @@ require "spec_helper"
 
 describe "Snippr::SegmentFilter::ValidBetween" do
   it "returns true if 'now' is between the filter dates" do
-    Snippr::SegmentFilter::ValidBetween.new("1976-03-10 09:00:00 - 9999-09-01 23:59:59").should be_active
+    expect(Snippr::SegmentFilter::ValidBetween.new("1976-03-10 09:00:00 - 9999-09-01 23:59:59")).to be_active
   end
 
   it "returns false if 'now' is outside the filter dates" do
-    Snippr::SegmentFilter::ValidBetween.new("1976-03-10 09:00:00 - 1977-09-01 23:59:59").should_not be_active
+    expect(Snippr::SegmentFilter::ValidBetween.new("1976-03-10 09:00:00 - 1977-09-01 23:59:59")).not_to be_active
   end
 
   it "returns false if the from date is not parsable" do
-    Snippr::SegmentFilter::ValidBetween.new("xxxx-03-10 09:00:00 - 1977-09-01 23:59:59").should_not be_active
+    expect(Snippr::SegmentFilter::ValidBetween.new("xxxx-03-10 09:00:00 - 1977-09-01 23:59:59")).not_to be_active
   end
 
   it "returns false if the until date is not parsable" do
-    Snippr::SegmentFilter::ValidBetween.new("1976-03-10 09:00:00 - xxxx-09-01 23:59:59").should_not be_active
+    expect(Snippr::SegmentFilter::ValidBetween.new("1976-03-10 09:00:00 - xxxx-09-01 23:59:59")).not_to be_active
   end
 end

data/spec/snippr/segment_filter/valid_from_spec.rb

@@ -3,14 +3,14 @@ require "spec_helper"
 
 describe "Snippr::SegmentFilter::ValidFrom" do
   it "returns true if the filter date is before now" do
-    Snippr::SegmentFilter::ValidFrom.new("1976-03-10 09:00:00").should be_active
+    expect(Snippr::SegmentFilter::ValidFrom.new("1976-03-10 09:00:00")).to be_active
   end
 
   it "returns false if the filter date is after now" do
-    Snippr::SegmentFilter::ValidFrom.new("9999-03-10 09:00:00").should_not be_active
+    expect(Snippr::SegmentFilter::ValidFrom.new("9999-03-10 09:00:00")).not_to be_active
   end
 
   it "returns false if the filter date is unparsable" do
-    Snippr::SegmentFilter::ValidFrom.new("99990310090000").should_not be_active
+    expect(Snippr::SegmentFilter::ValidFrom.new("99990310090000")).not_to be_active
   end
 end

data/spec/snippr/segment_filter/valid_until_spec.rb

@@ -3,14 +3,14 @@ require "spec_helper"
 
 describe "Snippr::SegmentFilter::ValidUntil" do
   it "returns false if the filter date is before now" do
-    Snippr::SegmentFilter::ValidUntil.new("1976-03-10 09:00:00").should_not be_active
+    expect(Snippr::SegmentFilter::ValidUntil.new("1976-03-10 09:00:00")).not_to be_active
   end
 
   it "returns true if the filter date is after now" do
-    Snippr::SegmentFilter::ValidUntil.new("9999-03-10 09:00:00").should be_active
+    expect(Snippr::SegmentFilter::ValidUntil.new("9999-03-10 09:00:00")).to be_active
   end
 
   it "returns false if the filter date is unparsable" do
-    Snippr::SegmentFilter::ValidUntil.new("99990310090000").should_not be_active
+    expect(Snippr::SegmentFilter::ValidUntil.new("99990310090000")).not_to be_active
   end
 end

data/spec/snippr/segment_parser_spec.rb

@@ -4,42 +4,42 @@ require "spec_helper"
 describe "SegmentParser" do
 
   it "allows scissor symbols to be the delimiter. yay!" do
-    Snippr::SegmentParser.new("a\n=✄== valid_from: 3099-05-01 09:00:00 ====\nb").content.should == "a"
+    expect(Snippr::SegmentParser.new("a\n=✄== valid_from: 3099-05-01 09:00:00 ====\nb").content).to eq("a")
   end
 
   it "chooses the correct segment if no condition is given" do
-    Snippr::SegmentParser.new("a\nb").content.should == "a\nb"
+    expect(Snippr::SegmentParser.new("a\nb").content).to eq("a\nb")
   end
 
   it "chooses the correct segment if no valid condition is given" do
-    Snippr::SegmentParser.new("a\n==== valid_from: 3099-05-01 09:00:00 ====\nb").content.should == "a"
+    expect(Snippr::SegmentParser.new("a\n==== valid_from: 3099-05-01 09:00:00 ====\nb").content).to eq("a")
   end
 
   it "chooses the correct segment if a valid condition is given" do
-    Snippr::SegmentParser.new("a\n==== valid_from: 1099-05-01 09:00:00 ====\nb").content.should == "b"
+    expect(Snippr::SegmentParser.new("a\n==== valid_from: 1099-05-01 09:00:00 ====\nb").content).to eq("b")
   end
 
   it "returns the first matching segment if multiple segments are given" do
-    Snippr::SegmentParser.new("a\n==== valid_from: 1099-05-01 09:00:00 ====\nb\n==== valid_from: 1100-05-01 09:00:00 ====\nc").content.should == "b"
+    expect(Snippr::SegmentParser.new("a\n==== valid_from: 1099-05-01 09:00:00 ====\nb\n==== valid_from: 1100-05-01 09:00:00 ====\nc").content).to eq("b")
   end
 
   it "can handle more than two segments" do
-    Snippr::SegmentParser.new("a\n==== valid_from: 6099-05-01 09:00:00 ====\nb\n==== valid_from: 1100-05-01 09:00:00 ====\nc").content.should == "c"
+    expect(Snippr::SegmentParser.new("a\n==== valid_from: 6099-05-01 09:00:00 ====\nb\n==== valid_from: 1100-05-01 09:00:00 ====\nc").content).to eq("c")
   end
 
   it "doesn't need a newline after the last segment" do
-    Snippr::SegmentParser.new("a\n==== valid_from: 1099-05-01 09:00:00 ====").content.should be_empty
+    expect(Snippr::SegmentParser.new("a\n==== valid_from: 1099-05-01 09:00:00 ====").content).to be_empty
   end
 
   it "chooses the correct segment even with \r\n" do
-    Snippr::SegmentParser.new("alt\r\n==== valid_from: 1099-05-01 09:00:00 ====\r\nneu\r\n").content.should == "neu"
+    expect(Snippr::SegmentParser.new("alt\r\n==== valid_from: 1099-05-01 09:00:00 ====\r\nneu\r\n").content).to eq("neu")
   end
 
   it 'works with yml block in old block' do
-    Snippr::SegmentParser.new("---\nyml_key: yml_value\nalt\n==== valid_from: 1099-05-01 09:00:00 ====\nneu\n").content.should == "neu"
+    expect(Snippr::SegmentParser.new("---\nyml_key: yml_value\nalt\n==== valid_from: 1099-05-01 09:00:00 ====\nneu\n").content).to eq("neu")
   end
 
   it 'works with yml block in new block' do
-    Snippr::SegmentParser.new("---\nyml_key: yml_value\n---\nalt\n==== valid_from: 1099-05-01 09:00:00 ====\n---\nyml_key: yml_value\n---\nneu\n").content.should == "---\nyml_key: yml_value\n---\nneu"
+    expect(Snippr::SegmentParser.new("---\nyml_key: yml_value\n---\nalt\n==== valid_from: 1099-05-01 09:00:00 ====\n---\nyml_key: yml_value\n---\nneu\n").content).to eq("---\nyml_key: yml_value\n---\nneu")
   end
 end

data/spec/snippr/snip_spec.rb

@@ -16,48 +16,48 @@ describe Snippr::Snip do
       end
 
       it "calls #after_initialize" do
-        Snippr::Snip.any_instance.should_receive(:after_initialize).once
+        expect_any_instance_of(Snippr::Snip).to receive(:after_initialize).once
         Snippr::Snip.new(:path_to_snips, :file)
       end
 
       it "initializes name, path and opts without opts" do
         snip = Snippr::Snip.new(:path_to_snips, :file)
-        snip.name.should == 'pathToSnips/file'
-        snip.path.should == 'path/pathToSnips/file.snip'
-        snip.opts.should == {}
+        expect(snip.name).to eq('pathToSnips/file')
+        expect(snip.path).to eq('path/pathToSnips/file.snip')
+        expect(snip.opts).to eq({})
       end
 
       it "initializes name, path and opts with opts" do
         snip = Snippr::Snip.new(:path_to_snips, :file, :key => :value)
-        snip.name.should == 'pathToSnips/file'
-        snip.path.should == 'path/pathToSnips/file.snip'
-        snip.opts.should == {:key => :value}
+        expect(snip.name).to eq('pathToSnips/file')
+        expect(snip.path).to eq('path/pathToSnips/file.snip')
+        expect(snip.opts).to eq({:key => :value})
       end
 
       it "initializes name, path and opts with given extension" do
         snip = Snippr::Snip.new(:path_to_snips, :file, :extension => :yml)
-        snip.name.should == "pathToSnips/file"
-        snip.path.should == "path/pathToSnips/file.yml"
-        snip.opts.should == { :extension => :yml }
+        expect(snip.name).to eq("pathToSnips/file")
+        expect(snip.path).to eq("path/pathToSnips/file.yml")
+        expect(snip.opts).to eq({ :extension => :yml })
       end
 
       it "initializes name, path and opts with given i18n deactivation" do
         snip = Snippr::Snip.new(:path_to_snips, :file, :i18n => true)
-        snip.name.should == "pathToSnips/file_#{::I18n.locale}"
-        snip.path.should == "path/pathToSnips/file_#{::I18n.locale}.snip"
-        snip.opts.should == { :i18n => true }
+        expect(snip.name).to eq("pathToSnips/file_#{::I18n.locale}")
+        expect(snip.path).to eq("path/pathToSnips/file_#{::I18n.locale}.snip")
+        expect(snip.opts).to eq({ :i18n => true })
       end
 
       it "returns no double slashes in the path for nil value" do
         snip = Snippr::Snip.new(:path_to_snips, nil ,:file)
-        snip.name.should == 'pathToSnips/file'
-        snip.path.should == 'path/pathToSnips/file.snip'
+        expect(snip.name).to eq('pathToSnips/file')
+        expect(snip.path).to eq('path/pathToSnips/file.snip')
       end
 
       it "returns no double slahes in the path for empty string value" do
         snip = Snippr::Snip.new(:path_to_snips, "" ,:file)
-        snip.name.should == 'pathToSnips/file'
-        snip.path.should == 'path/pathToSnips/file.snip'
+        expect(snip.name).to eq('pathToSnips/file')
+        expect(snip.path).to eq('path/pathToSnips/file.snip')
       end
 
     end
@@ -70,30 +70,30 @@ describe Snippr::Snip do
 
       it "initializes name, path and opts without opts" do
         snip = Snippr::Snip.new(:path_to_snips, :file)
-        snip.name.should == "pathToSnips/file_#{::I18n.locale}"
-        snip.path.should == "path/pathToSnips/file_#{::I18n.locale}.snip"
-        snip.opts.should == {}
+        expect(snip.name).to eq("pathToSnips/file_#{::I18n.locale}")
+        expect(snip.path).to eq("path/pathToSnips/file_#{::I18n.locale}.snip")
+        expect(snip.opts).to eq({})
       end
 
       it "initializes name, path and opts with opts" do
         snip = Snippr::Snip.new(:path_to_snips, :file, :key => :value)
-        snip.name.should == "pathToSnips/file_#{::I18n.locale}"
-        snip.path.should == "path/pathToSnips/file_#{::I18n.locale}.snip"
-        snip.opts.should == {:key => :value}
+        expect(snip.name).to eq("pathToSnips/file_#{::I18n.locale}")
+        expect(snip.path).to eq("path/pathToSnips/file_#{::I18n.locale}.snip")
+        expect(snip.opts).to eq({:key => :value})
       end
 
       it "initializes name, path and opts with given extension" do
         snip = Snippr::Snip.new(:path_to_snips, :file, :extension => :yml)
-        snip.name.should == "pathToSnips/file_#{::I18n.locale}"
-        snip.path.should == "path/pathToSnips/file_#{::I18n.locale}.yml"
-        snip.opts.should == { :extension => :yml }
+        expect(snip.name).to eq("pathToSnips/file_#{::I18n.locale}")
+        expect(snip.path).to eq("path/pathToSnips/file_#{::I18n.locale}.yml")
+        expect(snip.opts).to eq({ :extension => :yml })
       end
 
       it "initializes name, path and opts with given i18n deactivation" do
         snip = Snippr::Snip.new(:path_to_snips, :file, :i18n => false)
-        snip.name.should == "pathToSnips/file"
-        snip.path.should == "path/pathToSnips/file.snip"
-        snip.opts.should == { :i18n => false }
+        expect(snip.name).to eq("pathToSnips/file")
+        expect(snip.path).to eq("path/pathToSnips/file.snip")
+        expect(snip.opts).to eq({ :i18n => false })
       end
     end
 
@@ -103,23 +103,23 @@ describe Snippr::Snip do
   describe "#unprocessed_content" do
 
     it "reads an existing snip" do
-      Snippr::Snip.new(:home).unprocessed_content.should == '<p>Home</p>'
+      expect(Snippr::Snip.new(:home).unprocessed_content).to eq('<p>Home</p>')
     end
 
     it "stores the read data instead of reading it again" do
-      File.should_receive(:read).once.and_return('data')
+      expect(File).to receive(:read).once.and_return('data')
       snip = Snippr::Snip.new(:home)
-      snip.unprocessed_content.should == 'data'
-      snip.unprocessed_content.should == 'data'
+      expect(snip.unprocessed_content).to eq('data')
+      expect(snip.unprocessed_content).to eq('data')
     end
 
     it "returns an empty string on missing snips" do
-      File.should_receive(:read).never
-      Snippr::Snip.new(:doesnotexist).unprocessed_content.should == ''
+      expect(File).to receive(:read).never
+      expect(Snippr::Snip.new(:doesnotexist).unprocessed_content).to eq('')
     end
 
     it "strips the read content" do
-      Snippr::Snip.new(:empty).unprocessed_content.should == ''
+      expect(Snippr::Snip.new(:empty).unprocessed_content).to eq('')
     end
 
   end
@@ -127,35 +127,35 @@ describe Snippr::Snip do
   describe "content" do
 
     it "calls Snippr::Processor.process with opts and return decorated result" do
-      Snippr::Processor.should_receive(:process).with('<p>Home</p>', {:a => :b}, anything()).and_return('processed')
-      Snippr::Snip.new(:home, :a => :b).content.should == "<!-- starting snippr: home -->\nprocessed\n<!-- closing snippr: home -->"
+      expect(Snippr::Processor).to receive(:process).with('<p>Home</p>', {:a => :b}, anything()).and_return('processed')
+      expect(Snippr::Snip.new(:home, :a => :b).content).to eq("<!-- starting snippr: home -->\nprocessed\n<!-- closing snippr: home -->")
     end
 
     it "stores the processed data instead of processing it again" do
-      Snippr::Processor.should_receive(:process).with('<p>Home</p>', {:a => :b}, anything()).once.and_return('processed')
+      expect(Snippr::Processor).to receive(:process).with('<p>Home</p>', {:a => :b}, anything()).once.and_return('processed')
       snip = Snippr::Snip.new(:home, :a => :b)
-      snip.content.should == "<!-- starting snippr: home -->\nprocessed\n<!-- closing snippr: home -->"
-      snip.content.should == "<!-- starting snippr: home -->\nprocessed\n<!-- closing snippr: home -->"
+      expect(snip.content).to eq("<!-- starting snippr: home -->\nprocessed\n<!-- closing snippr: home -->")
+      expect(snip.content).to eq("<!-- starting snippr: home -->\nprocessed\n<!-- closing snippr: home -->")
     end
 
     it "doesn't call Snippr::Processor.process and return missing string" do
-      Snippr::Processor.should_receive(:process).never
-      Snippr::Snip.new(:doesnotexist, :a => :b).content.should == '<!-- missing snippr: doesnotexist -->'
+      expect(Snippr::Processor).to receive(:process).never
+      expect(Snippr::Snip.new(:doesnotexist, :a => :b).content).to eq('<!-- missing snippr: doesnotexist -->')
     end
   end
 
   describe "#missing?" do
 
     it "returns true when the snip isn't there" do
-      Snippr::Snip.new(:doesnotexist).should be_missing
+      expect(Snippr::Snip.new(:doesnotexist)).to be_missing
     end
 
     it "returns false when the snip is there but empty" do
-      Snippr::Snip.new(:empty).should_not be_missing
+      expect(Snippr::Snip.new(:empty)).not_to be_missing
     end
 
     it "returns false when the snip is there and has content" do
-      Snippr::Snip.new(:home).should_not be_missing
+      expect(Snippr::Snip.new(:home)).not_to be_missing
     end
 
   end
@@ -163,15 +163,15 @@ describe Snippr::Snip do
   describe "#empty?" do
 
     it "returns true when the snip isn't there" do
-      Snippr::Snip.new(:doesnotexist).should be_empty
+      expect(Snippr::Snip.new(:doesnotexist)).to be_empty
     end
 
     it "returns false when the snip is there but empty" do
-      Snippr::Snip.new(:empty).should be_empty
+      expect(Snippr::Snip.new(:empty)).to be_empty
     end
 
     it "returns false when the snip is there and has content" do
-      Snippr::Snip.new(:home).should_not be_empty
+      expect(Snippr::Snip.new(:home)).not_to be_empty
     end
 
   end