inversion 0.12.3 → 0.14.0

data/spec/inversion/mixins_spec.rb

@@ -1,17 +1,7 @@
 #!/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'
 
 require 'inversion/mixins'
 
@@ -30,15 +20,15 @@ describe Inversion, "mixins" do
 
 			result = Inversion::HashUtilities.stringify_keys( testhash )
 
-			result.should be_an_instance_of( Hash )
-			result.should_not be_equal( testhash )
-			result.should == {
+			expect( result ).to be_an_instance_of( Hash )
+			expect( result ).to_not be_equal( testhash )
+			expect( result ).to eq({
 				'foo' => 1,
 				'bar' => {
 					'klang' => 'klong',
 					'barang' => { 'kerklang' => 'dumdumdum' },
 				}
-			}
+			})
 		end
 
 
@@ -53,15 +43,15 @@ describe Inversion, "mixins" do
 
 			result = Inversion::HashUtilities.symbolify_keys( testhash )
 
-			result.should be_an_instance_of( Hash )
-			result.should_not be_equal( testhash )
-			result.should == {
+			expect( result ).to be_an_instance_of( Hash )
+			expect( result ).to_not be_equal( testhash )
+			expect( result ).to eq({
 				:foo => 1,
 				:bar => {
 					:klang => 'klong',
 					:barang => { :kerklang => 'dumdumdum' },
 				}
-			}
+			})
 		end
 
 	end
@@ -125,17 +115,17 @@ describe Inversion, "mixins" do
 
 		it "adds configurable escaping to including classes" do
 			render_state = Inversion::RenderState.new( {}, :escape_format => :html )
-			@obj.render( render_state ).should == "<something>"
+			expect( @obj.render( render_state ) ).to eq( "<something>" )
 		end
 
 		it "doesn't escape anything if escaping is disabled" do
 			render_state = Inversion::RenderState.new( {}, :escape_format => nil )
-			@obj.render( render_state ).should == "<something>"
+			expect( @obj.render( render_state ) ).to eq( "<something>" )
 		end
 
 		it "doesn't escape anything if escaping is set to ':none'" do
 			render_state = Inversion::RenderState.new( {}, :escape_format => :none )
-			@obj.render( render_state ).should == "<something>"
+			expect( @obj.render( render_state ) ).to eq( "<something>" )
 		end
 	end
 
@@ -143,26 +133,26 @@ describe Inversion, "mixins" do
 	describe Inversion::DataUtilities do
 
 		it "doesn't try to dup immediate objects" do
-			Inversion::DataUtilities.deep_copy( nil ).should be( nil )
-			Inversion::DataUtilities.deep_copy( 112 ).should be( 112 )
-			Inversion::DataUtilities.deep_copy( true ).should be( true )
-			Inversion::DataUtilities.deep_copy( false ).should be( false )
-			Inversion::DataUtilities.deep_copy( :a_symbol ).should be( :a_symbol )
+			expect( Inversion::DataUtilities.deep_copy( nil ) ).to be( nil )
+			expect( Inversion::DataUtilities.deep_copy( 112 ) ).to be( 112 )
+			expect( Inversion::DataUtilities.deep_copy( true ) ).to be( true )
+			expect( Inversion::DataUtilities.deep_copy( false ) ).to be( false )
+			expect( Inversion::DataUtilities.deep_copy( :a_symbol ) ).to be( :a_symbol )
 		end
 
 		it "doesn't try to dup modules/classes" do
 			klass = Class.new
-			Inversion::DataUtilities.deep_copy( klass ).should be( klass )
+			expect( Inversion::DataUtilities.deep_copy( klass ) ).to be( klass )
 		end
 
 		it "doesn't try to dup IOs" do
 			data = [ $stdin ]
-			Inversion::DataUtilities.deep_copy( data[0] ).should be( $stdin )
+			expect( Inversion::DataUtilities.deep_copy( data[0] ) ).to be( $stdin )
 		end
 
 		it "doesn't try to dup Tempfiles" do
 			data = Tempfile.new( 'inversion_deepcopy.XXXXX' )
