inversion 0.12.3 → 0.14.0

data/spec/inversion/template/endtag_spec.rb

@@ -1,17 +1,8 @@
 #!/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/fortag'
 require 'inversion/template/textnode'
 require 'inversion/template/endtag'
@@ -19,22 +10,14 @@ require 'inversion/renderstate'
 
 describe Inversion::Template::EndTag do
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
 	before( :each ) do
 		@tag = Inversion::Template::EndTag.new
 	end
 
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	it "doesn't render as anything" do
 		renderstate = Inversion::RenderState.new
-		@tag.render( renderstate ).should be_nil()
+		expect( @tag.render(renderstate) ).to be_nil()
 	end
 
 	it "can render itself as a comment body that outputs what it closes" do
@@ -42,14 +25,14 @@ describe Inversion::Template::EndTag do
 		template = Inversion::Template.
 			new( "<?for foo in bar ?>Chunkers<?end ?>", :debugging_comments => true )
 		template.bar = [ :an_item ]
-		template.render.should =~ /<!-- End of For: { foo IN template.bar } -->/
+		expect( template.render ).to match( /<!-- End of For: { foo IN template.bar } -->/ )
 	end
 
 	it "closes the parse state's currently-open container node before it's appended" do
 		container = double( "container node", :tagname => 'for', :location => nil )
-		parserstate = mock( "parser state" )
+		parserstate = double( "parser state" )
 
-		parserstate.should_receive( :pop ).and_return( container )
+		expect( parserstate ).to receive( :pop ).and_return( container )
 
 		@tag.before_appending( parserstate )
 	end
@@ -67,7 +50,7 @@ describe Inversion::Template::EndTag do
 
 			expect {
 				@tag.before_appending( state )
-			}.to raise_exception( Inversion::ParseError, /unbalanced/i )
+			}.to raise_error( Inversion::ParseError, /unbalanced/i )
 		end
 
 	end

data/spec/inversion/template/escapetag_spec.rb

@@ -1,59 +1,44 @@
 #!/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/escapetag'
 
 describe Inversion::Template::EscapeTag do
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
-	after( :all ) do
-		reset_logging()
-	end
-
 	before( :each ) do
-		@attribute_object = mock( "template attribute" )
+		@attribute_object = double( "template attribute" )
 	end
 
 
 	it "defaults to escaping as HTML" do
 		template = Inversion::Template.new( 'this is <?escape foo.bar ?>' )
 		template.foo = @attribute_object
-		@attribute_object.should_receive( :bar ).with( no_args() ).
+		expect( @attribute_object ).to receive( :bar ).with( no_args() ).
 			and_return( "<the good, the bad, & the ugly>" )
 
-		template.render.should == "this is &lt;the good, the bad, &amp; the ugly&gt;"
+		expect( template.render ).to eq( "this is &lt;the good, the bad, &amp; the ugly&gt;" )
 	end
 
 	it "raises an Inversion::OptionsError if the config specifies an unsupported format" do
 		template = Inversion::Template.new( 'this is <?escape foo.bar ?>',
 				:escape_format => :clowns, :on_render_error => :propagate )
 		template.foo = @attribute_object
-		@attribute_object.should_receive( :bar ).with( no_args() ).
+		expect( @attribute_object ).to receive( :bar ).with( no_args() ).
 			and_return( "<the good, the bad, & the ugly>" )
 
-		expect { template.render }.to raise_error Inversion::OptionsError, /no such escape format/i
+		expect {
+			template.render
+		}.to raise_error( Inversion::OptionsError, /no such escape format/i )
 	end
 
 	it "escapes as HTML if the format is set to :html" do
 		template = Inversion::Template.new( 'this is <?escape foo.bar ?>', :escape_format => :html )
 		template.foo = @attribute_object
-		@attribute_object.should_receive( :bar ).with( no_args() ).
+		expect( @attribute_object ).to receive( :bar ).with( no_args() ).
 			and_return( "<the good, the bad, & the ugly>" )
 
