inversion 0.1.1 → 0.2.0

data/spec/inversion/{template/parser_spec.rb → parser_spec.rb}

@@ -3,7 +3,7 @@
 
 BEGIN {
 	require 'pathname'
-	basedir = Pathname( __FILE__ ).dirname.parent.parent.parent
+	basedir = Pathname( __FILE__ ).dirname.parent.parent
 	libdir  = basedir + 'lib'
 
 	$LOAD_PATH.unshift( basedir.to_s ) unless $LOAD_PATH.include?( basedir.to_s )
@@ -12,9 +12,9 @@ BEGIN {
 
 require 'rspec'
 require 'spec/lib/helpers'
-require 'inversion/template/parser'
+require 'inversion/parser'
 
-describe Inversion::Template::Parser do
+describe Inversion::Parser do
 
 	before( :all ) do
 		setup_logging( :fatal )
@@ -26,7 +26,7 @@ describe Inversion::Template::Parser do
 	end
 
 	it "parses a string with no PIs as a single text node" do
-		result = Inversion::Template::Parser.new( @template ).parse( "render unto Caesar" )
+		result = Inversion::Parser.new( @template ).parse( "render unto Caesar" )
 
 		result.should have( 1 ).member
 		result.first.should be_a( Inversion::Template::TextNode )
@@ -34,18 +34,18 @@ describe Inversion::Template::Parser do
 	end
 
 	it "parses an empty string as a empty tree" do
-		result = Inversion::Template::Parser.new( @template ).parse( "" )
+		result = Inversion::Parser.new( @template ).parse( "" )
 		result.should be_empty
 	end
 
 	it "raises a ParseError on mismatched tag brackets" do
 		expect {
-			Inversion::Template::Parser.new( @template ).parse( '[?foo bar ?>' )
+			Inversion::Parser.new( @template ).parse( '[?foo bar ?>' )
 		}.to raise_error( Inversion::ParseError, /mismatched start and end brackets/i )
 	end
 
 	it "parses a string with a single 'attr' tag as a single AttrTag node" do
-		result = Inversion::Template::Parser.new( @template ).parse( "<?attr foo ?>" )
+		result = Inversion::Parser.new( @template ).parse( "<?attr foo ?>" )
 
 		result.should have( 1 ).member
 		result.first.should be_a( Inversion::Template::AttrTag )
@@ -53,7 +53,7 @@ describe Inversion::Template::Parser do
 	end
 
 	it "parses a single 'attr' tag surrounded by plain text" do
-		result = Inversion::Template::Parser.new( @template ).parse( "beginning<?attr foo ?>end" )
+		result = Inversion::Parser.new( @template ).parse( "beginning<?attr foo ?>end" )
 
 		result.should have( 3 ).members
 		result[0].should be_a( Inversion::Template::TextNode )
@@ -63,7 +63,7 @@ describe Inversion::Template::Parser do
 	end
 
 	it "ignores unknown tags by default" do
-		result = Inversion::Template::Parser.new( @template ).parse( "Text <?hoooowhat ?>" )
+		result = Inversion::Parser.new( @template ).parse( "Text <?hoooowhat ?>" )
 
 		result.should have( 2 ).members
 		result[0].should be_a( Inversion::Template::TextNode )
@@ -73,28 +73,28 @@ describe Inversion::Template::Parser do
 
 	it "can raise exceptions on unknown tags" do
 		expect {
-			Inversion::Template::Parser.new( @template, :ignore_unknown_tags => false ).
+			Inversion::Parser.new( @template, :ignore_unknown_tags => false ).
 				parse( "Text <?hoooowhat ?>" )
 		}.to raise_exception( Inversion::ParseError, /unknown tag/i )
 	end
 
 	it "can raise exceptions on unclosed (nested) tags" do
 		expect {
-			Inversion::Template::Parser.new( @template ).parse( "Text <?attr something <?attr something_else ?>" )
+			Inversion::Parser.new( @template ).parse( "Text <?attr something <?attr something_else ?>" )
 		}.to raise_exception( Inversion::ParseError, /unclosed or nested tag/i )
 	end
 
 	it "can raise exceptions on unclosed (eof) tags" do
 		expect {
-			Inversion::Template::Parser.new( @template ).parse( "Text <?hoooowhat" )
+			Inversion::Parser.new( @template ).parse( "Text <?hoooowhat" )
 		}.to raise_exception( Inversion::ParseError, /unclosed tag/i )
 	end
 
 
-	describe Inversion::Template::Parser::State do
+	describe Inversion::Parser::State do
 
 		before( :each ) do
-			@state = Inversion::Template::Parser::State.new( @template )
+			@state = Inversion::Parser::State.new( @template )
 		end
 
 		it "returns the node tree if it's well-formed" do

data/spec/inversion/renderstate_spec.rb

@@ -23,245 +23,287 @@ describe Inversion::RenderState do
 		setup_logging( :fatal )
 	end
 
-	it "copies its initial attributes" do
-		attributes = { :foot => "in mouth", :bear => "in woods" }
-
-		state = Inversion::RenderState.new( attributes )
-
-		state.attributes.should_not equal( attributes )
-		state.attributes[:foot].should == "in mouth"
-		state.attributes[:foot].should_not equal( attributes[:foot] )
-		state.attributes[:bear].should == "in woods"
-		state.attributes[:bear].should_not equal( attributes[:bear] )
+	after( :all ) do
+		reset_logging()
 	end
 
 
-	it "preserves tainted status when copying its attributes" do
-		attributes = { :danger => "in pants" }
-		attributes[:danger].taint
+	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 )
+	end
 
+	it "can evaluate code in the context of itself" do
+		attributes = { :foot => "in mouth", :bear => "in woods" }
 		state = Inversion::RenderState.new( attributes )
-
-		state.attributes[:danger].should be_tainted()
+		state.eval( "foot" ).should == 'in mouth'
 	end
 
 
-	it "preserves frozen status when copying its attributes" do
-		attributes = { :danger => "in pants" }
-		attributes[:danger].freeze
+	describe "overridable attributes" do
 
-		state = Inversion::RenderState.new( attributes )
+		it "copies its initial attributes" do
+			attributes = { :foot => "in mouth", :bear => "in woods" }
 
-		state.attributes[:danger].should be_frozen()
-	end
+			state = Inversion::RenderState.new( attributes )
 
+			state.attributes.should_not equal( attributes )
+			state.attributes[:foot].should == "in mouth"
+			state.attributes[:foot].should_not equal( attributes[:foot] )
+			state.attributes[:bear].should == "in woods"
+			state.attributes[:bear].should_not equal( attributes[:bear] )
+		end
 
-	it "preserves singleton methods on attribute objects when copying" do
-		obj = Object.new
-		def obj.foo; "foo!"; end
+		it "preserves tainted status when copying its attributes" do
+			attributes = { :danger => "in pants" }
+			attributes[:danger].taint
 
-		state = Inversion::RenderState.new( :foo => obj )
+			state = Inversion::RenderState.new( attributes )
 
-		state.attributes[:foo].singleton_methods.map( &:to_sym ).should include( :foo )
-	end
+			state.attributes[:danger].should be_tainted()
+		end
 
+		it "preserves singleton methods on attribute objects when copying" do
+			obj = Object.new
+			def obj.foo; "foo!"; 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 )
-	end
+			state = Inversion::RenderState.new( :foo => obj )
 