-			Inversion::DataUtilities.deep_copy( data ).should be( data )
+			expect( Inversion::DataUtilities.deep_copy( data ) ).to be( data )
 		end
 
 		it "makes distinct copies of arrays and their members" do
@@ -170,14 +160,14 @@ describe Inversion, "mixins" do
 
 			copy = Inversion::DataUtilities.deep_copy( original )
 
-			copy.should == original
-			copy.should_not be( original )
-			copy[0].should == original[0]
-			copy[0].should_not be( original[0] )
-			copy[1].should == original[1]
-			copy[1].should_not be( original[1] )
-			copy[2].should == original[2]
-			copy[2].should be( original[2] ) # Immediate
+			expect( copy ).to eq( original )
+			expect( copy ).to_not be( original )
+			expect( copy[0] ).to eq( original[0] )
+			expect( copy[0] ).to_not be( original[0] )
+			expect( copy[1] ).to eq( original[1] )
+			expect( copy[1] ).to_not be( original[1] )
+			expect( copy[2] ).to eq( original[2] )
+			expect( copy[2] ).to be( original[2] ) # Immediate
 		end
 
 		it "makes recursive copies of deeply-nested Arrays" do
@@ -185,12 +175,12 @@ describe Inversion, "mixins" do
 
 			copy = Inversion::DataUtilities.deep_copy( original )
 
-			copy.should == original
-			copy.should_not be( original )
-			copy[1].should_not be( original[1] )
-			copy[1][2].should_not be( original[1][2] )
-			copy[3].should_not be( original[3] )
-			copy[3][1].should_not be( original[3][1] )
+			expect( copy ).to eq( original )
+			expect( copy ).to_not be( original )
+			expect( copy[1] ).to_not be( original[1] )
+			expect( copy[1][2] ).to_not be( original[1][2] )
+			expect( copy[3] ).to_not be( original[3] )
+			expect( copy[3][1] ).to_not be( original[3][1] )
 		end
 
 		it "makes distinct copies of Hashes and their members" do
@@ -202,13 +192,13 @@ describe Inversion, "mixins" do
 
 			copy = Inversion::DataUtilities.deep_copy( original )
 
-			copy.should == original
-			copy.should_not be( original )
-			copy[:a].should == 1
-			copy.key( 2 ).should == 'b'
-			copy.key( 2 ).should_not be( original.key(2) )
-			copy[3].should == 'c'
-			copy[3].should_not be( original[3] )
+			expect( copy ).to eq( original )
+			expect( copy ).to_not be( original )
+			expect( copy[:a] ).to eq( 1 )
+			expect( copy.key( 2 ) ).to eq( 'b' )
+			expect( copy.key( 2 ) ).to_not be( original.key(2) )
+			expect( copy[3] ).to eq( 'c' )
+			expect( copy[3] ).to_not be( original[3] )
 		end
 
 		it "makes distinct copies of deeply-nested Hashes" do
@@ -225,15 +215,15 @@ describe Inversion, "mixins" do
 
 			copy = Inversion::DataUtilities.deep_copy( original )
 
-			copy.should == original
-			copy[:a][:b][:c].should == 'd'
-			copy[:a][:b][:c].should_not be( original[:a][:b][:c] )
-			copy[:a][:b][:e].should == 'f'
-			copy[:a][:b][:e].should_not be( original[:a][:b][:e] )
-			copy[:a][:g].should == 'h'
-			copy[:a][:g].should_not be( original[:a][:g] )
-			copy[:i].should == 'j'
-			copy[:i].should_not be( original[:i] )
+			expect( copy ).to eq( original )
+			expect( copy[:a][:b][:c] ).to eq( 'd' )
+			expect( copy[:a][:b][:c] ).to_not be( original[:a][:b][:c] )
+			expect( copy[:a][:b][:e] ).to eq( 'f' )
+			expect( copy[:a][:b][:e] ).to_not be( original[:a][:b][:e] )
+			expect( copy[:a][:g] ).to eq( 'h' )
+			expect( copy[:a][:g] ).to_not be( original[:a][:g] )
+			expect( copy[:i] ).to eq( 'j' )
+			expect( copy[:i] ).to_not be( original[:i] )
 		end
 
 		it "copies the default proc of copied Hashes" do
