inversion 0.12.3 → 0.14.0

data/spec/inversion/template/unlesstag_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/unlesstag'
 require 'inversion/template/textnode'
 require 'inversion/renderstate'
 
 describe Inversion::Template::UnlessTag do
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	it "renders its contents if its attribute is false" do
 		tag = Inversion::Template::UnlessTag.new( 'attribute' )
@@ -33,7 +16,7 @@ describe Inversion::Template::UnlessTag do
 
 		renderstate = Inversion::RenderState.new( :attribute => false )
 		tag.render( renderstate )
-		renderstate.to_s.should == 'the body'
+		expect( renderstate.to_s ).to eq( 'the body' )
 	end
 
 	it "renders its contents if its methodchain is false" do
@@ -42,7 +25,7 @@ describe Inversion::Template::UnlessTag do
 
 		renderstate = Inversion::RenderState.new( :attribute => {:bar => 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 true" do
@@ -51,7 +34,7 @@ describe Inversion::Template::UnlessTag do
 
 		renderstate = Inversion::RenderState.new( :attribute => true )
 		tag.render( renderstate )
-		renderstate.to_s.should == ''
+		expect( renderstate.to_s ).to eq( '' )
 	end
 
 	it "doesn't render its contents if its methodchain is true" do
@@ -60,7 +43,7 @@ describe Inversion::Template::UnlessTag do
 
 		renderstate = Inversion::RenderState.new( :attribute => {:foo => 1} )
 		tag.render( renderstate )
-		renderstate.to_s.should == ''
+		expect( renderstate.to_s ).to eq( '' )
 	end
 
 	context "with an 'else' clause" do
@@ -76,13 +59,13 @@ describe Inversion::Template::UnlessTag do
 		it "only renders the second 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 after else'
+			expect( renderstate.to_s ).to eq( 'the body after else' )
 		end
 
 		it "only renders the first half of the contents if its attribute is false" do
 			renderstate = Inversion::RenderState.new( :attribute => false )
 			@tag.render( renderstate )
-			renderstate.to_s.should == 'the body before else'
+			expect( renderstate.to_s ).to eq( 'the body before else' )
 		end
 
 	end

data/spec/inversion/template/uriencodetag_spec.rb

@@ -1,49 +1,32 @@
 #!/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/uriencodetag'
 
 describe Inversion::Template::UriencodeTag 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 "URI encodes the results of rendering" do
 		template = Inversion::Template.new( 'this is<?uriencode 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( " 25% Sparta!" )
 
-		template.render.should == "this is%2025%25%20Sparta%21"
+		expect( template.render ).to eq( "this is%2025%25%20Sparta%21" )
 	end
 
 	it "stringifies its content before encoding" do
 		template = Inversion::Template.new( '<?uriencode foo.bar ?> bottles of beer on the wall' )
 		template.foo = @attribute_object
-		@attribute_object.should_receive( :bar ).with( no_args() ).
+		expect( @attribute_object ).to receive( :bar ).with( no_args() ).
 			and_return( 99.999 )
 
-		template.render.should == "99.999 bottles of beer on the wall"
+		expect( template.render ).to eq( "99.999 bottles of beer on the wall" )
 	end
 end

data/spec/inversion/template/yieldtag_spec.rb

@@ -1,29 +1,12 @@
 #!/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/yieldtag'
 
 describe Inversion::Template::YieldTag do
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	it "calls the renderstate's block before rendering, and renders as its return value" do
 		tag = Inversion::Template::YieldTag.new( '' )
@@ -36,7 +19,7 @@ describe Inversion::Template::YieldTag do
 			renderstate << tag
 		end
 
-		rendered_output.should == [ :return_value ]
+		expect( rendered_output ).to eq([ :return_value ])
 	end
 
 	it "renders as nothing if there wasn't a render block" do
@@ -48,7 +31,7 @@ describe Inversion::Template::YieldTag do
 			renderstate << tag
 		end
 
-		rendered_output.should == [ nil ]
+		expect( rendered_output ).to eq([ nil ])
 	end
 
 end

data/spec/inversion/template_spec.rb

@@ -1,48 +1,42 @@
 #!/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'
+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 'stringio'
 
-require 'spec/lib/helpers'
 require 'inversion/template'
 
 describe Inversion::Template do
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
+	context "created from a simple string" do
 
-	it "can be loaded from a String" do
-		Inversion::Template.new( "a template" ).source.should == 'a template'
-	end
+		let( :template ) { described_class.new("a template") }
 
-	it "renders the source as-is if there are no instructions" do
-		Inversion::Template.new( "a template" ).render.should == 'a template'
-	end
+		it "can be loaded from a String" do
+			expect( template.source ).to eq( 'a template' )
+		end
+
+		it "renders the source as-is if there are no instructions" do
+			expect( template.render ).to eq( 'a template' )
+		end
+
+		it "renders when stringified" do
+			expect( template.to_s ).to eq( 'a template' )
+		end
 
-	it "renders when stringified" do
-		Inversion::Template.new( "a template" ).to_s.should == 'a template'
 	end
 
+
 	it "calls before and after rendering hooks on all of its nodes when rendered" do
 		node = double( "fake node" )
 		parentstate = Inversion::RenderState.new( :foo => 'the merged stuff' )
-		tmpl = Inversion::Template.new( '' )
+		tmpl = described_class.new( '' )
 		tmpl.node_tree << node
 
-		node.should_receive( :before_rendering ).with( an_instance_of(Inversion::RenderState) )
-		node.should_receive( :render ).with( an_instance_of(Inversion::RenderState) )
-		node.should_receive( :after_rendering ).with( an_instance_of(Inversion::RenderState) )
+		expect( node ).to receive( :before_rendering ).with( an_instance_of(Inversion::RenderState) )
+		expect( node ).to receive( :render ).with( an_instance_of(Inversion::RenderState) )
+		expect( node ).to receive( :after_rendering ).with( an_instance_of(Inversion::RenderState) )
 
 		tmpl.render( parentstate )
 	end
@@ -50,12 +44,12 @@ describe Inversion::Template do
 
 	it "passes the block it was rendered with to its RenderState" do
 		node = double( "fake node", :before_rendering => nil, :after_rendering => nil )
-		tmpl = Inversion::Template.new( '' )
+		tmpl = described_class.new( '' )
 		tmpl.node_tree << node
 
 		renderblock = Proc.new {}
-		node.should_receive( :render ).and_return do |renderstate|
-			renderstate.block.should equal( renderblock )
+		expect( node ).to receive( :render ) do |renderstate|
+			expect( renderstate.block ).to equal( renderblock )
 		end
 
 		tmpl.render( &renderblock )
@@ -63,24 +57,40 @@ describe Inversion::Template do
 
 	it "carries its global configuration to the parser" do
 		begin
-			orig_config = Inversion::Template.config
-			Inversion::Template.configure( :ignore_unknown_tags => false )
+			orig_config = described_class.config
+			described_class.configure( :ignore_unknown_tags => false )
 
 			expect {
-				Inversion::Template.new( '<?rumple an unknown tag ?>' )
+				described_class.new( '<?rumple an unknown tag ?>' )
 			}.to raise_error( Inversion::ParseError, /unknown tag/i )
 		ensure
-			Inversion::Template.config = orig_config
+			described_class.config = orig_config
+		end
+	end
+
+	it "carries its global configuration to per-template options" do
+		begin
+			orig_config = described_class.config
+			described_class.configure( :stat_delay => 300 )
+
+			template = described_class.new( 'hi!' )
+			expect( template.options[ :stat_delay ] ).to eq( 300 )
+
+			template = described_class.new( 'hi!', :stat_delay => 600 )
+			expect( template.options[ :stat_delay ] ).to eq( 600 )
+		ensure
+			described_class.config = orig_config
 		end
 	end
 
+
 	it "can make an human-readable string version of itself suitable for debugging" do
-		IO.should_receive( :read ).with( '/tmp/inspect.tmpl' ).and_return( '<?attr foo ?>' )
-		tmpl = Inversion::Template.load( '/tmp/inspect.tmpl' )
-		tmpl.inspect.should =~ /Inversion::Template/
-		tmpl.inspect.should =~ %r{/tmp/inspect.tmpl}
-		tmpl.inspect.should =~ /attributes/
-		tmpl.inspect.should_not =~ /node_tree/
+		expect( IO ).to receive( :read ).with( '/tmp/inspect.tmpl' ).and_return( '<?attr foo ?>' )
+		tmpl = described_class.load( '/tmp/inspect.tmpl' )
+		expect( tmpl.inspect ).to match( /#{Regexp.escape(described_class.name)}/ )
+		expect( tmpl.inspect ).to match( %r{/tmp/inspect.tmpl} )
+		expect( tmpl.inspect ).to match( /attributes/ )
+		expect( tmpl.inspect ).to_not match( /node_tree/ )
 	end
 
 	it "includes the node tree in the inspected object if debugging is enabled" do
@@ -88,25 +98,25 @@ describe Inversion::Template do
 			debuglevel = $DEBUG
 			$DEBUG = true
 
-			tmpl = Inversion::Template.new( '<?attr something ?>' )
-			tmpl.inspect.should =~ /node_tree/
+			tmpl = described_class.new( '<?attr something ?>' )
+			expect( tmpl.inspect ).to match( /node_tree/ )
 		ensure
 			$DEBUG = debuglevel
 		end
 	end
 
 	it "provides accessors for attributes that aren't identifiers in the template" do
-		tmpl = Inversion::Template.new( '' )
+		tmpl = described_class.new( '' )
 		tmpl.foo = :bar
-		tmpl.foo.should == :bar
+		expect( tmpl.foo ).to eq( :bar )
 	end
 
 	it "can pass an encoding option to IO.open through the template constructor" do
 		content = 'some stuff'.encode( 'utf-8' )
-		IO.should_receive( :read ).with( '/a/utf8/template.tmpl', encoding: 'utf-8' ).and_return( content )
-		template = Inversion::Template.load( '/a/utf8/template.tmpl', encoding: 'utf-8' )
+		expect( IO ).to receive( :read ).with( '/a/utf8/template.tmpl', encoding: 'utf-8' ).and_return( content )
+		template = described_class.load( '/a/utf8/template.tmpl', encoding: 'utf-8' )
 
-		template.render.encoding.should == Encoding::UTF_8
+		expect( template.render.encoding ).to eq( Encoding::UTF_8 )
 	end
 
 
@@ -115,30 +125,30 @@ describe Inversion::Template do
 		before( :each ) do
 			@timestamp = Time.now
 			content = 'file contents'.taint
-			IO.stub( :read ).with( '/tmp/hooowat' ).and_return( content )
-			@template = Inversion::Template.load( '/tmp/hooowat' )
+			allow( IO ).to receive( :read ).with( '/tmp/hooowat' ).and_return( content )
+			@template = described_class.load( '/tmp/hooowat' )
 		end
 
 
 		it "untaints template content loaded from a file" do
-			@template.source.should_not be_tainted()
+			expect( @template.source ).to_not be_tainted()
 		end
 
 		it "can be reloaded" do
 			newcontent = 'changed file contents'.taint
-			IO.should_receive( :read ).with( '/tmp/hooowat' ).and_return( newcontent )
+			expect( IO ).to receive( :read ).with( '/tmp/hooowat' ).and_return( newcontent )
 			@template.reload
-			@template.source.should == newcontent
+			expect( @template.source ).to eq( newcontent )
 		end
 
 		context "that hasn't changed since it was loaded" do
 
 			before( :each ) do
-				@template.source_file.stub!( :mtime ).and_return( @timestamp )
+				allow( @template.source_file ).to receive( :mtime ).and_return( @timestamp )
 			end
 
 			it "knows that it hasn't changed" do
-				@template.should_not be_changed()
+				expect( @template ).to_not be_changed()
 			end
 
 			context "with a stat delay" do
@@ -149,13 +159,13 @@ describe Inversion::Template do
 
 				it "returns unchanged if the delay time hasn't expired" do
 					@template.instance_variable_set( :@last_checked, @timestamp )
-					@template.should_not be_changed()
+					expect( @template ).to_not be_changed()
 				end
 
 				it "returns unchanged if the delay time has expired" do
-					@template.source_file.stub!( :mtime ).and_return( @timestamp - 30 )
+					expect( @template.source_file ).to receive( :mtime ).and_return( @timestamp - 30 )
 					@template.instance_variable_set( :@last_checked, @timestamp - 30 )
-					@template.should_not be_changed()
+					expect( @template ).to_not be_changed()
 				end
 			end
 		end
@@ -163,11 +173,11 @@ describe Inversion::Template do
 		context "that has changed since it was loaded" do
 
 			before( :each ) do
-				@template.source_file.stub!( :mtime ).and_return( @timestamp + 1 )
+				allow( @template.source_file ).to receive( :mtime ).and_return( @timestamp + 1 )
 			end
 
 			it "knows that is has changed" do
-				@template.should be_changed()
+				expect( @template ).to be_changed()
 			end
 
 			context "with a stat delay" do
@@ -178,12 +188,12 @@ describe Inversion::Template do
 
 				it "returns unchanged if the delay time hasn't expired" do
 					@template.instance_variable_set( :@last_checked, @timestamp )
-					@template.should_not be_changed()
+					expect( @template ).to_not be_changed()
 				end
 
 				it "returns changed if the delay time has expired" do
 					@template.instance_variable_set( :@last_checked, @timestamp - 60 )
-					@template.should be_changed()
+					expect( @template ).to be_changed()
 				end
 			end
 		end
@@ -193,11 +203,11 @@ describe Inversion::Template do
 	context "loaded from a String" do
 
 		before( :each ) do
-			@template = Inversion::Template.new( 'some stuff' )
+			@template = described_class.new( 'some stuff' )
 		end
 
 		it "never says it has changed" do
-			@template.should_not be_changed()
+			expect( @template ).to_not be_changed()
 		end
 
 		it "raises an exception if reloaded" do
@@ -213,19 +223,19 @@ describe Inversion::Template do
 	context "without template paths set" do
 
 		before( :each ) do
-			Inversion::Template.template_paths.clear
+			described_class.template_paths.clear
 		end
 
 		it "instances can be loaded from an absolute path" do
-			IO.should_receive( :read ).with( '/tmp/hooowat' ).and_return( 'file contents' )
-			Inversion::Template.load( '/tmp/hooowat' ).source.should == 'file contents'
+			expect( IO ).to receive( :read ).with( '/tmp/hooowat' ).and_return( 'file contents' )
+			expect( described_class.load( '/tmp/hooowat' ).source ).to eq( 'file contents' )
 		end
 
 		it "instances can be loaded from a path relative to the current working directory" do
 			tmplpath = Pathname.pwd + 'hooowat.tmpl'
-			FileTest.should_receive( :exist? ).with( tmplpath.to_s ).and_return( true )
-			IO.should_receive( :read ).with( tmplpath.to_s ).and_return( 'file contents' )
-			Inversion::Template.load( 'hooowat.tmpl' ).source.should == 'file contents'
+			expect( FileTest ).to receive( :exist? ).with( tmplpath.to_s ).and_return( true )
+			expect( IO ).to receive( :read ).with( tmplpath.to_s ).and_return( 'file contents' )
+			expect( described_class.load( 'hooowat.tmpl' ).source ).to eq( 'file contents' )
 		end
 	end
 
@@ -233,93 +243,93 @@ describe Inversion::Template do
 	context "with template paths set" do
 
 		before( :each ) do
-			Inversion::Template.template_paths = [ '/tmp', '/fun' ]
+			described_class.template_paths = [ '/tmp', '/fun' ]
 		end
 
 		after( :each ) do
-			Inversion::Template.template_paths.clear
+			described_class.template_paths.clear
 		end
 
 		it "instances can be loaded from an absolute path" do
-			FileTest.should_not_receive( :exist? )
+			expect( FileTest ).to_not receive( :exist? )
 
-			IO.should_receive( :read ).with( '/tmp/hooowat' ).and_return( 'file contents' )
-			Inversion::Template.load( '/tmp/hooowat' ).source.should == 'file contents'
+			expect( IO ).to receive( :read ).with( '/tmp/hooowat' ).and_return( 'file contents' )
+			expect( described_class.load( '/tmp/hooowat' ).source ).to eq( 'file contents' )
 		end
 
 		it "raises a runtime exception if unable to locate the template" do
 			tmplpath = Pathname.pwd + 'sadmanhose.tmpl'
 
-			FileTest.should_receive( :exist? ).with( '/tmp/sadmanhose.tmpl' ).and_return( false )
-			FileTest.should_receive( :exist? ).with( '/fun/sadmanhose.tmpl' ).and_return( false )
-			FileTest.should_receive( :exist? ).with( tmplpath.to_s ).and_return( false )
+			expect( FileTest ).to receive( :exist? ).with( '/tmp/sadmanhose.tmpl' ).and_return( false )
+			expect( FileTest ).to receive( :exist? ).with( '/fun/sadmanhose.tmpl' ).and_return( false )
+			expect( FileTest ).to receive( :exist? ).with( tmplpath.to_s ).and_return( false )
 
 			expect {
-				Inversion::Template.load( 'sadmanhose.tmpl' )
+				described_class.load( 'sadmanhose.tmpl' )
 			}.to raise_error( RuntimeError, /unable to find template ".+" within configured paths/i )
 		end
 
 		it "loads template relative to directories in the template_paths" do
-			FileTest.should_receive( :exist? ).with( '/tmp/hooowat.tmpl' ).and_return( false )
-			FileTest.should_receive( :exist? ).with( '/fun/hooowat.tmpl' ).and_return( true )
-			IO.should_receive( :read ).with( '/fun/hooowat.tmpl' ).and_return( 'file contents' )
+			expect( FileTest ).to receive( :exist? ).with( '/tmp/hooowat.tmpl' ).and_return( false )
+			expect( FileTest ).to receive( :exist? ).with( '/fun/hooowat.tmpl' ).and_return( true )
+			expect( IO ).to receive( :read ).with( '/fun/hooowat.tmpl' ).and_return( 'file contents' )
 
-			Inversion::Template.load( 'hooowat.tmpl' ).source.should == 'file contents'
+			expect( described_class.load( 'hooowat.tmpl' ).source ).to eq( 'file contents' )
 		end
 
 		it "falls back to loading the template relative to the current working directory" do
 			tmplpath = Pathname.pwd + 'hooowat.tmpl'
 
-			FileTest.should_receive( :exist? ).with( '/tmp/hooowat.tmpl' ).and_return( false )
-			FileTest.should_receive( :exist? ).with( '/fun/hooowat.tmpl' ).and_return( false )
-			FileTest.should_receive( :exist? ).with( tmplpath.to_s ).and_return( true )
-			IO.should_receive( :read ).with( tmplpath.to_s ).and_return( 'file contents' )
+			expect( FileTest ).to receive( :exist? ).with( '/tmp/hooowat.tmpl' ).and_return( false )
+			expect( FileTest ).to receive( :exist? ).with( '/fun/hooowat.tmpl' ).and_return( false )
+			expect( FileTest ).to receive( :exist? ).with( tmplpath.to_s ).and_return( true )
+			expect( IO ).to receive( :read ).with( tmplpath.to_s ).and_return( 'file contents' )
 
-			Inversion::Template.load( 'hooowat.tmpl' ).source.should == 'file contents'
+			expect( described_class.load( 'hooowat.tmpl' ).source ).to eq( 'file contents' )
 		end
 	end
 
 
 	context "with an attribute PI" do
 
-		let( :template ) { Inversion::Template.new("<h1><?attr foo ?></h1>") }
+		let( :template ) { described_class.new("<h1><?attr foo ?></h1>") }
 
 
 		it "has a reader for getting the attribute's value" do
-			template.should respond_to( :foo )
+			expect( template ).to respond_to( :foo )
 		end
 
 		it "has an accessor for setting the attribute's value" do
-			template.should respond_to( :foo= )
+			expect( template ).to respond_to( :foo= )
 		end
 
 		it "renders scalar values set for the attribute" do
 			template.foo = "a lion"
-			template.render.should == "<h1>a lion</h1>"
+			expect( template.render ).to eq( "<h1>a lion</h1>" )
 		end
 
 		it "renders an non-String value set for the attribute using #to_s" do
 			template.foo = [ 'a lion', 'a little guy', 'a bad mousie', 'one birdy' ]
-			template.render.should == %{<h1>a liona little guya bad mousieone birdy</h1>}
+			expect( template.render ).to eq( %{<h1>a liona little guya bad mousieone birdy</h1>} )
 		end
 	end
 
 
 	context "with several attribute PIs" do
 
-		let( :template ) { Inversion::Template.new("<h1><?attr foo ?> <?attr foo?> RUN!</h1>") }
+		let( :template ) { described_class.new("<h1><?attr foo ?> <?attr foo?> RUN!</h1>") }
 
 		it "has a reader for getting the attribute's value" do
-			template.should respond_to( :foo )
+			expect( template ).to respond_to( :foo )
 		end
 
 		it "has an accessor for setting the attribute's value" do
-			template.should respond_to( :foo= )
+			expect( template ).to respond_to( :foo= )
 		end
 
 		it "renders scalar values set for the attribute(s)" do
 			template.foo = "lions!!"
-			template.render.should == "<h1>lions!! lions!! RUN!</h1>"
+			expect( template.render ).to eq( "<h1>lions!! lions!! RUN!</h1>" )
 		end
 	end
 
@@ -327,11 +337,11 @@ describe Inversion::Template do
 	describe "Configurability support", :if => defined?( Configurability ) do
 
 		after( :each ) do
-			Inversion::Template.config = Inversion::Template::DEFAULT_CONFIG
+			described_class.config = described_class::DEFAULT_CONFIG
 		end
 
 		it "is included in the list of configurable objects" do
-			Configurability.configurable_objects.should include( Inversion::Template )
+			expect( Configurability.configurable_objects ).to include( described_class )
 		end
 
 		it "can be configured using a Configurability::Config object" do
@@ -344,12 +354,12 @@ describe Inversion::Template do
 			  comment_end: ""
 			}.gsub(/^\t{3}/, '') )
 
-			Inversion::Template.configure( config.templates )
+			described_class.configure( config.templates )
 
-			Inversion::Template.config[:ignore_unknown_tags].should be_false()
-			Inversion::Template.config[:debugging_comments].should be_true()
-			Inversion::Template.config[:comment_start].should == '#'
-			Inversion::Template.config[:comment_end].should == ''
+			expect( described_class.config[:ignore_unknown_tags] ).to be_false()
+			expect( described_class.config[:debugging_comments] ).to be_true()
+			expect( described_class.config[:comment_start] ).to eq( '#' )
+			expect( described_class.config[:comment_end] ).to eq( '' )
 
 		end
 
@@ -359,11 +369,11 @@ describe Inversion::Template do
 	describe "exception-handling:" do
 
 		before( :each ) do
-			@source = "Some stuff\n<?call obj.raise_exception ?>\nMore stuff"
-			@tmpl = Inversion::Template.new( @source )
+			@source = "Some stuff\n<?call obj.raise_error ?>\nMore stuff"
+			@tmpl = described_class.new( @source )
 
 			@obj = Object.new
-			def @obj.raise_exception
+			def @obj.raise_error
 				raise "Okay, here's an exception!"
 			end
 
@@ -372,24 +382,61 @@ describe Inversion::Template do
 
 		it "can be configured to completely ignore exceptions raised while rendering" do
 			@tmpl.options[:on_render_error] = :ignore
-			@tmpl.render.should == "Some stuff\nMore stuff"
+			expect( @tmpl.render ).to eq( "Some stuff\nMore stuff" )
 		end
 
 		it "can be configured to insert debugging comments for exceptions raised while rendering" do
 			@tmpl.options[:on_render_error] = :comment
-			@tmpl.render.should ==
-				"Some stuff\n<!-- RuntimeError: Okay, here's an exception! -->More stuff"
+			expect(
+				@tmpl.render
+			).to eq( "Some stuff\n<!-- RuntimeError: Okay, here's an exception! -->More stuff" )
 		end
 
 		it "can be configured to propagate exceptions raised while rendering" do
 			@tmpl.options[:on_render_error] = :propagate
 			expect {
 				@tmpl.render
-			}.to raise_exception( RuntimeError, /Okay, here's an exception!/ )
+			}.to raise_error( RuntimeError, /Okay, here's an exception!/ )
 		end
 
 	end
 
 
+	describe "with fragment tags" do
+
+		before( :each ) do
+			@template = Inversion::Template.new <<-TMPL
+			<?default bool to 'yes' ?>
+			<?fragment pork ?>wooo<?end ?>
+			<?fragment beef ?><?attr bool ?> please<?end ?>
+			<?attr beef ?>
+			TMPL
+		end
+
+		it "doesn't have any fragments before it's been rendered" do
+			expect( @template.fragments ).to be_empty
+		end
+
+		it "has a fragment for each tag after it's been rendered" do
+			@template.render
+
+			expect( @template.fragments ).to be_a( Hash )
+			expect( @template.fragments ).to include( :pork, :beef )
+			expect( @template.fragments.size ).to eq( 2 )
+			expect( @template.fragments[:pork] ).to eq( 'wooo' )
+			expect( @template.fragments[:beef] ).to eq( 'yes please' )
+		end
+
+		it "clears previous fragments when rendered a second time" do
+			@template.render
+			expect( @template.fragments[:beef] ).to eq( 'yes please' )
+
+			@template.bool = 'no'
+			@template.render
+			expect( @template.fragments[:beef] ).to eq( 'no please' )
+		end
+
+	end
+
 end