inversion 0.0.1

data/spec/inversion/template/importtag_spec.rb

@@ -0,0 +1,106 @@
+#!/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'
+
+	$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/importtag'
+
+describe Inversion::Template::ImportTag do
+
+	before( :all ) do
+		setup_logging( :fatal )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+	it "can import a single attribute" do
+		tag = Inversion::Template::ImportTag.new( 'txn ' )
+		tag.attributes.should == [ :txn ]
+	end
+
+	it "can import multiple attributes" do
+		tag = Inversion::Template::ImportTag.new( 'txn, applet' )
+		tag.attributes.should == [ :txn, :applet ]
+	end
+
+
+	context "with a single attribute name" do
+
+		before( :each ) do
+			@subtemplate = Inversion::Template.new( '<?import foo ?><?attr foo ?>' )
+		end
+
+		it "copies the named value from the enclosing template" do
+			outside = Inversion::Template.new( '<?attr foo ?><?attr subtemplate ?>' )
+			outside.subtemplate = @subtemplate
+			outside.foo = 'Froo'
+
+			outside.render.should == 'FrooFroo'
+		end
+
+		it "doesn't override values set explicitly on the subtemplate" do
+			outside = Inversion::Template.new( '<?attr foo ?><?attr subtemplate ?>' )
+			outside.subtemplate = @subtemplate
+			outside.foo = 'Froo'
+
+			@subtemplate.foo = 'Frar'
+
+			outside.render.should == 'FrooFrar'
+		end
+
+	end
+
+
+	context "with multiple attribute names" do
+
+		before( :each ) do
+			source = '<?import foo, bar ?><?attr foo.capitalize ?>: ' +
+				'<?attr bar.capitalize ?><?attr baz ?>'
+			@subtemplate = Inversion::Template.new( source )
+		end
+
+		it "copies the named value from the enclosing template" do
+			outside = Inversion::Template.new( '<?attr subtemplate ?>' )
+			outside.subtemplate = @subtemplate
+			outside.foo = 'mission'
+			outside.bar = 'accomplished'
+
+			outside.render.should == 'Mission: Accomplished'
+		end
+
+		it "doesn't override values set explicitly on the subtemplate" do
+			outside = Inversion::Template.new( '<?attr subtemplate ?>' )
+			outside.subtemplate = @subtemplate
+			outside.foo = 'mission'
+			outside.bar = 'accomplished'
+
+			@subtemplate.bar = 'abandoned'
+
+			outside.render.should == 'Mission: Abandoned'
+		end
+
+		it "only imports listed attributes" do
+			outside = Inversion::Template.new( '<?attr subtemplate ?>' )
+			outside.subtemplate = @subtemplate
+			outside.foo = 'Attributes'
+			outside.bar = 'Just This One'
+			outside.baz = 'And Not This One'
+
+			outside.render.should == 'Attributes: Just this one'
+		end
+	end
+
+end
+
+

data/spec/inversion/template/includetag_spec.rb