@@ -241,7 +231,7 @@ describe Inversion, "mixins" do
 
 			copy = Inversion::DataUtilities.deep_copy( original )
 
-			copy.default_proc.should == original.default_proc
+			expect( copy.default_proc ).to eq( original.default_proc )
 		end
 
 		it "preserves taintedness of copied objects" do
@@ -250,8 +240,8 @@ describe Inversion, "mixins" do
 
 			copy = Inversion::DataUtilities.deep_copy( original )
 
-			copy.should_not be( original )
-			copy.should be_tainted()
+			expect( copy ).to_not be( original )
+			expect( copy ).to be_tainted()
 		end
 
 		it "preserves frozen-ness of copied objects" do
@@ -260,8 +250,8 @@ describe Inversion, "mixins" do
 
 			copy = Inversion::DataUtilities.deep_copy( original )
 
-			copy.should_not be( original )
-			copy.should be_frozen()
+			expect( copy ).to_not be( original )
+			expect( copy ).to be_frozen()
 		end
 	end
 end

data/spec/inversion/monkeypatches_spec.rb

@@ -1,20 +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_relative '../helpers'
 
 require 'ripper'
-
-require 'rspec'
-require 'spec/lib/helpers'
-
 require 'inversion/monkeypatches'
 
 
@@ -25,7 +15,7 @@ describe Inversion, "monkeypatches" do
 		it "exposes the Ripper::TokenPattern::MatchData's #tokens array" do
 			tagpattern = Ripper::TokenPattern.compile( '$(ident) $(sp) $(ident)' )
 			matchdata = tagpattern.match( "foo bar" )
-			matchdata.tokens.map {|tok| tok[1] }.should == [ :on_ident, :on_sp, :on_ident ]
+			expect( matchdata.tokens.map {|tok| tok[1]} ).to eq([ :on_ident, :on_sp, :on_ident ])
 		end
 
 	end

data/spec/inversion/parser_spec.rb

@@ -1,23 +1,13 @@
 #!/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 'spec/lib/helpers'
 require 'inversion/parser'
 
 describe Inversion::Parser do
 
 	before( :all ) do
-		setup_logging( :fatal )
 		Inversion::Template::Tag.load_all
 	end
 
@@ -28,14 +18,14 @@ describe Inversion::Parser do
 	it "parses a string with no PIs as a single text node" do
 		result = Inversion::Parser.new( @template ).parse( "render unto Caesar" )
 
-		result.should have( 1 ).member
-		result.first.should be_a( Inversion::Template::TextNode )
-		result.first.body.should == 'render unto Caesar'
+		expect( result.size ).to eq( 1 )
+		expect( result.first ).to be_a( Inversion::Template::TextNode )
+		expect( result.first.body ).to eq( 'render unto Caesar' )
 	end
 
 	it "parses an empty string as a empty tree" do
 		result = Inversion::Parser.new( @template ).parse( "" )
-		result.should be_empty
+		expect( result ).to be_empty
 	end
 
 	it "raises a ParseError on mismatched tag brackets" do
@@ -47,47 +37,47 @@ describe Inversion::Parser do
 	it "parses a string with a single 'attr' tag as a single AttrTag node" do
 		result = Inversion::Parser.new( @template ).parse( "<?attr foo ?>" )
 
-		result.should have( 1 ).member
-		result.first.should be_a( Inversion::Template::AttrTag )
-		result.first.body.should == 'foo'
+		expect( result.size ).to eq( 1 )
+		expect( result.first ).to be_a( Inversion::Template::AttrTag )
+		expect( result.first.body ).to eq( 'foo' )
 	end
 
 	it "parses a single 'attr' tag surrounded by plain text" do
 		result = Inversion::Parser.new( @template ).parse( "beginning<?attr foo ?>end" )
 
