inversion 0.0.1

data/spec/inversion/template/uriencodetag_spec.rb

@@ -0,0 +1,49 @@
+#!/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/uriencodetag'
+
+describe Inversion::Template::UriencodeTag do
+
+	before( :all ) do
+		setup_logging( :fatal )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+	before( :each ) do
+		@attribute_object = mock( "template attribute" )
+	end
+
+
+	it "URI encodes the results of rendering" do
+		template = Inversion::Template.new( 'this is<?uriencode foo.bar ?>' )
+		template.foo = @attribute_object
+		@attribute_object.should_receive( :bar ).with( no_args() ).
+			and_return( " 25% Sparta!" )
+
+		template.render.should == "this is%2025%25%20Sparta%21"
+	end
+
+	it "stringifies its content before encoding" do
+		template = Inversion::Template.new( '<?uriencode foo.bar ?> bottles of beer on the wall' )
+		template.foo = @attribute_object
+		@attribute_object.should_receive( :bar ).with( no_args() ).
+			and_return( 99.999 )
+
+		template.render.should == "99.999 bottles of beer on the wall"
+	end
+end

data/spec/inversion/template/yieldtag_spec.rb

@@ -0,0 +1,54 @@
+#!/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/yieldtag'
+
+describe Inversion::Template::YieldTag do
+
+	before( :all ) do
+		setup_logging( :fatal )
+	end
+
+	after( :all ) do
+		reset_logging()
+	end
+
+
+	it "calls the renderstate's block before rendering, and renders as its return value" do
+		tag = Inversion::Template::YieldTag.new
+		renderstate = Inversion::RenderState.new do |state|
+			:return_value
+		end
+		tag.before_rendering( renderstate )
+
+		rendered_output = renderstate.with_destination( [] ) do
+			renderstate << tag
+		end
+
+		rendered_output.should == [ :return_value ]
+	end
+
+	it "renders as nothing if there wasn't a render block" do
+		tag = Inversion::Template::YieldTag.new
+		renderstate = Inversion::RenderState.new
+		tag.before_rendering( renderstate )
+
+		rendered_output = renderstate.with_destination( [] ) do
+			renderstate << tag
+		end
+
+		rendered_output.should == [ nil ]
+	end
+
+end

data/spec/inversion/template_spec.rb