-		template.render.should == "this is &lt;the good, the bad, &amp; the ugly&gt;"
+		expect( template.render ).to eq( "this is &lt;the good, the bad, &amp; the ugly&gt;" )
 	end
 end

data/spec/inversion/template/fortag_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/fortag'
 require 'inversion/template/attrtag'
 require 'inversion/template/textnode'
@@ -20,25 +11,17 @@ require 'inversion/renderstate'
 
 describe Inversion::Template::ForTag do
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	it "knows which identifiers should be added to the template" do
 		tag = Inversion::Template::ForTag.new( 'foo in bar' )
-		tag.identifiers.should == [ :bar ]
+		expect( tag.identifiers ).to eq( [ :bar ] )
 	end
 
 	it "can iterate over single items of a collection attribute" do
 		tag = Inversion::Template::ForTag.new( 'foo in bar' )
 
-		tag.block_args.should == [ :foo ]
-		tag.enumerator.should == 'bar'
+		expect( tag.block_args ).to eq( [ :foo ] )
+		expect( tag.enumerator ).to eq( 'bar' )
 	end
 
 	it "should render as nothing if the corresponding attribute in the template is unset" do
@@ -52,7 +35,7 @@ describe Inversion::Template::ForTag do
 		tag << Inversion::Template::AttrTag.new( 'foo' )
 		tag << Inversion::Template::TextNode.new( ']' )
 
-		tag.render( render_state ).should be_nil()
+		expect( tag.render( render_state ) ).to be_nil()
 	end
 
 	it "renders each of its subnodes for each iteration, replacing its " +
@@ -68,7 +51,7 @@ describe Inversion::Template::ForTag do
 		tag << Inversion::Template::TextNode.new( ']' )
 
 		tag.render( render_state )
-		render_state.to_s.should == "[monkey][goat]"
+		expect( render_state.to_s ).to eq( "[monkey][goat]" )
 	end
 
 	it "supports nested iterators" do
@@ -88,7 +71,7 @@ describe Inversion::Template::ForTag do
 		outer << inner
 
 		outer.render( render_state )
-		render_state.to_s.should == "[x, o][x, x][o, o][o, x]"
+		expect( render_state.to_s ).to eq( "[x, o][x, x][o, o][o, x]" )
 	end
 
 	it "supports iterating over a range" do
@@ -101,13 +84,13 @@ describe Inversion::Template::ForTag do
 
 		render_state = Inversion::RenderState.new( :rng => 0..10 )
 		tag.render( render_state )
-		render_state.to_s.should == "0 1 2 3 4 5 6 7 8 9 10 "
+		expect( render_state.to_s ).to eq( "0 1 2 3 4 5 6 7 8 9 10 " )
 	end
 
 	it "raises a ParseError if a keyword other than 'in' is used" do
 		expect {
 			Inversion::Template::ForTag.new( 'foo begin bar' )
-		}.to raise_exception( Inversion::ParseError, /invalid/i )
+		}.to raise_error( Inversion::ParseError, /invalid/i )
 	end
 
 	context "multidimensional collections" do
@@ -115,16 +98,16 @@ describe Inversion::Template::ForTag do
 		it "can be expanded into multiple block arguments" do
 			tag = Inversion::Template::ForTag.new( 'splip, splorp in splap' )
 
-			tag.block_args.should == [ :splip, :splorp ]
-			tag.enumerator.should == 'splap'
+			expect( tag.block_args ).to eq( [ :splip, :splorp ] )
+			expect( tag.enumerator ).to eq( 'splap' )
 		end
 
 
 		it "can be expanded into multiple block arguments (sans spaces)" do
 			tag = Inversion::Template::ForTag.new( 'splip,splorp,sploop in splap' )
 
-			tag.block_args.should == [ :splip, :splorp, :sploop ]
-			tag.enumerator.should == 'splap'
+			expect( tag.block_args ).to eq( [ :splip, :splorp, :sploop ] )
+			expect( tag.enumerator ).to eq( 'splap' )
 		end
 
 		it "can be expanded into multiple block arguments from hash pairs" do