-		result.should have( 3 ).members
-		result[0].should be_a( Inversion::Template::TextNode )
-		result[1].should be_a( Inversion::Template::AttrTag )
-		result[1].body.should == 'foo'
-		result[2].should be_a( Inversion::Template::TextNode )
+		expect( result.size ).to eq( 3 )
+		expect( result[0] ).to be_a( Inversion::Template::TextNode )
+		expect( result[1] ).to be_a( Inversion::Template::AttrTag )
+		expect( result[1].body ).to eq( 'foo' )
+		expect( result[2] ).to be_a( Inversion::Template::TextNode )
 	end
 
 	it "ignores unknown tags by default" do
 		result = Inversion::Parser.new( @template ).parse( "Text <?hoooowhat ?>" )
 
-		result.should have( 2 ).members
-		result[0].should be_a( Inversion::Template::TextNode )
-		result[1].should be_a( Inversion::Template::TextNode )
-		result[1].body.should == '<?hoooowhat ?>'
+		expect( result.size ).to eq( 2 )
+		expect( result[0] ).to be_a( Inversion::Template::TextNode )
+		expect( result[1] ).to be_a( Inversion::Template::TextNode )
+		expect( result[1].body ).to eq( '<?hoooowhat ?>' )
 	end
 
 	it "can raise exceptions on unknown tags" do
 		expect {
 			Inversion::Parser.new( @template, :ignore_unknown_tags => false ).
 				parse( "Text <?hoooowhat ?>" )
-		}.to raise_exception( Inversion::ParseError, /unknown tag/i )
+		}.to raise_error( Inversion::ParseError, /unknown tag/i )
 	end
 
 	it "can raise exceptions on unclosed (nested) tags" do
 		expect {
 			Inversion::Parser.new( @template ).parse( "Text <?attr something <?attr something_else ?>" )
-		}.to raise_exception( Inversion::ParseError, /unclosed or nested tag/i )
+		}.to raise_error( Inversion::ParseError, /unclosed or nested tag/i )
 	end
 
 	it "can raise exceptions on unclosed (eof) tags" do
 		expect {
 			Inversion::Parser.new( @template ).parse( "Text <?hoooowhat" )
-		}.to raise_exception( Inversion::ParseError, /unclosed tag/i )
+		}.to raise_error( Inversion::ParseError, /unclosed tag/i )
 	end
 
 
@@ -103,41 +93,41 @@ describe Inversion::Parser do
 
 			@state << open_tag << end_tag
 
-			@state.tree.should == [ open_tag, end_tag ]
+			expect( @state.tree ).to eq( [ open_tag, end_tag ] )
 		end
 
 		it "knows it is well-formed if there are no open tags" do
 			@state << Inversion::Template::ForTag.new( 'foo in bar' )
-			@state.should_not be_well_formed
+			expect( @state ).to_not be_well_formed
 
 			@state << Inversion::Template::ForTag.new( 'foo in bar' )
-			@state.should_not be_well_formed
+			expect( @state ).to_not be_well_formed
 
 			@state << Inversion::Template::EndTag.new( 'for' )
-			@state.should_not be_well_formed
+			expect( @state ).to_not be_well_formed
 
 			@state << Inversion::Template::EndTag.new( 'for' )
-			@state.should be_well_formed
+			expect( @state ).to be_well_formed
 		end
 
 		it "can pop a container tag off of the current context" do
 			container = Inversion::Template::ForTag.new( 'foo in bar' )
 			@state << container
-			@state.pop.should == container
+			expect( @state.pop ).to eq( container )
 		end
 
 		it "calls the #after_appending hook of container nodes when they're popped" do
-			container = mock( "container tag", :before_appending => false, :is_container? => true )
+			container = double( "container tag", :before_appending => false, :is_container? => true )
 			@state << container
 
-			container.should_receive( :after_appending ).with( @state )
+			expect( container ).to receive( :after_appending ).with( @state )
 			@state.pop
 		end
 
 		it "raises an error when popping if there is no container tag" do
 			expect {
 				@state.pop
-			}.to raise_exception( Inversion::ParseError, /unbalanced end: no open tag/i )
+			}.to raise_error( Inversion::ParseError, /unbalanced end: no open tag/i )
 		end
 
 		it "raises an error when the tree is fetched if it isn't well-formed" do
