inversion 0.12.3 → 0.14.0

data/spec/inversion/sinatra_spec.rb

@@ -1,19 +1,10 @@
 #!/usr/bin/env rspec -cfd -b
 # vim: set noet nosta sw=4 ts=4 :
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname( __FILE__ ).dirname.parent.parent
-	libdir  = basedir + 'lib'
-
-	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
-	$LOAD_PATH.unshift( libdir.to_s )  unless $LOAD_PATH.include?( libdir.to_s )
-}
-
-require 'rspec'
-require 'spec/lib/helpers'
+require_relative '../helpers'
 
 begin
+	require 'sinatra'
 	require 'rack/test'
 	require 'inversion/sinatra'
 	$sinatra_support = true
@@ -25,21 +16,17 @@ end
 describe "Sinatra support", :if => $sinatra_support do
 	include Rack::Test::Methods if defined?( ::Rack )
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
 	before( :each ) do
 		@datadir = Pathname( __FILE__ ).dirname.parent + 'data'
-		Sinatra::Base.set :environment, :test
 	end
 
 	def app
+		Sinatra::Base.set :environment, :test
 		@app
 	end
 
 	it "extends the Sinatra DSL with an #inversion helper method" do
-		Sinatra::Base.instance_methods.should include( :inversion )
+		expect( Sinatra::Base.instance_methods ).to include( :inversion )
 	end
 
 	it "renders .inversion files in views path" do
@@ -51,8 +38,8 @@ describe "Sinatra support", :if => $sinatra_support do
 		end
 
 		get '/'
-		last_response.should be_ok
-	    last_response.body.should == 'Hello, Sinatra!'
+		expect( last_response ).to be_ok
+		expect( last_response.body ).to eq( 'Hello, Sinatra!' )
 	end
 
 end

data/spec/inversion/template/attrtag_spec.rb

@@ -1,120 +1,103 @@
 #!/usr/bin/env rspec -cfd -b
 # vim: set noet nosta sw=4 ts=4 :
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname( __FILE__ ).dirname.parent.parent.parent
-	libdir = basedir + 'lib'
+require_relative '../../helpers'
 
-	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
-	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
-}
-
-require 'rspec'
-require 'spec/lib/helpers'
 require 'inversion/template/attrtag'
 
 describe Inversion::Template::AttrTag do
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
-	after( :all ) do
-		reset_logging()
-	end
-
 	describe "parsing" do
 
 		it "can have a simple attribute name" do
-			Inversion::Template::AttrTag.new( 'foo' ).name.should == :foo
+			expect( described_class.new( 'foo' ).name ).to eq( :foo )
 		end
 
 		it "can have an attribute name and a format string" do
-			tag = Inversion::Template::AttrTag.new( '"%0.2f" % foo' )
-			tag.name.should == :foo
-			tag.format.should == '%0.2f'
+			tag = described_class.new( '"%0.2f" % foo' )
+			expect( tag.name ).to eq( :foo )
+			expect( tag.format ).to eq( '%0.2f' )
 		end
 
 		it "raises an exception with an unknown operator" do
 			expect {
-				Inversion::Template::AttrTag.new( '"%0.2f" + foo' )
-			}.to raise_exception( Inversion::ParseError, /expected/ )
+				described_class.new( '"%0.2f" + foo' )
+			}.to raise_error( Inversion::ParseError, /expected/ )
 		end
 
 		it "raises an exception if it has more than one identifier" do
 			expect {
-				Inversion::Template::AttrTag.new( '"%0.2f" % [ foo, bar ]' )
-			}.to raise_exception( Inversion::ParseError, /expected/ )
+				described_class.new( '"%0.2f" % [ foo, bar ]' )
+			}.to raise_error( Inversion::ParseError, /expected/ )
 		end
 
 		it "supports simple <identifier>.<methodname> syntax" do
-			tag = Inversion::Template::AttrTag.new( 'foo.bar' )
+			tag = described_class.new( 'foo.bar' )
 
-			tag.name.should == :foo
-			tag.methodchain.should == '.bar'
+			expect( tag.name ).to eq( :foo )
+			expect( tag.methodchain ).to eq( '.bar' )
 		end
 
 		it "supports index operator (<identifier>.methodname[ <arguments> ]) syntax" do