+			state.attributes[:foo].singleton_methods.map( &:to_sym ).should include( :foo )
+		end
 
-	it "can evaluate code in the context of itself" do
-		attributes = { :foot => "in mouth", :bear => "in woods" }
+		it "preserves frozen status when copying its attributes" do
+			attributes = { :danger => "in pants" }
+			attributes[:danger].freeze
 
-		state = Inversion::RenderState.new( attributes )
+			state = Inversion::RenderState.new( attributes )
 
-		state.eval( "foot" ).should == 'in mouth'
-	end
+			state.attributes[:danger].should be_frozen()
+		end
 
-	it "can override its attributes for the duration of a block" do
-		attributes = { :foot => "in mouth", :bear => "in woods" }
+		it "can override its attributes for the duration of a block" do
+			attributes = { :foot => "in mouth", :bear => "in woods" }
 
-		state = Inversion::RenderState.new( attributes )
+			state = Inversion::RenderState.new( attributes )
 
-		state.with_attributes( :foot => 'ball' ) do
-			state.foot.should == 'ball'
-			state.bear.should == 'in woods'
-		end
+			state.with_attributes( :foot => 'ball' ) do
+				state.foot.should == 'ball'
+				state.bear.should == 'in woods'
+			end
 
-		state.attributes[:foot].should == 'in mouth'
-	end
+			state.attributes[:foot].should == 'in mouth'
+		end
 
 
-	it "restores the original attributes if the block raises an exception" do
-		attributes = { :foot => "in mouth", :bear => "in woods" }
+		it "restores the original attributes if the block raises an exception" do
+			attributes = { :foot => "in mouth", :bear => "in woods" }
 