@@ -146,19 +136,19 @@ describe Inversion::Parser do
 
 			expect {
 				@state.tree
-			}.to raise_exception( Inversion::ParseError, /unclosed/i )
+			}.to raise_error( Inversion::ParseError, /unclosed/i )
 		end
 
 		it "calls the #before_appending callback on nodes that are appended to it" do
-			node = mock( "node", :is_container? => false, :after_appending => nil )
-			node.should_receive( :before_appending ).with( @state )
+			node = double( "node", :is_container? => false, :after_appending => nil )
+			expect( node ).to receive( :before_appending ).with( @state )
 
 			@state << node
 		end
 
 		it "calls the #after_appending callback on nodes that are appended to it" do
-			node = mock( "node", :is_container? => false, :before_appending => nil )
-			node.should_receive( :after_appending ).with( @state )
+			node = double( "node", :is_container? => false, :before_appending => nil )
+			expect( node ).to receive( :after_appending ).with( @state )
 
 			@state << node
 		end

data/spec/inversion/renderstate_spec.rb

@@ -2,43 +2,28 @@
 # encoding: utf-8
 # 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 'spec/lib/helpers'
 require 'inversion/renderstate'
 require 'inversion/template/attrtag'
 require 'inversion/template/textnode'
+require 'inversion/template/fragmenttag'
+require 'inversion/template/subscribetag'
+require 'inversion/template/publishtag'
 
 describe Inversion::RenderState do
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	it "provides access to the block it was constructed with if there was one" do
 		block = Proc.new {}
 		state = Inversion::RenderState.new( &block )
-		state.block.should equal( block )
+		expect( state.block ).to equal( block )
 	end
 
 	it "can evaluate code in the context of itself" do
 		attributes = { :foot => "in mouth", :bear => "in woods" }
 		state = Inversion::RenderState.new( attributes )
-		state.eval( "foot" ).should == 'in mouth'
+		expect( state.eval( "foot" ) ).to eq( 'in mouth' )
 	end
 
 
@@ -49,11 +34,11 @@ describe Inversion::RenderState do
 
 			state = Inversion::RenderState.new( attributes )
 
-			state.scope.__locals__.should_not equal( attributes )
-			state.scope[:foot].should == "in mouth"
-			state.scope[:foot].should_not equal( attributes[:foot] )
-			state.scope[:bear].should == "in woods"
-			state.scope[:bear].should_not equal( attributes[:bear] )
+			expect( state.scope.__locals__ ).to_not equal( attributes )
+			expect( state.scope[:foot] ).to eq( "in mouth" )
+			expect( state.scope[:foot] ).to_not equal( attributes[:foot] )
+			expect( state.scope[:bear] ).to eq( "in woods" )
+			expect( state.scope[:bear] ).to_not equal( attributes[:bear] )
 		end
 
 		it "preserves tainted status when copying its attributes" do
@@ -62,7 +47,7 @@ describe Inversion::RenderState do
 
 			state = Inversion::RenderState.new( attributes )
 
-			state.scope[:danger].should be_tainted()
+			expect( state.scope[:danger] ).to be_tainted()
 		end
 
 		it "preserves singleton methods on attribute objects when copying" do
@@ -71,7 +56,7 @@ describe Inversion::RenderState do
 
 			state = Inversion::RenderState.new( :foo => obj )
 
-			state.scope[:foo].singleton_methods.map( &:to_sym ).should include( :foo )
+			expect( state.scope[:foo].singleton_methods.map( &:to_sym ) ).to include( :foo )
 		end
 
 		it "preserves frozen status when copying its attributes" do
@@ -80,7 +65,7 @@ describe Inversion::RenderState do
 
 			state = Inversion::RenderState.new( attributes )
 
-			state.scope[:danger].should be_frozen()
+			expect( state.scope[:danger] ).to be_frozen()
 		end
 
 		it "can override its attributes for the duration of a block" do
@@ -89,11 +74,11 @@ describe Inversion::RenderState do
 			state = Inversion::RenderState.new( attributes )
 
 			state.with_attributes( :foot => 'ball' ) do