@@ -0,0 +1,108 @@
+#!/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'
+
+	$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 'timeout'
+require 'rspec'
+require 'spec/lib/helpers'
+require 'inversion/template'
+require 'inversion/template/includetag'
+
+describe Inversion::Template::IncludeTag do
+
+	before( :all ) do
+		setup_logging( :fatal )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+
+	it "renders the IncludeTag as an empty string" do
+		included_path = Pathname.pwd + 'included.tmpl'
+		FileTest.stub( :exist? ).with( included_path.to_s ).and_return true
+		IO.stub( :read ).with( included_path.to_s ).and_return( 'there,' )
+
+		tmpl = Inversion::Template.new( "hi <?include included.tmpl ?> handsome!" )
+		tmpl.render.should == "hi there, handsome!"
+	end
+
+
+	it "renders debugging comments with the included template path" do
+		included_path = Pathname.pwd + 'included.tmpl'
+		FileTest.stub( :exist? ).with( included_path.to_s ).and_return true
+		IO.stub( :read ).with( included_path.to_s ).and_return( 'there,' )
+
+		tmpl = Inversion::Template.
+			new( "hi <?include included.tmpl ?> handsome!", :debugging_comments => true )
+		tmpl.render.should =~ /Include "included\.tmpl"/
+	end
+
+
+	it "appends the nodes from a separate template onto the including template" do
+		included_path = Pathname.pwd + 'included.tmpl'
+		FileTest.stub( :exist? ).with( included_path.to_s ).and_return true
+		IO.stub( :read ).with( included_path.to_s ).and_return( 'there,' )
+
+		tmpl = Inversion::Template.new( "hi <?include included.tmpl ?> handsome!" )
+		tmpl.node_tree.should have(4).members
+		tmpl.node_tree[0].should be_a( Inversion::Template::TextNode )
+		tmpl.node_tree[1].should be_a( Inversion::Template::IncludeTag )
+		tmpl.node_tree[2].should be_a( Inversion::Template::TextNode )
+		tmpl.node_tree[3].should be_a( Inversion::Template::TextNode )
+	end
+
+
+	it "allows the same template to be included multiple times" do
+		included_path = Pathname.pwd + 'included.tmpl'
+		FileTest.stub( :exist? ).with( included_path.to_s ).and_return true
+		IO.stub( :read ).with( included_path.to_s ).and_return( ' hi' )
+
+		tmpl = Inversion::Template.
+			new( "hi<?include included.tmpl ?><?include included.tmpl ?> handsome!" )
+		tmpl.render.should == "hi hi hi handsome!"
+	end
+
+
+	it "raises exception on include loops" do
+		included_path = Pathname.pwd + 'included.tmpl'
+		FileTest.stub( :exist? ).with( included_path.to_s ).and_return true
+		IO.stub( :read ).with( included_path.to_s ).and_return( "<?include included.tmpl ?>" )
+
+		expect {
+			Inversion::Template.new( "hi <?include included.tmpl ?> handsome!" )
+		}.to raise_error( Inversion::StackError, /Recursive load .+"included.tmpl"/ )
+	end
+
+
+	it "raises exception on complex include loops" do
+		top_path    = Pathname.pwd + 'top.tmpl'
+		middle_path = Pathname.pwd + 'middle.tmpl'
+		bottom_path = Pathname.pwd + 'bottom.tmpl'
+
+		FileTest.stub( :exist? ).with( top_path.to_s ).and_return true
+		IO.stub( :read ).with( top_path.to_s ).and_return( "<?include middle.tmpl ?>" )
+
+		FileTest.stub( :exist? ).with( middle_path.to_s ).and_return true
+		IO.stub( :read ).with( middle_path.to_s ).and_return( "<?include bottom.tmpl ?>" )
+
+		FileTest.stub( :exist? ).with( bottom_path.to_s ).and_return true
+		IO.stub( :read ).with( bottom_path.to_s ).and_return( "<?include top.tmpl ?>" )
+
+		expect {
+			Inversion::Template.new( "hi <?include top.tmpl ?> handsome!" )
+		}.to raise_error( Inversion::StackError, /Recursive load .+"top.tmpl"/ )
+	end
+end
+
+
+

data/spec/inversion/template/node_spec.rb

