inversion 0.1.1 → 0.2.0

data/spec/inversion/template/attrtag_spec.rb

@@ -99,18 +99,18 @@ describe Inversion::Template::AttrTag do
 			end
 
 			it "renders as the stringified contents of the template attribute with the same name" do
-				template = stub( "template object", :attributes => {:foo => %w[floppy the turtle]} )
-				@tag.render( template ).should == ["floppy", "the", "turtle"]
+				state = Inversion::RenderState.new( :foo => %w[floppy the turtle] )
+				@tag.render( state ).should == ["floppy", "the", "turtle"]
 			end
 
 			it "doesn't error if the attribute isn't set on the template" do
-				template = stub( "template object", :attributes => { :foo => nil } )
-				@tag.render( template ).should == nil
+				state = Inversion::RenderState.new( :foo => nil )
+				@tag.render( state ).should == nil
 			end
 
 			it "returns false when the rendered value is false" do
-				template = stub( "template object", :attributes => { :foo => false } )
-				@tag.render( template ).should equal( false )
+				state = Inversion::RenderState.new( :foo => false )
+				@tag.render( state ).should equal( false )
 			end
 
 			it "can render itself as a comment for template debugging" do
@@ -127,21 +127,13 @@ describe Inversion::Template::AttrTag do
 			end
 
 			it "renders as the formatted contents of the template attribute with the same name" do
-				attributes = double( "template object attributes" )
-				template = stub( "template object", :attributes => attributes )
-
-				attributes.should_receive( :[] ).with( :foo ).and_return( Math::PI )
-
-				@tag.render( template ).should == '3.14'
+				state = Inversion::RenderState.new( :foo => Math::PI )
+				@tag.render( state ).should == '3.14'
 			end
 
 			it "doesn't error if the attribute isn't set on the template" do
-				attributes = double( "template object attributes" )
-				template = stub( "template object", :attributes => attributes )
-
-				attributes.should_receive( :[] ).with( :foo ).and_return( nil )
-
-				@tag.render( template ).should == nil
+				state = Inversion::RenderState.new( :foo => nil )
+				@tag.render( state ).should == nil
 			end
 
 			it "can render itself as a comment for template debugging" do

data/spec/inversion/template/begintag_spec.rb

@@ -39,13 +39,13 @@ describe Inversion::Template::BeginTag do
 			@tag << Inversion::Template::TextNode.new( ':the stuff after the attr' )
 		end
 
-		it "should render its subnodes as-is if none of them raise an exception"  do
+		it "renders its subnodes as-is if none of them raise an exception"  do
 			renderstate = Inversion::RenderState.new( :foo => OpenStruct.new(:baz => 'the body') )
 			renderstate << @tag
 			renderstate.to_s.should == 'the body:the stuff after the attr'
 		end
 
-		it "should use the configured error behavior of the template if a subnode raises any exception" do
+		it "uses the configured error behavior of the template if a subnode raises any exception" do
 			renderstate = Inversion::RenderState.new
 			renderstate << @tag
 			renderstate.to_s.should =~ /NoMethodError/
@@ -74,13 +74,13 @@ describe Inversion::Template::BeginTag do
 			@tag.rescue_clauses.should == [ [[::RuntimeError], [@rescue_textnode]] ]
 		end
 
-		it "should render its subnodes as-is if none of them raise an exception"  do
+		it "renders its subnodes as-is if none of them raise an exception"  do
 			renderstate = Inversion::RenderState.new( :foo => OpenStruct.new(:baz => 'the body') )
 			renderstate << @tag
 			renderstate.to_s.should == 'the body:the stuff after the attr'
 		end
 
-		it "should render the rescue section if a subnode raises a RuntimeError"  do
+		it "renders the rescue section if a subnode raises a RuntimeError"  do
 			fooobj = Object.new
 			def fooobj.baz; raise "An exception"; end
 
@@ -89,7 +89,7 @@ describe Inversion::Template::BeginTag do
 			renderstate.to_s.should == 'rescue stuff'
 		end
 
-		it "should use the configured error behavior of the template if a subnode raises an " +
+		it "uses the configured error behavior of the template if a subnode raises an " +
 		   "exception other than RuntimeError" do
 			fooobj = Object.new
 			def fooobj.baz; raise Errno::ENOENT, "No such file or directory"; end