@@ -137,13 +120,13 @@ describe Inversion::Template::ForTag do
 			tag << Inversion::Template::AttrTag.new( 'value' )
 			tag << Inversion::Template::TextNode.new( ']' )
 
-			tag.block_args.should == [ :key, :value ]
-			tag.enumerator.should == 'splap'
+			expect( tag.block_args ).to eq( [ :key, :value ] )
+			expect( tag.enumerator ).to eq( 'splap' )
 
 			render_state = Inversion::RenderState.new( :splap => {'one' => 'uno', 'two' => 'dos'} )
 			tag.render( render_state )
 
-			render_state.to_s.should == '[one translates to uno][two translates to dos]'
+			expect( render_state.to_s ).to eq( '[one translates to uno][two translates to dos]' )
 		end
 
 		it "can be expanded into multiple block arguments with complex values" do
@@ -166,8 +149,8 @@ describe Inversion::Template::ForTag do
 			render_state = Inversion::RenderState.new( :method_list => method_list )
 			tree.first.render( render_state )
 
-			render_state.to_s.should =~ /foo \(3\) => foo\s+AKA: foom, foom_detail/
-			render_state.to_s.should =~ /ch \(1\) => ch/
+			expect( render_state.to_s ).to match( /foo \(3\) => foo\s+AKA: foom, foom_detail/ )
+			expect( render_state.to_s ).to match( /ch \(1\) => ch/ )
 		end
 
 		it "preserves an array of subhashes" do
@@ -185,7 +168,7 @@ describe Inversion::Template::ForTag do
 			render_state = Inversion::RenderState.new( :the_hash => the_hash )
 			tree.first.render( render_state )
 
-			render_state.to_s.should =~ /Subhash is a Hash/i
+			expect( render_state.to_s ).to match( /Subhash is a Hash/i )
 		end
 
 	end
@@ -220,7 +203,7 @@ describe Inversion::Template::ForTag do
 			tmpl.frame = frame
 			output = tmpl.render
 
-			output.gsub( /\t+/, '' ).should == (<<-END_OUTPUT).gsub( /\t+/, '' )
+			expect( output.gsub( /\t+/, '' ) ).to eq( (<<-END_OUTPUT).gsub( /\t+/, '' ) )
 			<section class="hexdump">
 				<span class="row">0x00000000:
 				&nbsp;<code>0x89</code>

data/spec/inversion/template/fragmenttag_spec.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env rspec -cfd -b
+# vim: set noet nosta sw=4 ts=4 :
+
+require_relative '../../helpers'
+
+require 'inversion/template/fragmenttag'
+require 'inversion/template/attrtag'
+require 'inversion/template/textnode'
+require 'inversion/renderstate'
+
+describe Inversion::Template::FragmentTag do
+
+	it "raises a parse error if the body isn't a simple attribute" do
+		expect {
+			Inversion::Template::FragmentTag.new( 'something-else' )
+		}.to raise_error( Inversion::ParseError, /malformed key/i )
+	end
+
+
+	it "doesn't render its contents in the template it's declared in" do
+		expect(
+			Inversion::Template.new( "<?fragment foo ?>Fatty BoomBoom<?end ?>" ).render
+		).to eq( '' )
+	end
+
+
+	it "sets the attribute on the template object when rendered" do
+		tmpl = Inversion::Template.new(
+			'<?fragment subject ?>Order #<?attr order_number ?><?end?>-- <?attr subject ?> --'
+		)
+
+		tmpl.order_number = '2121bf8c4'
+		output = tmpl.render
+
+		expect( output ).to eq( "-- Order #2121bf8c4 --" )
+		expect( tmpl.fragments[:subject] ).to eq( "Order #2121bf8c4" )
+	end
+
+end
+

data/spec/inversion/template/iftag_spec.rb