-			tag = Inversion::Template::AttrTag.new( 'foo.bar[8]' )
+			tag = described_class.new( 'foo.bar[8]' )
 
-			tag.name.should == :foo
-			tag.methodchain.should == '.bar[8]'
+			expect( tag.name ).to eq( :foo )
+			expect( tag.methodchain ).to eq( '.bar[8]' )
 		end
 
 		it "supports index operator (<identifier>[ <arguments> ]) syntax" do
-			tag = Inversion::Template::AttrTag.new( 'foo[8]' )
+			tag = described_class.new( 'foo[8]' )
 
-			tag.name.should == :foo
-			tag.methodchain.should == '[8]'
+			expect( tag.name ).to eq( :foo )
+			expect( tag.methodchain ).to eq( '[8]' )
 		end
 
 		it "supports <identifier>.<methodname>( <arguments> ) syntax" do
-			tag = Inversion::Template::AttrTag.new( 'foo.bar( 8, :baz )' )
+			tag = described_class.new( 'foo.bar( 8, :baz )' )
 
-			tag.name.should == :foo
-			tag.methodchain.should == '.bar( 8, :baz )'
+			expect( tag.name ).to eq( :foo )
+			expect( tag.methodchain ).to eq( '.bar( 8, :baz )' )
 		end
 
 		it "can have a format with a methodchain" do
-			tag = Inversion::Template::AttrTag.new( '"%0.02f" % foo.bar( 8 )' )
+			tag = described_class.new( '"%0.02f" % foo.bar( 8 )' )
 
-			tag.name.should == :foo
-			tag.methodchain.should == '.bar( 8 )'
-			tag.format.should == '%0.02f'
+			expect( tag.name ).to eq( :foo )
+			expect( tag.methodchain ).to eq( '.bar( 8 )' )
+			expect( tag.format ).to eq( '%0.02f' )
 		end
 	end
 
 	describe "rendering" do
 
 		it "can render itself as a comment for template debugging" do
-			tag = Inversion::Template::AttrTag.new( 'foo.bar( 8, :baz )' )
-			tag.as_comment_body.should == "Attr: { template.foo.bar( 8, :baz ) }"
+			tag = described_class.new( 'foo.bar( 8, :baz )' )
+			expect( tag.as_comment_body ).to eq( "Attr: { template.foo.bar( 8, :baz ) }" )
 		end
 
 		context "without a format" do
 
 			before( :each ) do
-				@tag = Inversion::Template::AttrTag.new( 'foo' )
+				@tag = described_class.new( 'foo' )
 			end
 
 			it "renders as the stringified contents of the template attribute with the same name" do
 				state = Inversion::RenderState.new( :foo => %w[floppy the turtle] )
-				@tag.render( state ).should == ["floppy", "the", "turtle"]
+				expect( @tag.render( state ) ).to eq( ["floppy", "the", "turtle"] )
 			end
 
 			it "doesn't error if the attribute isn't set on the template" do
 				state = Inversion::RenderState.new( :foo => nil )
-				@tag.render( state ).should == nil
+				expect( @tag.render( state ) ).to eq( nil )
 			end
 
 			it "returns false when the rendered value is false" do
 				state = Inversion::RenderState.new( :foo => false )
-				@tag.render( state ).should equal( false )
+				expect( @tag.render( state ) ).to equal( false )
 			end
 
 			it "can render itself as a comment for template debugging" do
-				@tag.as_comment_body.should == 'Attr: { template.foo }'
+				expect( @tag.as_comment_body ).to eq( 'Attr: { template.foo }' )
 			end
 
 		end
@@ -122,25 +105,22 @@ describe Inversion::Template::AttrTag do
 		context "with a format" do
 
 			before( :each ) do
-				@tag = Inversion::Template::AttrTag.new( 'foo' )
+				@tag = described_class.new( 'foo' )
 				@tag.format = "%0.2f"
 			end
 
 			it "renders as the formatted contents of the template attribute with the same name" do
 				state = Inversion::RenderState.new( :foo => Math::PI )
-				@tag.render( state ).should == '3.14'
+				expect( @tag.render( state ) ).to eq( '3.14' )
 			end
 
 			it "doesn't error if the attribute isn't set on the template" do