@@ -0,0 +1,81 @@
+#!/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'
+
+	$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/node'
+
+describe Inversion::Template::Node do
+
+	let( :concrete_subclass ) { Class.new(Inversion::Template::Node) }
+
+	it "is an abstract class" do
+		expect {
+			Inversion::Template::Node.new( '' )
+		}.to raise_exception( NoMethodError, /private method `new'/i )
+	end
+
+	it "defaults to using inspect to render itself as a comment" do
+		node = concrete_subclass.new( '' )
+		node.as_comment_body.should == node.inspect
+	end
+
+	it "isn't a container" do
+		node = concrete_subclass.new( '' )
+		node.should_not be_a_container()
+	end
+
+	it "knows where it was parsed from if constructed with a position" do
+		node = concrete_subclass.new( '', 4, 12 )
+		node.location.should =~ /line 4, column 12/
+	end
+
+	it "knows that it was created from an unknown location if created without a position" do
+		node = concrete_subclass.new( '' )
+		node.location.should == 'line ??, column ??'
+	end
+
+	it "doesn't raise an exception when the before_appending event callback is called" do
+		state = double( "parser state" )
+		node = concrete_subclass.new( '' )
+		expect {
+			node.before_appending( state )
+		}.to_not raise_error()
+	end
+
+	it "doesn't raise an exception when the after_appending event callback is called" do
+		state = double( "parser state" )
+		node = concrete_subclass.new( '' )
+		expect {
+			node.after_appending( state )
+		}.to_not raise_error()
+	end
+
+	it "doesn't raise an exception when the before_rendering event callback is called" do
+		state = double( "render state" )
+		node = concrete_subclass.new( '' )
+		expect {
+			node.before_rendering( state )
+		}.to_not raise_error()
+	end
+
+	it "doesn't raise an exception when the after_rendering event callback is called" do
+		state = double( "render state" )
+		node = concrete_subclass.new( '' )
+		expect {
+			node.after_rendering( state )
+		}.to_not raise_error()
+	end
+end
+
+
+

data/spec/inversion/template/parser_spec.rb

@@ -0,0 +1,170 @@
+#!/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'
+
+	$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/parser'
+
+describe Inversion::Template::Parser do
+
+	before( :all ) do
+		setup_logging( :fatal )
+		Inversion::Template::Tag.load_all
+	end
+
+	before( :each ) do
+		@template = double( "An Inversion::Template" )
+	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.should have( 1 ).member
+		result.first.should be_a( Inversion::Template::TextNode )
+		result.first.body.should == 'render unto Caesar'
+	end
+
+	it "parses an empty string as a empty tree" do
+		result = Inversion::Template::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 ?>' )
+		}.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.should have( 1 ).member
+		result.first.should be_a( Inversion::Template::AttrTag )
+		result.first.body.should == 'foo'
+	end
+
+	it "parses a single 'attr' tag surrounded by plain text" do
+		result = Inversion::Template::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 )
+	end
+
+	it "ignores unknown tags by default" do
+		result = Inversion::Template::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 ?>'
+	end
+
+	it "can raise exceptions on unknown tags" do
+		expect {
+			Inversion::Template::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 ?>" )
+		}.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" )
+		}.to raise_exception( Inversion::ParseError, /unclosed tag/i )
+	end
+
+
+	describe Inversion::Template::Parser::State do
+
+		before( :each ) do
+			@state = Inversion::Template::Parser::State.new( @template )
+		end
+
+		it "returns the node tree if it's well-formed" do
+			open_tag = Inversion::Template::ForTag.new( 'foo in bar' )
+			end_tag  = Inversion::Template::EndTag.new( 'for' )
+
+			@state << open_tag << end_tag
+
+			@state.tree.should == [ 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
+
+			@state << Inversion::Template::ForTag.new( 'foo in bar' )
+			@state.should_not be_well_formed
+
+			@state << Inversion::Template::EndTag.new( 'for' )
+			@state.should_not be_well_formed
+
+			@state << Inversion::Template::EndTag.new( 'for' )
+			@state.should 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
+		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 )
+			@state << container
+
+			container.should_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 )
+		end
+
+		it "raises an error when the tree is fetched if it isn't well-formed" do
+			open_tag = Inversion::Template::ForTag.new( 'foo in bar' )
+			@state << open_tag
+
+			expect {
+				@state.tree
+			}.to raise_exception( 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 )
+
+			@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 )
+
+			@state << node
+		end
+
+
+	end
+
+end
+