-				state.foot.should == 'ball'
-				state.bear.should == 'in woods'
+				expect( state.foot ).to eq( 'ball' )
+				expect( state.bear ).to eq( 'in woods' )
 			end
 
-			state.scope[:foot].should == 'in mouth'
+			expect( state.scope[:foot] ).to eq( 'in mouth' )
 		end
 
 
@@ -108,7 +93,7 @@ describe Inversion::RenderState do
 				end
 			}.to raise_error()
 
-			state.scope[:foot].should == 'in mouth'
+			expect( state.scope[:foot] ).to eq( 'in mouth' )
 		end
 
 
@@ -122,12 +107,12 @@ describe Inversion::RenderState do
 
 			it "provides accessor methods for its attributes" do
 				state = Inversion::RenderState.new( :bar => :the_attribute_value )
-				state.scope.bar.should == :the_attribute_value
+				expect( state.scope.bar ).to eq( :the_attribute_value )
 			end
 
 			it "doesn't error if an accessor for a non-existant attribute is called" do
 				state = Inversion::RenderState.new( :bar => :the_attribute_value )
-				state.scope.foo.should be_nil()
+				expect( state.scope.foo ).to be_nil()
 			end
 
 		end
@@ -142,11 +127,11 @@ describe Inversion::RenderState do
 
 			thirdstate = state.merge( anotherstate )
 
-			thirdstate.attributes.should == {
+			expect( thirdstate.attributes ).to eq({
 				:bar => :the_bar_value,
 				:foo => :the_foo_value
-			}
-			thirdstate.options.should include(
+			})
+			expect( thirdstate.options ).to include(
 				:debugging_comments => true,
 				:on_render_error => :propagate
 			)
@@ -162,7 +147,7 @@ describe Inversion::RenderState do
 		end
 
 		it "provides a mechanism for storing tag state for the current render" do
-			@renderstate.tag_data.should be_a( Hash )
+			expect( @renderstate.tag_data ).to be_a( Hash )
 		end
 
 		it "can override tag state for the duration of a block" do
@@ -170,14 +155,14 @@ describe Inversion::RenderState do
 			@renderstate.tag_data[ :colorado ] = 'fine fishing'
 
 			@renderstate.with_tag_data( :alaska => 'good fishing' ) do
-				@renderstate.tag_data[:alaska].should == 'good fishing'
+				expect( @renderstate.tag_data[:alaska] ).to eq( 'good fishing' )
 				@renderstate.tag_data[:alaska] = 'blueberry bear poop'
 				@renderstate.tag_data[:colorado] = 'Boulder has hippies'
 			end
 
-			@renderstate.tag_data.should_not have_key( :alaska )
-			@renderstate.tag_data[:montana].should == 'excellent fishing'
-			@renderstate.tag_data[:colorado].should == 'fine fishing'
+			expect( @renderstate.tag_data ).to_not have_key( :alaska )
+			expect( @renderstate.tag_data[:montana] ).to eq( 'excellent fishing' )
+			expect( @renderstate.tag_data[:colorado] ).to eq( 'fine fishing' )
 		end
 
 	end
@@ -194,11 +179,11 @@ describe Inversion::RenderState do
 			rval = state.with_destination( newdest ) do
 				state << node
 			end
-			rval.should equal( newdest )
+			expect( rval ).to equal( newdest )
 
-			newdest.should have( 1 ).member
-			newdest.should include( 'New!' )
-			state.destination.should equal( original_dest )
+			expect( newdest.size ).to eq( 1 )
+			expect( newdest ).to include( 'New!' )
+			expect( state.destination ).to equal( original_dest )
 		end
 
 		it "restores the original destination if the block raises an exception" do
@@ -212,7 +197,7 @@ describe Inversion::RenderState do
 				end
 			}.to raise_error()
 
-			state.destination.should equal( original_dest )
+			expect( state.destination ).to equal( original_dest )
 		end
 
 		it "raises an error if #with_destination is called without a block" do
@@ -232,7 +217,7 @@ describe Inversion::RenderState do
 
 			state << node
 