-		state = Inversion::RenderState.new( attributes )
+			state = Inversion::RenderState.new( attributes )
 
-		expect {
-			state.with_attributes( {} ) do
-				raise "Charlie dooo!"
-			end
-		}.to raise_error()
+			expect {
+				state.with_attributes( {} ) do
+					raise "Charlie dooo!"
+				end
+			}.to raise_error()
 
-		state.attributes[:foot].should == 'in mouth'
-	end
+			state.attributes[:foot].should == 'in mouth'
+		end
 
 
-	it "raises an error if #with_attributes is called without a block" do
-		expect {
-			Inversion::RenderState.new.with_attributes( {} )
-		}.to raise_error( LocalJumpError, /no block/i )
-	end
+		it "raises an error if #with_attributes is called without a block" do
+			expect {
+				Inversion::RenderState.new.with_attributes( {} )
+			}.to raise_error( LocalJumpError, /no block/i )
+		end
 
+		it "provides accessor methods for its attributes" do
+			state = Inversion::RenderState.new( :bar => :the_attribute_value )
+			state.bar.should == :the_attribute_value
+		end
 
-	it "can override the render destination for the duration of a block" do
-		state = Inversion::RenderState.new
+		it "doesn't error if an accessor for a non-existant attribute is called" do
+			state = Inversion::RenderState.new( :bar => :the_attribute_value )
+			state.foo.should be_nil()
+		end
 
-		original_dest = state.destination
-		newdest = []
-		node = Inversion::Template::TextNode.new( "New!" )
-		rval = state.with_destination( newdest ) do
-			state << node
+		it "can be merged with another RenderState" do
+			state = Inversion::RenderState.new(
+				{:bar => :the_bar_value},
+				{:debugging_comments => false} )
+			anotherstate = Inversion::RenderState.new(
+				{:foo => :the_foo_value},
+				{:debugging_comments => true, :on_render_error => :propagate} )
+
+			thirdstate = state.merge( anotherstate )
+
+			thirdstate.attributes.should == {
+				:bar => :the_bar_value,
+				:foo => :the_foo_value
+			}
+			thirdstate.options.should include(
+				:debugging_comments => true,
+				:on_render_error => :propagate
+			)
 		end
-		rval.should equal( newdest )
 
-		newdest.should have( 1 ).member
-		newdest.should include( 'New!' )
-		state.destination.should equal( original_dest )
 	end
 
-	it "restores the original destination if the block raises an exception" do
-		state = Inversion::RenderState.new
 
-		original_dest = state.destination
+	describe "context-aware tag state" do
 
-		expect {
-			state.with_destination( [] ) do
-				raise "New!"
-			end
-		}.to raise_error()
+		before( :each ) do
+			@renderstate = Inversion::RenderState.new 
+		end
 
-		state.destination.should equal( original_dest )
-	end
+		it "provides a mechanism for storing tag state for the current render" do
+			@renderstate.tag_data.should be_a( Hash )
+		end
 
-	it "raises an error if #with_destination is called without a block" do
-		expect {
-			Inversion::RenderState.new.with_destination( [] )
-		}.to raise_error( LocalJumpError, /no block/i )
-	end
+		it "can override tag state for the duration of a block" do
+			@renderstate.tag_data[ :montana ] = 'excellent fishing'
+			@renderstate.tag_data[ :colorado ] = 'fine fishing'
 
-	it "adds a debugging comment when appending a node if debugging comments are enabled" do
-		node = Inversion::Template::AttrTag.new( 'foo' )
-		state = Inversion::RenderState.new( {}, :debugging_comments => true )
+			@renderstate.with_tag_data( :alaska => 'good fishing' ) do
+				@renderstate.tag_data[:alaska].should == 'good fishing'
+				@renderstate.tag_data[:alaska] = 'blueberry bear poop'
+				@renderstate.tag_data[:colorado] = 'Boulder has hippies'
+			end
 
-		state << node
+			@renderstate.tag_data.should_not have_key( :alaska )
+			@renderstate.tag_data[:montana].should == 'excellent fishing'
+			@renderstate.tag_data[:colorado].should == 'fine fishing'
+		end
 