-				pending "recalling why we did this" do
-					state = Inversion::RenderState.new( :foo => nil )
-					@tag.render( state ).should == nil
-				end
+				state = Inversion::RenderState.new( :foo => nil )
+				expect( @tag.render(state) ).to eq( nil )
 			end
 
 			it "can render itself as a comment for template debugging" do
-				@tag.as_comment_body.
-					should == 'Attr: { template.foo } with format: "%0.2f"'
+				expect( @tag.as_comment_body ).to eq( 'Attr: { template.foo } with format: "%0.2f"' )
 			end
 
 		end
@@ -148,69 +128,69 @@ describe Inversion::Template::AttrTag do
 		context "with a methodchain" do
 
 			before( :each ) do
-				@attribute_object = mock( "template attribute" )
+				@attribute_object = double( "template attribute" )
 			end
 
 			it "renders a single method call with no arguments" do
 				template = Inversion::Template.new( 'this is <?attr foo.bar ?>' )
 				template.foo = @attribute_object
-				@attribute_object.should_receive( :bar ).with( no_args() ).and_return( "the result" )
+				expect( @attribute_object ).to receive( :bar ).with( no_args() ).and_return( "the result" )
 
-				template.render.should == "this is the result"
+				expect( template.render ).to eq( "this is the result" )
 			end
 
 			it "renders a single method call with one argument" do
 				template = Inversion::Template.new( 'this is <?attr foo.bar(8) ?>' )
 				template.foo = @attribute_object
-				@attribute_object.should_receive( :bar ).with( 8 ).and_return( "the result" )
+				expect( @attribute_object ).to receive( :bar ).with( 8 ).and_return( "the result" )
 
-				template.render.should == "this is the result"
+				expect( template.render ).to eq( "this is the result" )
 			end
 
 			it "renders a call with a single index operator" do
 				template = Inversion::Template.new( 'lines end with <?attr config[:line_ending] ?>' )
 				template.config = { :line_ending => 'newline' }
 
-				template.render.should == "lines end with newline"
+				expect( template.render ).to eq( "lines end with newline" )
 			end
 
 			it "renders a single method call with multiple arguments" do
 				template = Inversion::Template.new( 'this is <?attr foo.bar(8, :woo) ?>' )
 				template.foo = @attribute_object
-				@attribute_object.should_receive( :bar ).with( 8, :woo ).and_return( "the result" )
+				expect( @attribute_object ).to receive( :bar ).with( 8, :woo ).and_return( "the result" )
 
-				template.render.should == "this is the result"
+				expect( template.render ).to eq( "this is the result" )
 			end
 
 			it "renders multiple method calls with no arguments" do
-				additional_object = mock( 'additional template attribute' )
+				additional_object = double( 'additional template attribute' )
 				template = Inversion::Template.new( 'this is <?attr foo.bar.baz ?>' )
 				template.foo = @attribute_object
-				template.foo.should_receive( :bar ).and_return( additional_object )
-				additional_object.should_receive( :baz ).with( no_args() ).and_return( "the result" )
+				expect( template.foo ).to receive( :bar ).and_return( additional_object )
+				expect( additional_object ).to receive( :baz ).with( no_args() ).and_return( "the result" )
 
-				template.render.should == "this is the result"
+				expect( template.render ).to eq( "this is the result" )
 			end
 
 			it "renders multiple method calls with arguments" do
-				additional_object = mock( 'additional template attribute' )
+				additional_object = double( 'additional template attribute' )
 				template = Inversion::Template.new( 'this is <?attr foo.bar( 8 ).baz( :woo ) ?>' )
 				template.foo = @attribute_object
-				template.foo.should_receive( :bar ).with( 8 ).and_return( additional_object )
-				additional_object.should_receive( :baz ).with( :woo ).and_return( "the result" )
+				expect( template.foo ).to receive( :bar ).with( 8 ).and_return( additional_object )
+				expect( additional_object ).to receive( :baz ).with( :woo ).and_return( "the result" )
 
-				template.render.should == "this is the result"
+				expect( template.render ).to eq( "this is the result" )
 			end
 
 			it "renders method calls with template attribute arguments" do
 				template = Inversion::Template.new( 'this is <?attr foo.bar( baz ) ?>' )