@@ -1,31 +1,14 @@
 #!/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/iftag'
 require 'inversion/template/textnode'
 require 'inversion/renderstate'
 
 describe Inversion::Template::IfTag do
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	it "renders its contents if its attribute is true" do
 		tag = Inversion::Template::IfTag.new( 'attribute' )
@@ -33,7 +16,7 @@ describe Inversion::Template::IfTag do
 
 		renderstate = Inversion::RenderState.new( :attribute => true )
 		tag.render( renderstate )
-		renderstate.to_s.should == 'the body'
+		expect( renderstate.to_s ).to eq( 'the body' )
 	end
 
 
@@ -43,7 +26,7 @@ describe Inversion::Template::IfTag do
 
 		renderstate = Inversion::RenderState.new( :attribute => {:foo => 1} )
 		tag.render( renderstate )
-		renderstate.to_s.should == 'the body'
+		expect( renderstate.to_s ).to eq( 'the body' )
 	end
 
 	it "doesn't render its contents if its attribute is false" do
@@ -52,7 +35,7 @@ describe Inversion::Template::IfTag do
 
 		renderstate = Inversion::RenderState.new( :attribute => nil )
 		tag.render( renderstate )
-		renderstate.to_s.should == ''
+		expect( renderstate.to_s ).to eq( '' )
 	end
 
 	it "doesn't render its contents if its methodchain is false" do
@@ -61,7 +44,7 @@ describe Inversion::Template::IfTag do
 
 		renderstate = Inversion::RenderState.new( :attribute => {:bar => 1} )
 		tag.render( renderstate )
-		renderstate.to_s.should == ''
+		expect( renderstate.to_s ).to eq( '' )
 	end
 
 	it "works inside an iterator (ticket #3)" do
@@ -73,8 +56,8 @@ describe Inversion::Template::IfTag do
 
 		template.items = [ true, false ]
 
-		template.render.should include( "Item: Yep." )
-		template.render.should include( "Item: Nope." )
+		expect( template.render ).to include( "Item: Yep." )
+		expect( template.render ).to include( "Item: Nope." )
 	end
 
 
@@ -91,13 +74,13 @@ describe Inversion::Template::IfTag do
 		it "only renders the first half of the contents if its attribute is true" do
 			renderstate = Inversion::RenderState.new( :attribute => true )
 			@tag.render( renderstate )
-			renderstate.to_s.should == 'the body before else'
+			expect( renderstate.to_s ).to eq( 'the body before else' )
 		end
 
 		it "only renders the second half of the contents if its attribute is true" do
 			renderstate = Inversion::RenderState.new( :attribute => false )
 			@tag.render( renderstate )
-			renderstate.to_s.should == 'the body after else'
+			expect( renderstate.to_s ).to eq( 'the body after else' )
 		end
 
 	end
@@ -116,21 +99,21 @@ describe Inversion::Template::IfTag do
 		it "only renders the first third of the contents if its attribute is true" do
 			renderstate = Inversion::RenderState.new( :attribute => true )
 			@tag.render( renderstate )
-			renderstate.to_s.should == 'the body before elsif'
+			expect( renderstate.to_s ).to eq( 'the body before elsif' )
 		end
 
 		it "only renders the second third of the contents if the attribute is false and the " +
 		   "elsif's attribute is true" do
 			renderstate = Inversion::RenderState.new( :attribute => false, :elsifattribute => true )
 			@tag.render( renderstate )
-			renderstate.to_s.should == 'the body after elsif'
+			expect( renderstate.to_s ).to eq( 'the body after elsif' )
 		end
 
 		it "only renders the last third of the contents if both the attribute and the elsif's " +
 		   "attribute are false" do
 			renderstate = Inversion::RenderState.new( :attribute => false, :elsifattribute => false )
 			@tag.render( renderstate )
-			renderstate.to_s.should == 'the body after else'
+			expect( renderstate.to_s ).to eq( 'the body after else' )
 		end
 
 	end