@@ -0,0 +1,269 @@
+#!/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 'stringio'
+
+require 'spec/lib/helpers'
+require 'inversion/template'
+
+describe Inversion::Template do
+
+	before( :all ) do
+		setup_logging( :fatal )
+	end
+
+	it "can be loaded from a String" do
+		Inversion::Template.new( "a template" ).source.should == 'a template'
+	end
+
+	it "renders the source as-is if there are no instructions" do
+		Inversion::Template.new( "a template" ).render.should == 'a template'
+	end
+
+	it "renders when stringified" do
+		Inversion::Template.new( "a template" ).to_s.should == 'a template'
+	end
+
+	it "untaints template content loaded from a file" do
+		content = 'file contents'.taint
+		IO.should_receive( :read ).with( '/tmp/hooowat' ).and_return( content )
+
+		Inversion::Template.load( '/tmp/hooowat' ).source.should_not be_tainted()
+	end
+
+	it "calls before and after rendering hooks on all of its nodes when rendered" do
+		node = double( "fake node" )
+		parentstate = Inversion::RenderState.new( :foo => 'the merged stuff' )
+		tmpl = Inversion::Template.new( '' )
+		tmpl.node_tree << node
+
+		node.should_receive( :before_rendering ).with( an_instance_of(Inversion::RenderState) )
+		node.should_receive( :render ).with( an_instance_of(Inversion::RenderState) )
+		node.should_receive( :after_rendering ).with( an_instance_of(Inversion::RenderState) )
+
+		tmpl.render( parentstate )
+	end
+
+
+	it "passes the block it was rendered with to its RenderState" do
+		node = double( "fake node", :before_rendering => nil, :after_rendering => nil )
+		tmpl = Inversion::Template.new( '' )
+		tmpl.node_tree << node
+
+		renderblock = Proc.new {}
+		node.should_receive( :render ).and_return do |renderstate|
+			renderstate.block.should equal( renderblock )
+		end
+
+		tmpl.render( &renderblock )
+	end
+
+	it "can make an human-readable string version of itself suitable for debugging" do
+		IO.should_receive( :read ).with( '/tmp/inspect.tmpl' ).and_return( '<?attr foo ?>' )
+		tmpl = Inversion::Template.load( '/tmp/inspect.tmpl' )
+		tmpl.inspect.should =~ /Inversion::Template/
+		tmpl.inspect.should =~ %r{/tmp/inspect.tmpl}
+		tmpl.inspect.should =~ /attributes/
+		tmpl.inspect.should =~ /node_tree/
+	end
+
+	it "provides accessors for attributes that aren't identifiers in the template" do
+		tmpl = Inversion::Template.new( '' )
+		tmpl.foo = :bar
+		tmpl.foo.should == :bar
+	end
+
+
+	context "without template paths set" do
+
+		before( :each ) do
+			Inversion::Template.config[:template_paths].clear
+		end
+
+		it "instances can be loaded from an absolute path" do
+			IO.should_receive( :read ).with( '/tmp/hooowat' ).and_return( 'file contents' )
+			Inversion::Template.load( '/tmp/hooowat' ).source.should == 'file contents'
+		end
+
+		it "instances can be loaded from a path relative to the current working directory" do
+			tmplpath = Pathname.pwd + 'hooowat.tmpl'
+			FileTest.should_receive( :exist? ).with( tmplpath.to_s ).and_return( true )
+			IO.should_receive( :read ).with( tmplpath.to_s ).and_return( 'file contents' )
+			Inversion::Template.load( 'hooowat.tmpl' ).source.should == 'file contents'
+		end
+	end
+
+
+	context "with template paths set" do
+
+		before( :each ) do
+			Inversion::Template.config[:template_paths] = [ '/tmp', '/fun' ]
+		end
+
+		after( :each ) do
+			Inversion::Template.config[:template_paths].clear
+		end
+
+		it "instances can be loaded from an absolute path" do
+			FileTest.should_not_receive( :exist? )
+
+			IO.should_receive( :read ).with( '/tmp/hooowat' ).and_return( 'file contents' )
+			Inversion::Template.load( '/tmp/hooowat' ).source.should == 'file contents'
+		end
+
+		it "raises a runtime exception if unable to locate the template" do
+			tmplpath = Pathname.pwd + 'sadmanhose.tmpl'
+
+			FileTest.should_receive( :exist? ).with( '/tmp/sadmanhose.tmpl' ).and_return( false )
+			FileTest.should_receive( :exist? ).with( '/fun/sadmanhose.tmpl' ).and_return( false )
+			FileTest.should_receive( :exist? ).with( tmplpath.to_s ).and_return( false )
+
+			expect {
+				Inversion::Template.load( 'sadmanhose.tmpl' )
+			}.to raise_error( RuntimeError, /unable to find template ".+" within configured paths/i )
+		end
+
+		it "loads template relative to directories in the template_paths" do
+			FileTest.should_receive( :exist? ).with( '/tmp/hooowat.tmpl' ).and_return( false )
+			FileTest.should_receive( :exist? ).with( '/fun/hooowat.tmpl' ).and_return( true )
+			IO.should_receive( :read ).with( '/fun/hooowat.tmpl' ).and_return( 'file contents' )
+
+			Inversion::Template.load( 'hooowat.tmpl' ).source.should == 'file contents'
+		end
+
+		it "falls back to loading the template relative to the current working directory" do
+			tmplpath = Pathname.pwd + 'hooowat.tmpl'
+
+			FileTest.should_receive( :exist? ).with( '/tmp/hooowat.tmpl' ).and_return( false )
+			FileTest.should_receive( :exist? ).with( '/fun/hooowat.tmpl' ).and_return( false )
+			FileTest.should_receive( :exist? ).with( tmplpath.to_s ).and_return( true )
+			IO.should_receive( :read ).with( tmplpath.to_s ).and_return( 'file contents' )
+
+			Inversion::Template.load( 'hooowat.tmpl' ).source.should == 'file contents'
+		end
+	end
+
+
+	context "with an attribute PI" do
+
+		let( :template ) { Inversion::Template.new("<h1><?attr foo ?></h1>") }
+
+
+		it "has a reader for getting the attribute's value" do
+			template.should respond_to( :foo )
+		end
+
+		it "has an accessor for setting the attribute's value" do
+			template.should respond_to( :foo= )
+		end
+
+		it "renders scalar values set for the attribute" do
+			template.foo = "a lion"
+			template.render.should == "<h1>a lion</h1>"
+		end
+
+		it "renders an non-String value set for the attribute using #to_s" do
+			template.foo = [ 'a lion', 'a little guy', 'a bad mousie', 'one birdy' ]
+			template.render.should == %{<h1>a liona little guya bad mousieone birdy</h1>}
+		end
+	end
+
+
+	context "with several attribute PIs" do
+
+		let( :template ) { Inversion::Template.new("<h1><?attr foo ?> <?attr foo?> RUN!</h1>") }
+
+		it "has a reader for getting the attribute's value" do
+			template.should respond_to( :foo )
+		end
+
+		it "has an accessor for setting the attribute's value" do
+			template.should respond_to( :foo= )
+		end
+
+		it "renders scalar values set for the attribute(s)" do
+			template.foo = "lions!!"
+			template.render.should == "<h1>lions!! lions!! RUN!</h1>"
+		end
+	end
+
+
+	describe "Configurability support", :if => defined?( Configurability ) do
+
+		after( :each ) do
+			Inversion::Template.config = Inversion::Template::DEFAULT_CONFIG
+		end
+
+		it "is included in the list of configurable objects" do
+			Configurability.configurable_objects.should include( Inversion::Template )
+		end
+
+		it "can be configured using a Configurability::Config object" do
+			config = Configurability::Config.new( %{
+			---
+			templates:
+			  ignore_unknown_tags: false
+			  debugging_comments: true
+			  comment_start: "#"
+			  comment_end: ""
+			}.gsub(/^\t{3}/, '') )
+
+			Inversion::Template.configure( config.templates )
+
+			Inversion::Template.config[:ignore_unknown_tags].should be_false()
+			Inversion::Template.config[:debugging_comments].should be_true()
+			Inversion::Template.config[:comment_start].should == '#'
+			Inversion::Template.config[:comment_end].should == ''
+
+		end
+
+	end
+
+
+	describe "exception-handling:" do
+
+		before( :each ) do
+			@source = "Some stuff\n<?call obj.raise_exception ?>\nMore stuff"
+			@tmpl = Inversion::Template.new( @source )
+
+			@obj = Object.new
+			def @obj.raise_exception
+				raise "Okay, here's an exception!"
+			end
+
+			@tmpl.obj = @obj
+		end
+
+		it "can be configured to completely ignore exceptions raised while rendering" do
+			@tmpl.options[:on_render_error] = :ignore
+			@tmpl.render.should == "Some stuff\nMore stuff"
+		end
+
+		it "can be configured to insert debugging comments for exceptions raised while rendering" do
+			@tmpl.options[:on_render_error] = :comment
+			@tmpl.render.should ==
+				"Some stuff\n<!-- RuntimeError: Okay, here's an exception! -->More stuff"
+		end
+
+		it "can be configured to propagate exceptions raised while rendering" do
+			@tmpl.options[:on_render_error] = :propagate
+			expect {
+				@tmpl.render
+			}.to raise_exception( RuntimeError, /Okay, here's an exception!/ )
+		end
+
+	end
+
+
+end
+

data/spec/inversion/tilt_spec.rb

@@ -0,0 +1,47 @@
+#!/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 'inversion/tilt'
+	$tilt_support = true
+rescue LoadError => err
+	warn "Tilt support testing disabled: %p: %s" % [ err.class, err.message ]
+	$tilt_support = false
+end
+
+describe "Tilt support", :if => $tilt_support do
+
+	before( :all ) do
+		setup_logging( :fatal )
+	end
+
+	it "registers itself with Tilt" do
+		Tilt['layout.tmpl'].should == Inversion::TiltWrapper
+	end
+
+	it "merges locals with template attributes upon evaluation" do
+		File.stub( :binread ).with( 'test.tmpl' ).and_return( '<?attr foo ?>' )
+		Tilt.new( 'test.tmpl' ).render( Object.new, :foo => 'Booyakasha!' ).should == 'Booyakasha!'
+	end
+
+	it "merges the 'scope' object if it responds_to #to_h" do
+		scope = Object.new
+		def scope.to_h; { :message => "Respek!" }; end
+		File.stub( :binread ).with( 'test.tmpl' ).and_return( '<?attr message ?>' )
+		Tilt.new( 'test.tmpl' ).render( scope, {} ).should == 'Respek!'
+	end
+
+end
+

data/spec/inversion_spec.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env rspec -cfd -b
+# vim: set noet nosta sw=4 ts=4 :
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname( __FILE__ ).dirname.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'
+
+describe Inversion do
+
+	before( :all ) do
+		@original_logger = Inversion.default_logger
+		@original_log_formatter = Inversion.default_log_formatter
+		setup_logging( :fatal )
+	end
+
+	after( :each ) do
+		Inversion.default_logger = @original_logger
+		Inversion.default_log_formatter = @original_log_formatter
+		reset_logging()
+	end
+
+
+	it "defines a version" do
+		Inversion::VERSION.should =~ /^\d+(\.\d+)*$/
+	end
+
+	describe "version methods" do
+
+		it "returns a version string if asked" do
+			Inversion.version_string.should =~ /\w+ [\d.]+/
+		end
+
+		it "returns a version string with a build number if asked" do
+			Inversion.version_string(true).should =~ /\w+ [\d.]+ \(build [[:xdigit:]]+\)/
+		end
+	end
+
+
+	describe " logging subsystem" do
+		before(:each) do
+			Inversion.reset_logger
+		end
+
+		after(:each) do
+			Inversion.reset_logger
+		end
+
+
+		it "knows if its default logger is replaced" do
+			Inversion.reset_logger
+			Inversion.should be_using_default_logger
+			Inversion.logger = Logger.new( $stderr )
+			Inversion.should_not be_using_default_logger
+		end
+
+		it "has the default logger instance after being reset" do
+			Inversion.logger.should equal( Inversion.default_logger )
+		end
+
+		it "has the default log formatter instance after being reset" do
+			Inversion.logger.formatter.should equal( Inversion.default_log_formatter )
+		end
+
+	end
+
+
+	describe " logging subsystem with new defaults" do
+		it "uses the new defaults when the logging subsystem is reset" do
+			logger = double( "dummy logger" )
+			formatter = double( "dummy logger" )
+
+			Inversion.default_logger = logger
+			Inversion.default_log_formatter = formatter
+
+			logger.should_receive( :formatter= ).with( formatter )
+			logger.should_receive( :level= ).with( Logger::WARN )
+
+			Inversion.reset_logger
+			Inversion.logger.should equal( logger )
+		end
+
+	end
+
+
+end
+