-				foo = mock( "foo attribute object" )
+				foo = double( "foo attribute object" )
 
 				template.foo = foo
 				template.baz = 18
-				foo.should_receive( :bar ).with( 18 ).and_return( "the result of calling bar" )
+				expect( foo ).to receive( :bar ).with( 18 ).and_return( "the result of calling bar" )
 
-				template.render.should == "this is the result of calling bar"
+				expect( template.render ).to eq( "this is the result of calling bar" )
 			end
 		end
 

data/spec/inversion/template/begintag_spec.rb

@@ -1,18 +1,9 @@
 #!/usr/bin/env rspec -cfd -b
 # vim: set noet nosta sw=4 ts=4 :
 
-BEGIN {
-	require 'pathname'
-	basedir = Pathname( __FILE__ ).dirname.parent.parent.parent
-	libdir = basedir + 'lib'
+require_relative '../../helpers'
 
-	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
-	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
-}
-
-require 'rspec'
 require 'ostruct'
-require 'spec/lib/helpers'
 require 'inversion/template/begintag'
 require 'inversion/template/textnode'
 require 'inversion/template/attrtag'
@@ -22,14 +13,6 @@ require 'inversion/renderstate'
 
 describe Inversion::Template::BeginTag do
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	context "without any rescue clauses" do
 
@@ -42,14 +25,14 @@ describe Inversion::Template::BeginTag do
 		it "renders its subnodes as-is if none of them raise an exception"  do
 			renderstate = Inversion::RenderState.new( :foo => OpenStruct.new(:baz => 'the body') )
 			renderstate << @tag
-			renderstate.to_s.should == 'the body:the stuff after the attr'
+			expect( renderstate.to_s ).to eq( 'the body:the stuff after the attr' )
 		end
 
 		it "uses the configured error behavior of the template if a subnode raises any exception" do
 			renderstate = Inversion::RenderState.new
 			renderstate << @tag
-			renderstate.to_s.should =~ /NoMethodError/
-			renderstate.to_s.should_not =~ /the stuff after the attr/i
+			expect( renderstate.to_s ).to match( /NoMethodError/ )
+			expect( renderstate.to_s ).to_not match( /the stuff after the attr/i )
 		end
 
 	end
@@ -71,13 +54,13 @@ describe Inversion::Template::BeginTag do
 		end
 
 		it "contains one rescue clause for RuntimeErrors" do
-			@tag.rescue_clauses.should == [ [[::RuntimeError], [@rescue_textnode]] ]
+			expect( @tag.rescue_clauses ).to eq([ [[::RuntimeError], [@rescue_textnode]] ])
 		end
 
 		it "renders its subnodes as-is if none of them raise an exception"  do
 			renderstate = Inversion::RenderState.new( :foo => OpenStruct.new(:baz => 'the body') )
 			renderstate << @tag
-			renderstate.to_s.should == 'the body:the stuff after the attr'
+			expect( renderstate.to_s ).to eq( 'the body:the stuff after the attr' )
 		end
 
 		it "renders the rescue section if a subnode raises a RuntimeError"  do
@@ -86,7 +69,7 @@ describe Inversion::Template::BeginTag do
 
 			renderstate = Inversion::RenderState.new( :foo => fooobj )
 			renderstate << @tag
-			renderstate.to_s.should == 'rescue stuff'
+			expect( renderstate.to_s ).to eq( 'rescue stuff' )
 		end
 
 		it "uses the configured error behavior of the template if a subnode raises an " +
@@ -96,9 +79,9 @@ describe Inversion::Template::BeginTag do
 
 			renderstate = Inversion::RenderState.new( :foo => fooobj )
 			renderstate << @tag
-			renderstate.to_s.should =~ /ENOENT/i
-			renderstate.to_s.should_not =~ /rescue stuff/i
-			renderstate.to_s.should_not =~ /the stuff after the attr/i
+			expect( renderstate.to_s ).to match( /ENOENT/i )
+			expect( renderstate.to_s ).to_not match( /rescue stuff/i )
+			expect( renderstate.to_s ).to_not match( /the stuff after the attr/i )
 		end
 	end
 