-		state.to_s.should == '<!-- Attr: { template.foo } -->'
 	end
 
-	it "doesn't add a debugging comment when appending a node if debugging comments are disabled" do
-		node = Inversion::Template::AttrTag.new( 'foo' )
-		state = Inversion::RenderState.new( {}, :debugging_comments => false )
+	describe "render destinations" do
 
-		state << node
+		it "can override the render destination for the duration of a block" do
+			state = Inversion::RenderState.new
 
-		state.to_s.should == ''
-	end
+			original_dest = state.destination
+			newdest = []
+			node = Inversion::Template::TextNode.new( "New!" )
+			rval = state.with_destination( newdest ) do
+				state << node
+			end
+			rval.should equal( newdest )
 
-	it "ignores errors while rendering appended nodes in 'ignore' mode" do
-		node  = Inversion::Template::AttrTag.new( 'boom.klang' )
-		state = Inversion::RenderState.new( {}, :on_render_error => :ignore )
+			newdest.should have( 1 ).member
+			newdest.should include( 'New!' )
+			state.destination.should equal( original_dest )
+		end
 
-		state << node
+		it "restores the original destination if the block raises an exception" do
+			state = Inversion::RenderState.new
 
-		state.to_s.should == ''
-	end
+			original_dest = state.destination
 
-	it "adds a comment for errors while rendering appended nodes in 'comment' mode" do
-		node  = Inversion::Template::AttrTag.new( 'boom.klang' )
-		state = Inversion::RenderState.new( {}, :on_render_error => :comment )
+			expect {
+				state.with_destination( [] ) do
+					raise "New!"
+				end
+			}.to raise_error()
 
-		state << node
+			state.destination.should equal( original_dest )
+		end
+
+		it "raises an error if #with_destination is called without a block" do
+			expect {
+				Inversion::RenderState.new.with_destination( [] )
+			}.to raise_error( LocalJumpError, /no block/i )
+		end
 
-		state.to_s.should == "<!-- NoMethodError: undefined method `klang' for nil:NilClass -->"
 	end
 
-	it "re-raises errors while rendering appended nodes in 'propagate' mode" do
-		node  = Inversion::Template::AttrTag.new( 'boom.klang' )
-		state = Inversion::RenderState.new( {}, :on_render_error => :propagate )
 
-		expect {
+	describe "debugging comments" do
+
+		it "adds a debugging comment when appending a node if debugging comments are enabled" do
+			node = Inversion::Template::AttrTag.new( 'foo' )
+			state = Inversion::RenderState.new( {}, :debugging_comments => true )
+
 			state << node
-		}.to raise_error( NoMethodError, /undefined method/ )
-	end
 
-	it "calls the provided handler if an exception is raised while the error handler has been " +
-	   "overridden" do
-		handler    = Proc.new do |state, node, err|
-			"Yum, I eat %p from %p! Tasting good!" % [err.class, node.class]
+			state.to_s.should == '<!-- Attr: { template.foo } -->'
 		end
-		node       = Inversion::Template::AttrTag.new( 'boom.klang' )
-		state      = Inversion::RenderState.new( {}, :on_render_error => :propagate )
-		defhandler = state.errhandler
 
-		expect {
-			state.with_error_handler( handler ) do
-				state << node
-			end
-		}.to_not raise_error()
+		it "doesn't add a debugging comment when appending a node if debugging comments are disabled" do
+			node = Inversion::Template::AttrTag.new( 'foo' )
+			state = Inversion::RenderState.new( {}, :debugging_comments => false )
 
-		state.to_s.should =~ /yum, i eat nomethoderror/i
-		state.errhandler.should equal( defhandler )
-	end
+			state << node
+
+			state.to_s.should == ''
+		end
 