-			state.to_s.should == '<!-- Attr: { template.foo } -->'
+			expect( state.to_s ).to eq( '<!-- Attr: { template.foo } -->' )
 		end
 
 		it "doesn't add a debugging comment when appending a node if debugging comments are disabled" do
@@ -241,7 +226,7 @@ describe Inversion::RenderState do
 
 			state << node
 
-			state.to_s.should == ''
+			expect( state.to_s ).to eq( '' )
 		end
 
 	end
@@ -255,7 +240,7 @@ describe Inversion::RenderState do
 
 			state << node
 
-			state.to_s.should == ''
+			expect( state.to_s ).to eq( '' )
 		end
 
 		it "adds a comment for errors while rendering appended nodes in 'comment' mode" do
@@ -264,7 +249,7 @@ describe Inversion::RenderState do
 
 			state << node
 
-			state.to_s.should == "<!-- NoMethodError: undefined method `klang' for nil:NilClass -->"
+			expect( state.to_s ).to eq( "<!-- NoMethodError: undefined method `klang' for nil:NilClass -->" )
 		end
 
 		it "includes a backtrace when rendering errors in 'comment' mode with 'debugging_comments' enabled" do
@@ -274,8 +259,8 @@ describe Inversion::RenderState do
 			state << node
 			output = state.to_s
 
-			output.should include( "<!-- NoMethodError: undefined method `klang' for nil:NilClass" )
-			output.should include( "#{__FILE__}:#{__LINE__ - 4}" )
+			expect( output ).to include( "<!-- NoMethodError: undefined method `klang' for nil:NilClass" )
+			expect( output ).to include( "#{__FILE__}:#{__LINE__ - 4}" )
 		end
 
 		it "re-raises errors while rendering appended nodes in 'propagate' mode" do
@@ -302,8 +287,8 @@ describe Inversion::RenderState do
 				end
 			}.to_not raise_error()
 
-			state.to_s.should =~ /yum, i eat nomethoderror/i
-			state.errhandler.should equal( defhandler )
+			expect( state.to_s ).to match( /yum, i eat nomethoderror/i )
+			expect( state.errhandler ).to equal( defhandler )
 		end
 
 		it "raises an exception if the error handler is set to something that doesn't respond to #call" do
@@ -332,7 +317,7 @@ describe Inversion::RenderState do
 		end
 
 		it "doesn't have any subscriptions by default" do
-			@state.subscriptions.should == {}
+			expect( @state.subscriptions ).to eq( {} )
 		end
 
 		it "allows an object to subscribe to node publications" do
@@ -340,8 +325,8 @@ describe Inversion::RenderState do
 
 			@state.subscribe( :the_key, subscriber )
 
-			@state.subscriptions.should have( 1 ).member
-			@state.subscriptions[ :the_key ].should == [ subscriber ]
+			expect( @state.subscriptions.size ).to eq( 1 )
+			expect( @state.subscriptions[:the_key] ).to eq( [subscriber] )
 		end
 
 	end
@@ -354,19 +339,19 @@ describe Inversion::RenderState do
 		end
 
 		it "allows rendering to be explicitly enabled and disabled" do
-			@state.rendering_enabled?.should be_true()
+			expect( @state.rendering_enabled? ).to be_truthy()
 			@state.disable_rendering
-			@state.rendering_enabled?.should be_false()
+			expect( @state.rendering_enabled? ).to be_falsey()
 			@state.enable_rendering
-			@state.rendering_enabled?.should be_true()
+			expect( @state.rendering_enabled? ).to be_truthy()
 		end
 
 		it "allows rendering to be toggled" do
-			@state.rendering_enabled?.should be_true()
+			expect( @state.rendering_enabled? ).to be_truthy()
 			@state.toggle_rendering
-			@state.rendering_enabled?.should be_false()
+			expect( @state.rendering_enabled? ).to be_falsey()
 			@state.toggle_rendering
-			@state.rendering_enabled?.should be_true()
+			expect( @state.rendering_enabled? ).to be_truthy()
 		end
 
 		it "doesn't render nodes that are appended to it if rendering is disabled" do