@@ -120,13 +103,13 @@ describe Inversion::Template::BeginTag do
 		end
 
 		it "contains one rescue clause for the specified exception type" do
-			@tag.rescue_clauses.should == [ [[::SystemCallError], [@rescue_textnode]] ]
+			expect( @tag.rescue_clauses ).to eq( [ [[::SystemCallError], [@rescue_textnode]] ] )
 		end
 
 		it "renders its subnodes as-is if none of them raise an exception"  do
 			renderstate = Inversion::RenderState.new( :foo => OpenStruct.new(:baz => 'the body') )
 			renderstate << @tag
-			renderstate.to_s.should == 'the body:the stuff after the attr'
+			expect( renderstate.to_s ).to eq( 'the body:the stuff after the attr' )
 		end
 
 		it "renders the rescue section if a subnode raises the specified exception type"  do
@@ -135,7 +118,7 @@ describe Inversion::Template::BeginTag do
 
 			renderstate = Inversion::RenderState.new( :foo => fooobj )
 			renderstate << @tag
-			renderstate.to_s.should == 'rescue stuff'
+			expect( renderstate.to_s ).to eq( 'rescue stuff' )
 		end
 
 		it "uses the configured error behavior of the template if a subnode raises an " +
@@ -145,9 +128,9 @@ describe Inversion::Template::BeginTag do
 
 			renderstate = Inversion::RenderState.new( :foo => fooobj )
 			renderstate << @tag
-			renderstate.to_s.should =~ /RuntimeError/i
-			renderstate.to_s.should_not =~ /rescue stuff/i
-			renderstate.to_s.should_not =~ /the stuff after the attr/i
+			expect( renderstate.to_s ).to match( /RuntimeError/i )
+			expect( renderstate.to_s ).to_not match( /rescue stuff/i )
+			expect( renderstate.to_s ).to_not match( /the stuff after the attr/i )
 		end
 	end
 
@@ -170,16 +153,16 @@ describe Inversion::Template::BeginTag do
 		end
 
 		it "contains a rescue tuple for each rescue tag" do
-			@tag.rescue_clauses.should == [
+			expect( @tag.rescue_clauses ).to eq([
 				[[::RuntimeError], [@rescue_textnode]],
 				[[Errno::ENOENT, Errno::EWOULDBLOCK], [@rescue_textnode2]],
-			]
+			])
 		end
 
 		it "renders its subnodes as-is if none of them raise an exception"  do
 			renderstate = Inversion::RenderState.new( :foo => OpenStruct.new(:baz => 'the body') )
 			renderstate << @tag
-			renderstate.to_s.should == 'the body:the stuff after the attr'
+			expect( renderstate.to_s ).to eq( 'the body:the stuff after the attr' )
 		end
 
 		it "renders the first rescue section if a subnode raises the exception it " +
@@ -189,7 +172,7 @@ describe Inversion::Template::BeginTag do
 
 			renderstate = Inversion::RenderState.new( :foo => fooobj )
 			renderstate << @tag
-			renderstate.to_s.should == 'rescue stuff'
+			expect( renderstate.to_s ).to eq( 'rescue stuff' )
 		end
 
 		it "renders the second rescue section if a subnode raises the exception it " +
@@ -199,7 +182,7 @@ describe Inversion::Template::BeginTag do
 
 			renderstate = Inversion::RenderState.new( :foo => fooobj )
 			renderstate << @tag
-			renderstate.to_s.should == 'alternative rescue stuff'
+			expect( renderstate.to_s ).to eq( 'alternative rescue stuff' )
 		end
 
 		it "uses the configured error behavior of the template if a subnode raises an " +
@@ -209,9 +192,9 @@ describe Inversion::Template::BeginTag do
 
 			renderstate = Inversion::RenderState.new( :foo => fooobj )
 			renderstate << @tag
-			renderstate.to_s.should =~ /ENOMEM/i
-			renderstate.to_s.should_not =~ /rescue stuff/i
-			renderstate.to_s.should_not =~ /the stuff after the attr/i
+			expect( renderstate.to_s ).to match( /ENOMEM/i )
+			expect( renderstate.to_s ).to_not match( /rescue stuff/i )
+			expect( renderstate.to_s ).to_not match( /the stuff after the attr/i )
 		end
 	end