@@ -148,20 +131,20 @@ describe Inversion::Template::IfTag do
 		it "only renders the first half of the contents if its attribute is true" do
 			renderstate = Inversion::RenderState.new( :attribute => true )
 			@tag.render( renderstate )
-			renderstate.to_s.should == 'the body before elsif'
+			expect( renderstate.to_s ).to eq( 'the body before elsif' )
 		end
 
 		it "only renders the second half of the contents if the attribute is false and the " +
 		   "elsif's attribute is true" do
 			renderstate = Inversion::RenderState.new( :attribute => false, :elsifattribute => true )
 			@tag.render( renderstate )
-			renderstate.to_s.should == 'the body after elsif'
+			expect( renderstate.to_s ).to eq( 'the body after elsif' )
 		end
 
 		it "doesn't render anything if both the attribute and the elsif's attribute are false" do
 			renderstate = Inversion::RenderState.new( :attribute => false, :elsifattribute => false )
 			@tag.render( renderstate )
-			renderstate.to_s.should == ''
+			expect( renderstate.to_s ).to eq( '' )
 		end
 
 	end
@@ -181,27 +164,27 @@ describe Inversion::Template::IfTag do
 		it "only renders the first third of the contents if its attribute is true" do
 			renderstate = Inversion::RenderState.new( :attribute => true )
 			@tag.render( renderstate )
-			renderstate.to_s.should == 'the body before elsif'
+			expect( renderstate.to_s ).to eq( 'the body before elsif' )
 		end
 
 		it "only renders the second third of the contents if the attribute is false and the " +
 		   "first elsif's attribute is true" do
 			renderstate = Inversion::RenderState.new( :elsifattribute => true )
 			@tag.render( renderstate )
-			renderstate.to_s.should == 'the body after elsif1'
+			expect( renderstate.to_s ).to eq( 'the body after elsif1' )
 		end
 
 		it "only renders the last third of the contents if both the attribute and the first elsif's " +
 		   "attribute are false, but the second elsif's attribute is true" do
 			renderstate = Inversion::RenderState.new( :elsifattribute2 => true )
 			@tag.render( renderstate )
-			renderstate.to_s.should == 'the body after elsif2'
+			expect( renderstate.to_s ).to eq( 'the body after elsif2' )
 		end
 
 		it "doesn't render anything if all three attributes are false" do
 			renderstate = Inversion::RenderState.new
 			@tag.render( renderstate )
-			renderstate.to_s.should == ''
+			expect( renderstate.to_s ).to eq( '' )
 		end
 
 	end
@@ -223,27 +206,27 @@ describe Inversion::Template::IfTag do
 		it "only renders the first quarter of the contents if its attribute is true" do
 			renderstate = Inversion::RenderState.new( :attribute => true )
 			@tag.render( renderstate )
-			renderstate.to_s.should == 'the body before elsif'
+			expect( renderstate.to_s ).to eq( 'the body before elsif' )
 		end
 
 		it "only renders the second quarter of the contents if the attribute is false and the " +
 		   "first elsif's attribute is true" do
 			renderstate = Inversion::RenderState.new( :elsifattribute => true )
 			@tag.render( renderstate )
-			renderstate.to_s.should == 'the body after elsif1'
+			expect( renderstate.to_s ).to eq( 'the body after elsif1' )
 		end
 
 		it "only renders the third quarter of the contents if both the attribute and the first elsif's " +
 		   "attribute are false, but the second elsif's attribute is true" do
 			renderstate = Inversion::RenderState.new( :elsifattribute2 => true )
 			@tag.render( renderstate )
-			renderstate.to_s.should == 'the body after elsif2'
+			expect( renderstate.to_s ).to eq( 'the body after elsif2' )
 		end
 
 		it "renders the last quarter of the contents if all three attributes are false" do
 			renderstate = Inversion::RenderState.new
 			@tag.render( renderstate )
-			renderstate.to_s.should == 'the body after else'
+			expect( renderstate.to_s ).to eq( 'the body after else' )
 		end
 
 	end