inversion 0.0.1

data/spec/inversion/monkeypatches_spec.rb

@@ -0,0 +1,35 @@
+#!/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 'ripper'
+
+require 'rspec'
+require 'spec/lib/helpers'
+
+require 'inversion/monkeypatches'
+
+
+describe Inversion, "monkeypatches" do
+
+	describe Inversion::RipperAdditions 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 ]
+		end
+
+	end
+
+
+end
+

data/spec/inversion/renderstate_spec.rb

@@ -0,0 +1,291 @@
+#!/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 'inversion/renderstate'
+require 'inversion/template/attrtag'
+require 'inversion/template/textnode'
+
+describe Inversion::RenderState do
+
+	before( :all ) 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] )
+	end
+
+
+	it "preserves tainted status when copying its attributes" do
+		attributes = { :danger => "in pants" }
+		attributes[:danger].taint
+
+		state = Inversion::RenderState.new( attributes )
+
+		state.attributes[:danger].should be_tainted()
+	end
+
+
+	it "preserves frozen status when copying its attributes" do
+		attributes = { :danger => "in pants" }
+		attributes[:danger].freeze
+
+		state = Inversion::RenderState.new( attributes )
+
+		state.attributes[:danger].should be_frozen()
+	end
+
+
+	it "preserves singleton methods on attribute objects when copying" do
+		obj = Object.new
+		def obj.foo; "foo!"; end
+
+		state = Inversion::RenderState.new( :foo => obj )
+
+		state.attributes[:foo].singleton_methods.map( &:to_sym ).should include( :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
+
+
+	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'
+	end
+
+	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.with_attributes( :foot => 'ball' ) do
+			state.foot.should == 'ball'
+			state.bear.should == 'in woods'
+		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" }
+
+		state = Inversion::RenderState.new( attributes )
+
+		expect {
+			state.with_attributes( {} ) do
+				raise "Charlie dooo!"
+			end
+		}.to raise_error()
+
+		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 "can override the render destination for the duration of a block" do
+		state = Inversion::RenderState.new
+
+		original_dest = state.destination
+		newdest = []
+		node = Inversion::Template::TextNode.new( "New!" )
+		rval = state.with_destination( newdest ) do
+			state << node
+		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
+
+		expect {
+			state.with_destination( [] ) do
+				raise "New!"
+			end
+		}.to raise_error()
+
+		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
+
+	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
+
+		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 )
+
+		state << node
+
+		state.to_s.should == ''
+	end
+
+	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
+
+		state.to_s.should == ''
+	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 "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
+
+	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
+
+	it "provides accessor methods for its attributes" do
+		state = Inversion::RenderState.new( :bar => :the_attribute_value )
+		state.bar.should == :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.foo.should be_nil()
+	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} )
+
+		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
+
+
+	describe "publish/subscribe:" do
+
+		before( :each ) do
+			@state = Inversion::RenderState.new
+		end
+
+		it "doesn't have any subscriptions by default" do
+			@state.subscriptions.should == {}
+		end
+
+		it "allows an object to subscribe to node publications" do
+			subscriber = Object.new
+
+			@state.subscribe( :the_key, subscriber )
+
+			@state.subscriptions.should have( 1 ).member
+			@state.subscriptions[ :the_key ].should == [ subscriber ]
+		end
+
+	end
+
+end
+

data/spec/inversion/sinatra_spec.rb

@@ -0,0 +1,59 @@
+#!/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'
+
+begin
+	require 'rack/test'
+	require 'inversion/sinatra'
+	$sinatra_support = true
+rescue LoadError => err
+	warn "Sintra support testing disabled: %p: %s" % [ err.class, err.message ]
+	$sinatra_support = false
+end
+
+describe "Sinatra support", :if => $sinatra_support do
+	include Rack::Test::Methods if defined?( ::Rack )
+
+	before( :all ) do
+		setup_logging( :fatal )
+	end
+
+	before( :each ) do
+		@datadir = Pathname( __FILE__ ).dirname.parent + 'data'
+		Sinatra::Base.set :environment, :test
+	end
+
+	def app
+		@app
+	end
+
+	it "extends the Sinatra DSL with an #inversion helper method" do
+		Sinatra::Base.instance_methods.should include( :inversion )
+	end
+
+	it "renders .inversion files in views path" do
+		@app = Sinatra.new( Sinatra::Base ) do
+			set :views, File.dirname( __FILE__ ) + '/../data/sinatra'
+			get '/' do
+				inversion :hello
+			end
+		end
+
+		get '/'
+		last_response.should be_ok
+	    last_response.body.should == 'Hello, Sinatra!'
+	end
+
+end
+

data/spec/inversion/template/attrtag_spec.rb