-	it "raises an exception if the error handler is set to something that doesn't respond to #call" do
-		state = Inversion::RenderState.new
-		expect {
-			state.with_error_handler( :foo )
-		}.to raise_error( ArgumentError, /doesn't respond_to #call/i )
 	end
 
-	it "re-raises errors while rendering appended nodes in 'propagate' mode" do
-		node  = Inversion::Template::AttrTag.new( 'boom.klang' )
-		state = Inversion::RenderState.new( {}, :on_render_error => :propagate )
 
-		expect {
+	describe "error-handling" do
+
+		it "ignores errors while rendering appended nodes in 'ignore' mode" do
+			node  = Inversion::Template::AttrTag.new( 'boom.klang' )
+			state = Inversion::RenderState.new( {}, :on_render_error => :ignore )
+
 			state << node
-		}.to raise_error( NoMethodError, /undefined method/ )
-	end
 
-	it "provides accessor methods for its attributes" do
-		state = Inversion::RenderState.new( :bar => :the_attribute_value )
-		state.bar.should == :the_attribute_value
-	end
+			state.to_s.should == ''
+		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.foo.should be_nil()
-	end
+		it "adds a comment for errors while rendering appended nodes in 'comment' mode" do
+			node  = Inversion::Template::AttrTag.new( 'boom.klang' )
+			state = Inversion::RenderState.new( {}, :on_render_error => :comment )
+
+			state << node
 
+			state.to_s.should == "<!-- NoMethodError: undefined method `klang' for nil:NilClass -->"
+		end
 
-	it "can be merged with another RenderState" do
-		state = Inversion::RenderState.new(
-			{:bar => :the_bar_value},
-			{:debugging_comments => false} )
-		anotherstate = Inversion::RenderState.new(
-			{:foo => :the_foo_value},
-			{:debugging_comments => true, :on_render_error => :propagate} )
+		it "re-raises errors while rendering appended nodes in 'propagate' mode" do
+			node  = Inversion::Template::AttrTag.new( 'boom.klang' )
+			state = Inversion::RenderState.new( {}, :on_render_error => :propagate )
 
-		thirdstate = state.merge( anotherstate )
+			expect {
+				state << node
+			}.to raise_error( NoMethodError, /undefined method/ )
+		end
 
-		thirdstate.attributes.should == {
-			:bar => :the_bar_value,
-			:foo => :the_foo_value
-		}
-		thirdstate.options.should include(
-			:debugging_comments => true,
-			:on_render_error => :propagate
-		)
+		it "calls the provided handler if an exception is raised while the error handler has been " +
+		   "overridden" do
+			handler    = Proc.new do |state, node, err|
+				"Yum, I eat %p from %p! Tasting good!" % [err.class, node.class]
+			end
+			node       = Inversion::Template::AttrTag.new( 'boom.klang' )
+			state      = Inversion::RenderState.new( {}, :on_render_error => :propagate )
+			defhandler = state.errhandler
+
+			expect {
+				state.with_error_handler( handler ) do
+					state << node
+				end
+			}.to_not raise_error()
+
+			state.to_s.should =~ /yum, i eat nomethoderror/i
+			state.errhandler.should equal( defhandler )
+		end
+
+		it "raises an exception if the error handler is set to something that doesn't respond to #call" do
+			state = Inversion::RenderState.new
+			expect {
+				state.with_error_handler( :foo )
+			}.to raise_error( ArgumentError, /doesn't respond_to #call/i )
+		end
+
+		it "re-raises errors while rendering appended nodes in 'propagate' mode" do
+			node  = Inversion::Template::AttrTag.new( 'boom.klang' )
+			state = Inversion::RenderState.new( {}, :on_render_error => :propagate )
+
+			expect {
+				state << node
+			}.to raise_error( NoMethodError, /undefined method/ )
+		end
 
 	end
 
@@ -287,5 +329,40 @@ describe Inversion::RenderState do
 
 	end
 
+
+	describe "conditional rendering" do
+
+		before( :each ) do
+			@state = Inversion::RenderState.new
+		end
+
+		it "allows rendering to be explicitly enabled and disabled" do
+			@state.rendering_enabled?.should be_true()
+			@state.disable_rendering
+			@state.rendering_enabled?.should be_false()
+			@state.enable_rendering
+			@state.rendering_enabled?.should be_true()
+		end
+
+		it "allows rendering to be toggled" do
+			@state.rendering_enabled?.should be_true()
+			@state.toggle_rendering
+			@state.rendering_enabled?.should be_false()
+			@state.toggle_rendering
+			@state.rendering_enabled?.should be_true()
+		end
+
+		it "doesn't render nodes that are appended to it if rendering is disabled" do
+			@state << Inversion::Template::TextNode.new( "before" )
+			@state.disable_rendering
+			@state << Inversion::Template::TextNode.new( "during" )
+			@state.enable_rendering
+			@state << Inversion::Template::TextNode.new( "after" )
+
+			@state.to_s.should == 'beforeafter'
+		end
+
+	end
+
 end