@@ -105,6 +105,7 @@ describe Inversion::Template::BeginTag do
 
 	context "with a single rescue clause with an exception type" do
 		before( :each ) do
+			
 			@tag = Inversion::Template::BeginTag.new( ' ' )
 
 			@attrtag = Inversion::Template::AttrTag.new( 'foo.baz' )
@@ -122,13 +123,13 @@ describe Inversion::Template::BeginTag do
 			@tag.rescue_clauses.should == [ [[::SystemCallError], [@rescue_textnode]] ]
 		end
 
-		it "should render its subnodes as-is if none of them raise an exception"  do
+		it "renders its subnodes as-is if none of them raise an exception"  do
 			renderstate = Inversion::RenderState.new( :foo => OpenStruct.new(:baz => 'the body') )
 			renderstate << @tag
 			renderstate.to_s.should == 'the body:the stuff after the attr'
 		end
 
-		it "should render the rescue section if a subnode raises the specified exception type"  do
+		it "renders the rescue section if a subnode raises the specified exception type"  do
 			fooobj = Object.new
 			def fooobj.baz; raise Errno::ENOENT, "no such file or directory"; end
 
@@ -137,7 +138,7 @@ describe Inversion::Template::BeginTag do
 			renderstate.to_s.should == 'rescue stuff'
 		end
 
-		it "should use the configured error behavior of the template if a subnode raises an " +
+		it "uses the configured error behavior of the template if a subnode raises an " +
 		   "exception other than the specified type" do
 			fooobj = Object.new
 			def fooobj.baz; raise "SPlat!"; end
@@ -175,13 +176,13 @@ describe Inversion::Template::BeginTag do
 			]
 		end
 
-		it "should render its subnodes as-is if none of them raise an exception"  do
+		it "renders its subnodes as-is if none of them raise an exception"  do
 			renderstate = Inversion::RenderState.new( :foo => OpenStruct.new(:baz => 'the body') )
 			renderstate << @tag
 			renderstate.to_s.should == 'the body:the stuff after the attr'
 		end
 
-		it "should render the first rescue section if a subnode raises the exception it " +
+		it "renders the first rescue section if a subnode raises the exception it " +
 		   "specifies"  do
 			fooobj = Object.new
 			def fooobj.baz; raise "An exception"; end
@@ -191,7 +192,7 @@ describe Inversion::Template::BeginTag do
 			renderstate.to_s.should == 'rescue stuff'
 		end
 
-		it "should render the second rescue section if a subnode raises the exception it " +
+		it "renders the second rescue section if a subnode raises the exception it " +
 		   "specifies"  do
 			fooobj = Object.new
 			def fooobj.baz; raise Errno::ENOENT, "no such file or directory"; end
@@ -201,7 +202,7 @@ describe Inversion::Template::BeginTag do
 			renderstate.to_s.should == 'alternative rescue stuff'
 		end
 
-		it "should use the configured error behavior of the template if a subnode raises an " +
+		it "uses the configured error behavior of the template if a subnode raises an " +
 		   "exception other than those specified by the rescue clauses" do
 			fooobj = Object.new
 			def fooobj.baz; raise Errno::ENOMEM, "All out!"; end

data/spec/inversion/template/configtag_spec.rb

@@ -86,17 +86,15 @@ describe Inversion::Template::ConfigTag do
 		}.to raise_exception( Inversion::ParseError, /unknown tag "what"/i )
 	end
 
-	it "can change the strictness of the parser as it's parsing the template" do
+	it "can turn on debugging comments in rendered output" do
 		source = <<-TEMPLATE
-		<?hooooowhat ?>
-		<?config ignore_unknown_tags: false ?>
+		<?config debugging_comments: true ?>
 		something
-		<?what ?>
+		<?if foo ?>Van!<?end if ?>
 		something else
 		TEMPLATE
-		expect {
-			Inversion::Template.new( source, :ignore_unknown_tags => true )
-		}.to raise_exception( Inversion::ParseError, /unknown tag "what"/i )
+		tmpl = Inversion::Template.new( source )
+		tmpl.render.should include( "<!-- If: { template.foo } -->" )
 	end
 
 end

data/spec/inversion/template/elsetag_spec.rb

@@ -35,7 +35,7 @@ describe Inversion::Template::ElseTag do
 
 	it "can be appended to an 'if' tag" do
 		template    = double( "template object" )