@@ -0,0 +1,216 @@
+#!/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/attrtag'
+
+describe Inversion::Template::AttrTag do
+
+	before( :all ) do
+		setup_logging( :fatal )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+	describe "parsing" do
+
+		it "can have a simple attribute name" do
+			Inversion::Template::AttrTag.new( 'foo' ).name.should == :foo
+		end
+
+		it "can have an attribute name and a format string" do
+			tag = Inversion::Template::AttrTag.new( '"%0.2f" % foo' )
+			tag.name.should == :foo
+			tag.format.should == '%0.2f'
+		end
+
+		it "raises an exception with an unknown operator" do
+			expect {
+				Inversion::Template::AttrTag.new( '"%0.2f" + foo' )
+			}.to raise_exception( Inversion::ParseError, /expected/ )
+		end
+
+		it "raises an exception if it has more than one identifier" do
+			expect {
+				Inversion::Template::AttrTag.new( '"%0.2f" % [ foo, bar ]' )
+			}.to raise_exception( Inversion::ParseError, /expected/ )
+		end
+
+		it "supports simple <identifier>.<methodname> syntax" do
+			tag = Inversion::Template::AttrTag.new( 'foo.bar' )
+
+			tag.name.should == :foo
+			tag.methodchain.should == '.bar'
+		end
+
+		it "supports index operator (<identifier>.methodname[ <arguments> ]) syntax" do
+			tag = Inversion::Template::AttrTag.new( 'foo.bar[8]' )
+
+			tag.name.should == :foo
+			tag.methodchain.should == '.bar[8]'
+		end
+
+		it "supports index operator (<identifier>[ <arguments> ]) syntax" do
+			tag = Inversion::Template::AttrTag.new( 'foo[8]' )
+
+			tag.name.should == :foo
+			tag.methodchain.should == '[8]'
+		end
+
+		it "supports <identifier>.<methodname>( <arguments> ) syntax" do
+			tag = Inversion::Template::AttrTag.new( 'foo.bar( 8, :baz )' )
+
+			tag.name.should == :foo
+			tag.methodchain.should == '.bar( 8, :baz )'
+		end
+
+		it "can have a format with a methodchain" do
+			tag = Inversion::Template::AttrTag.new( '"%0.02f" % foo.bar( 8 )' )
+
+			tag.name.should == :foo
+			tag.methodchain.should == '.bar( 8 )'
+			tag.format.should == '%0.02f'
+		end
+	end
+
+	describe "rendering" do
+
+		it "can render itself as a comment for template debugging" do
+			tag = Inversion::Template::AttrTag.new( 'foo.bar( 8, :baz )' )
+			tag.as_comment_body.should == "Attr: { template.foo.bar( 8, :baz ) }"
+		end
+
+		context "without a format" do
+
+			before( :each ) do
+				@tag = Inversion::Template::AttrTag.new( 'foo' )
+			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"]
+			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
+			end
+
+			it "returns false when the rendered value is false" do
+				template = stub( "template object", :attributes => { :foo => false } )
+				@tag.render( template ).should equal( false )
+			end
+
+			it "can render itself as a comment for template debugging" do
+				@tag.as_comment_body.should == 'Attr: { template.foo }'
+			end
+
+		end
+
+		context "with a format" do
+
+			before( :each ) do
+				@tag = Inversion::Template::AttrTag.new( 'foo' )
+				@tag.format = "%0.2f"
+			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'
+			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
+			end
+
+			it "can render itself as a comment for template debugging" do
+				@tag.as_comment_body.
+					should == 'Attr: { template.foo } with format: "%0.2f"'
+			end
+
+		end
+
+		context "with a methodchain" do
+
+			before( :each ) do
+				@attribute_object = mock( "template attribute" )
+			end
+
+			it "renders a single method call with no arguments" do
+				template = Inversion::Template.new( 'this is <?attr foo.bar ?>' )
+				template.foo = @attribute_object
+				@attribute_object.should_receive( :bar ).with( no_args() ).and_return( "the result" )
+
+				template.render.should == "this is the result"
+			end
+
+			it "renders a single method call with one argument" do
+				template = Inversion::Template.new( 'this is <?attr foo.bar(8) ?>' )
+				template.foo = @attribute_object
+				@attribute_object.should_receive( :bar ).with( 8 ).and_return( "the result" )
+
+				template.render.should == "this is the result"
+			end
+
+			it "renders a call with a single index operator" do
+				template = Inversion::Template.new( 'lines end with <?attr config[:line_ending] ?>' )
+				template.config = { :line_ending => 'newline' }
+
+				template.render.should == "lines end with newline"
+			end
+
+			it "renders a single method call with multiple arguments" do
+				template = Inversion::Template.new( 'this is <?attr foo.bar(8, :woo) ?>' )
+				template.foo = @attribute_object
+				@attribute_object.should_receive( :bar ).with( 8, :woo ).and_return( "the result" )
+
+				template.render.should == "this is the result"
+			end
+
+			it "renders multiple method calls with no arguments" do
+				additional_object = mock( 'additional template attribute' )
+				template = Inversion::Template.new( 'this is <?attr foo.bar.baz ?>' )
+				template.foo = @attribute_object
+				template.foo.should_receive( :bar ).and_return( additional_object )
+				additional_object.should_receive( :baz ).with( no_args() ).and_return( "the result" )
+
+				template.render.should == "this is the result"
+			end
+
+			it "renders multiple method calls with arguments" do
+				additional_object = mock( 'additional template attribute' )
+				template = Inversion::Template.new( 'this is <?attr foo.bar( 8 ).baz( :woo ) ?>' )
+				template.foo = @attribute_object
+				template.foo.should_receive( :bar ).with( 8 ).and_return( additional_object )
+				additional_object.should_receive( :baz ).with( :woo ).and_return( "the result" )
+
+				template.render.should == "this is the result"
+			end
+		end
+
+	end
+
+end
+
+