@@ -376,7 +361,7 @@ describe Inversion::RenderState do
 			@state.enable_rendering
 			@state << Inversion::Template::TextNode.new( "after" )
 
-			@state.to_s.should == 'beforeafter'
+			expect( @state.to_s ).to eq( 'beforeafter' )
 		end
 
 	end
@@ -390,7 +375,7 @@ describe Inversion::RenderState do
 
 
 		it "knows how many floating-point seconds have passed since it was created" do
-			@state.time_elapsed.should be_a( Float )
+			expect( @state.time_elapsed ).to be_a( Float )
 		end
 
 	end
@@ -409,7 +394,7 @@ describe Inversion::RenderState do
 			state << Inversion::Template::AttrTag.new( 'good_doggie' )
 			state << Inversion::Template::AttrTag.new( 'little' )
 
-			state.to_s.encoding.should be( Encoding::UTF_8 )
+			expect( state.to_s.encoding ).to be( Encoding::UTF_8 )
 		end
 
 		it "replaces characters with undefined conversions instead of raising an encoding error" do
@@ -426,7 +411,76 @@ describe Inversion::RenderState do
 			state << Inversion::Template::AttrTag.new( 'okay' )
 			state << Inversion::Template::AttrTag.new( 'bogus' )
 
-			state.to_s.encoding.should be( Encoding::UTF_8 )
+			expect( state.to_s.encoding ).to be( Encoding::UTF_8 )
+		end
+
+	end
+
+
+	describe "fragments" do
+
+		before( :each ) do
+			@state = Inversion::RenderState.new
+		end
+
+
+		it "can be set to an Array of rendered nodes" do
+			subscribe_node = Inversion::Template::SubscribeTag.new( 'brand' )
+			@state << subscribe_node
+
+			publish_node = Inversion::Template::PublishTag.new( 'brand' )
+			publish_node << Inversion::Template::TextNode.new( 'Acme' )
+			@state << publish_node
+
+			@state.add_fragment( :title, "Welcome to the ", subscribe_node, " website!" )
+
+			expect( @state.fragments ).to be_a( Hash )
+			expect( @state.fragments[:title] ).to eq([ "Welcome to the ", subscribe_node, " website!" ])
+		end
+
+
+		it "can be returned as a rendered Hash" do
+			subscribe_node = Inversion::Template::SubscribeTag.new( 'brand' )
+			@state << subscribe_node
+
+			publish_node = Inversion::Template::PublishTag.new( 'brand' )
+			publish_node << Inversion::Template::TextNode.new( 'Acme' )
+			@state << publish_node
+
+			@state.add_fragment( :title, "Welcome to the ", subscribe_node, " website!" )
+
+			expect( @state.rendered_fragments ).to be_a( Hash )
+			expect( @state.rendered_fragments[:title] ).to eq( "Welcome to the Acme website!" )
+		end
+
+
+		it "acts like a default if an attribute isn't set" do
+			node = Inversion::Template::FragmentTag.new( 'pork' )
+			node << Inversion::Template::AttrTag.new( 'bool' )
+			node << Inversion::Template::TextNode.new( ' please!' )
+
+			@state.scope[ :bool ] = 'yes'
+			@state << node
+			@state << Inversion::Template::TextNode.new( '--> ' )
+			@state << Inversion::Template::AttrTag.new( 'pork' )
+			@state << Inversion::Template::TextNode.new( ' <--' )
+
+			expect( @state.to_s ).to eq( '--> yes please! <--' )
+		end
+
+
+		it "don't override explicitly-set attributes" do
+			node = Inversion::Template::FragmentTag.new( 'pork' )
+			node << Inversion::Template::AttrTag.new( 'bool' )
+			node << Inversion::Template::TextNode.new( ' please!' )
+
+			@state.scope[ :pork ] = 'pie'
+			@state << node
+			@state << Inversion::Template::TextNode.new( '--> ' )
+			@state << Inversion::Template::AttrTag.new( 'pork' )
+			@state << Inversion::Template::TextNode.new( ' <--' )
+
+			expect( @state.to_s ).to eq( '--> pie <--' )
 		end
 
 	end