-		parserstate = Inversion::Template::Parser::State.new( template )
+		parserstate = Inversion::Parser::State.new( template )
 		iftag       = Inversion::Template::IfTag.new( 'foo' )
 		elsetag     = Inversion::Template::ElseTag.new
 		endtag      = Inversion::Template::EndTag.new
@@ -47,7 +47,7 @@ describe Inversion::Template::ElseTag do
 
 	it "can be appended to an 'unless' tag" do
 		template    = double( "template object" )
-		parserstate = Inversion::Template::Parser::State.new( template )
+		parserstate = Inversion::Parser::State.new( template )
 		unlesstag   = Inversion::Template::UnlessTag.new( 'foo' )
 		elsetag     = Inversion::Template::ElseTag.new
 		endtag      = Inversion::Template::EndTag.new
@@ -60,7 +60,7 @@ describe Inversion::Template::ElseTag do
 
 	it "can be appended to a 'comment' tag" do
 		template    = double( "template object" )
-		parserstate = Inversion::Template::Parser::State.new( template )
+		parserstate = Inversion::Parser::State.new( template )
 		commenttag  = Inversion::Template::CommentTag.new( 'else section for later' )
 		elsetag     = Inversion::Template::ElseTag.new
 		endtag      = Inversion::Template::EndTag.new
@@ -74,7 +74,7 @@ describe Inversion::Template::ElseTag do
 	it "raises an error if it's about to be appended to anything other than an 'if', 'unless', " +
 	   "or 'comment' tag" do
 		template    = double( "template object" )
-		parserstate = Inversion::Template::Parser::State.new( template )
+		parserstate = Inversion::Parser::State.new( template )
 		parserstate << Inversion::Template::ForTag.new( 'foo in bar' )
 
 		expect {
@@ -85,7 +85,7 @@ describe Inversion::Template::ElseTag do
 
 	it "raises an error if it's about to be appended without an opening 'if' or 'unless'" do
 		template    = double( "template object" )
-		parserstate = Inversion::Template::Parser::State.new( template )
+		parserstate = Inversion::Parser::State.new( template )
 
 		expect {
 			parserstate << Inversion::Template::ElseTag.new

data/spec/inversion/template/elsiftag_spec.rb

@@ -31,7 +31,7 @@ describe Inversion::Template::ElsifTag do
 
 	it "can be appended to an 'if' tag" do
 		template    = double( "template object" )
-		parserstate = Inversion::Template::Parser::State.new( template )
+		parserstate = Inversion::Parser::State.new( template )
 		iftag       = Inversion::Template::IfTag.new( 'foo' )
 		elsetag     = Inversion::Template::ElsifTag.new( 'bar' )
 		endtag      = Inversion::Template::EndTag.new
@@ -43,7 +43,7 @@ describe Inversion::Template::ElsifTag do
 
 	it "can be appended to a 'comment' tag" do
 		template    = double( "template object" )
-		parserstate = Inversion::Template::Parser::State.new( template )
+		parserstate = Inversion::Parser::State.new( template )
 		commenttag  = Inversion::Template::CommentTag.new( 'else section for later' )
 		elsetag     = Inversion::Template::ElsifTag.new( 'bar' )
 		endtag      = Inversion::Template::EndTag.new
@@ -56,7 +56,7 @@ describe Inversion::Template::ElsifTag do
 
 	it "raises an error if it's about to be appended to anything other than an 'if' or 'comment' tag" do
 		template    = double( "template object" )
-		parserstate = Inversion::Template::Parser::State.new( template )
+		parserstate = Inversion::Parser::State.new( template )
 		parserstate << Inversion::Template::UnlessTag.new( 'foo in bar' )
 
 		expect {
@@ -67,7 +67,7 @@ describe Inversion::Template::ElsifTag do
 
 	it "raises an error if it's about to be appended without an opening 'if'" do
 		template    = double( "template object" )
-		parserstate = Inversion::Template::Parser::State.new( template )
+		parserstate = Inversion::Parser::State.new( template )
 
 		expect {
 			parserstate << Inversion::Template::ElsifTag.new( 'bar' )
@@ -78,7 +78,7 @@ describe Inversion::Template::ElsifTag do
 	it "renders as its attribute value if it's a simple attribute" do
 		renderstate = Inversion::RenderState.new( :bar => :the_attribute_value )
 		tag = Inversion::Template::ElsifTag.new( 'bar' )
-		tag.render( renderstate ).should == :the_attribute_value
+		tag.evaluate( renderstate ).should == :the_attribute_value
 	end
 
 end

data/spec/inversion/template/endtag_spec.rb

@@ -61,7 +61,7 @@ describe Inversion::Template::EndTag do
 		end
 
 		it "raises an error on the addition of a mismatched end tag" do
-			state = Inversion::Template::Parser::State.new( :template )
+			state = Inversion::Parser::State.new( :template )
 			opener = Inversion::Template::ForTag.new( 'foo in bar' )
 			state << opener
 

data/spec/inversion/template/fortag_spec.rb

@@ -66,7 +66,28 @@ describe Inversion::Template::ForTag do
 		tag << Inversion::Template::AttrTag.new( 'foo' )
 		tag << Inversion::Template::TextNode.new( ']' )
 
-		tag.render( render_state ).should == "[monkey][goat]"
+		tag.render( render_state )
+		render_state.to_s.should == "[monkey][goat]"
+	end
+
+	it "supports nested iterators" do
+		render_state = Inversion::RenderState.new( :tic => [ 'x', 'o'], :tac => ['o', 'x'] )
+
+		# <?for omarker in tic ?><?for imarker in tac ?>
+		outer = Inversion::Template::ForTag.new( 'omarker in tic' )
+		inner = Inversion::Template::ForTag.new( 'imarker in tac' )
+
+		# [<?attr omarker?>, <?attr imarker?>]
+		inner << Inversion::Template::TextNode.new( '[' )
+		inner << Inversion::Template::AttrTag.new( 'omarker' )
+		inner << Inversion::Template::TextNode.new( ', ' )
+		inner << Inversion::Template::AttrTag.new( 'imarker' )
+		inner << Inversion::Template::TextNode.new( ']' )
+
+		outer << inner
+
+		outer.render( render_state )
+		render_state.to_s.should == "[x, o][x, x][o, o][o, x]"
 	end
 
 	it "raises a ParseError if a keyword other than 'in' is used" do

data/spec/inversion/template/iftag_spec.rb

@@ -64,6 +64,20 @@ describe Inversion::Template::IfTag do
 		renderstate.to_s.should == ''
 	end
 
+	it "works inside an iterator (ticket #3)" do
+		template = Inversion::Template.new( <<-END_TEMPLATE )
+		<?for item in items ?>
+		Item: <?if item ?>Yep.<?else?>Nope.<?end?>
+		<?end for ?>
+		END_TEMPLATE
+
+		template.items = [ true, false ]
+
+		template.render.should include( "Item: Yep." )
+		template.render.should include( "Item: Nope." )
+	end
+
+
 	context "with a single 'else' clause" do
 
 		before( :each ) do

data/spec/inversion/template/rescuetag_spec.rb

@@ -50,7 +50,7 @@ describe Inversion::Template::RescueTag do
 
 	it "can be appended to a 'begin' tag" do
 		template    = double( "template object" )
-		parserstate = Inversion::Template::Parser::State.new( template )
+		parserstate = Inversion::Parser::State.new( template )
 		begintag    = Inversion::Template::BeginTag.new
 		rescuetag   = Inversion::Template::RescueTag.new
 		textnode    = Inversion::Template::TextNode.new( 'Yeah!' )
@@ -64,7 +64,7 @@ describe Inversion::Template::RescueTag do
 
 	it "can be appended to a 'comment' tag" do
 		template    = double( "template object" )
-		parserstate = Inversion::Template::Parser::State.new( template )
+		parserstate = Inversion::Parser::State.new( template )
 		commenttag  = Inversion::Template::CommentTag.new( 'rescue section for later' )
 		rescuetag   = Inversion::Template::RescueTag.new
 		endtag      = Inversion::Template::EndTag.new
@@ -78,7 +78,7 @@ describe Inversion::Template::RescueTag do
 	it "raises an error if it's about to be appended to anything other than a 'begin' or " +
 	   "'comment' tag" do
 		template    = double( "template object" )
-		parserstate = Inversion::Template::Parser::State.new( template )
+		parserstate = Inversion::Parser::State.new( template )
 		parserstate << Inversion::Template::ForTag.new( 'foo in bar' )
 
 		expect {
@@ -89,7 +89,7 @@ describe Inversion::Template::RescueTag do
 
 	it "raises an error if it's about to be appended without an opening 'begin'" do
 		template    = double( "template object" )
-		parserstate = Inversion::Template::Parser::State.new( template )
+		parserstate = Inversion::Parser::State.new( template )
 
 		expect {
 			parserstate << Inversion::Template::RescueTag.new

data/spec/inversion/template/tag_spec.rb

@@ -35,11 +35,12 @@ describe Inversion::Template::Tag do
 
 
 	it "loads pluggable types via Rubygems" do
+		pluginfile = '/usr/lib/ruby/gems/1.8/gems/inversion-extra-1.0.8/lib/inversion/template/zebratag.rb'
 		Gem.stub( :find_files ).
 			with( Inversion::Template::Tag::TAG_PLUGIN_PATTERN ).
-			and_return([ 'inversion/template/zebratag.rb' ])
+			and_return([ pluginfile ])
 		Inversion::Template::Tag.should_receive( :require ).
-			with( 'inversion/template/zebratag.rb' ).
+			with( 'inversion/template/zebratag' ).
 			and_return {
 				Class.new( Inversion::Template::Tag ) {
 					def self::name; "ZebraTag"; end
@@ -54,11 +55,12 @@ describe Inversion::Template::Tag do
 	end
 
 	it "doesn't include abstract tag types in its loading mechanism" do
+		pluginfile = '/usr/lib/ruby/gems/1.8/gems/inversion-extra-1.0.8/lib/inversion/template/zebratag.rb'
 		Gem.stub( :find_files ).
 			with( Inversion::Template::Tag::TAG_PLUGIN_PATTERN ).
-			and_return([ 'inversion/template/zebratag.rb' ])
+			and_return([ pluginfile ])
 		Inversion::Template::Tag.should_receive( :require ).
-			with( 'inversion/template/zebratag.rb' ).
+			with( 'inversion/template/zebratag' ).
 			and_return {
 				Class.new( Inversion::Template::Tag ) {
 					include Inversion::AbstractClass

data/spec/inversion/template/unlesstag_spec.rb

@@ -32,7 +32,8 @@ describe Inversion::Template::UnlessTag do
 		tag << Inversion::Template::TextNode.new( 'the body' )
 
 		renderstate = Inversion::RenderState.new( :attribute => false )
-		tag.render( renderstate ).to_s.should == 'the body'
+		tag.render( renderstate )
+		renderstate.to_s.should == 'the body'
 	end
 
 	it "renders its contents if its methodchain is false" do
@@ -40,7 +41,8 @@ describe Inversion::Template::UnlessTag do
 		tag << Inversion::Template::TextNode.new( 'the body' )
 
 		renderstate = Inversion::RenderState.new( :attribute => {:bar => 1} )
-		tag.render( renderstate ).to_s.should == 'the body'
+		tag.render( renderstate )
+		renderstate.to_s.should == 'the body'
 	end
 
 	it "doesn't render its contents if its attribute is true" do
@@ -48,7 +50,8 @@ describe Inversion::Template::UnlessTag do
 		tag << Inversion::Template::TextNode.new( 'the body' )
 
 		renderstate = Inversion::RenderState.new( :attribute => true )
-		tag.render( renderstate ).to_s.should == ''
+		tag.render( renderstate )
+		renderstate.to_s.should == ''
 	end
 
 	it "doesn't render its contents if its methodchain is true" do
@@ -56,7 +59,8 @@ describe Inversion::Template::UnlessTag do
 		tag << Inversion::Template::TextNode.new( 'the body' )
 
 		renderstate = Inversion::RenderState.new( :attribute => {:foo => 1} )
-		tag.render( renderstate ).to_s.should == ''
+		tag.render( renderstate )
+		renderstate.to_s.should == ''
 	end
 
 	context "with an 'else' clause" do
@@ -71,12 +75,14 @@ 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 ).to_s.should == 'the body after else'
+			@tag.render( renderstate )
+			renderstate.to_s.should == '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 ).to_s.should == 'the body before else'
+			@tag.render( renderstate )
+			renderstate.to_s.should == 'the body before else'
 		end
 
 	end