inversion 0.12.3 → 0.14.0

data/spec/inversion/template/subscribetag_spec.rb

@@ -1,36 +1,19 @@
 #!/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'
+require_relative '../../helpers'
 
-	$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'
 require 'inversion/template/textnode'
 require 'inversion/template/subscribetag'
 
 describe Inversion::Template::SubscribeTag do
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	it "raises a parse error if the key isn't a simple attribute" do
 		expect {
 			Inversion::Template::SubscribeTag.new( 'a.non-identifier' )
-		}.to raise_exception( Inversion::ParseError, /malformed subscribe/i )
+		}.to raise_error( Inversion::ParseError, /malformed subscribe/i )
 	end
 
 	it "renders the nodes published by an immediate subtemplate with the same key" do
@@ -39,7 +22,7 @@ describe Inversion::Template::SubscribeTag do
 
 		template.subtemplate = subtemplate
 
-		template.render.should == '--a style--(subtemplate)'
+		expect( template.render ).to eq( '--a style--(subtemplate)' )
 	end
 
 	it "renders nodes published by an immediate subtemplate that's rendered before it" do
@@ -48,7 +31,7 @@ describe Inversion::Template::SubscribeTag do
 
 		template.subtemplate = subtemplate
 
-		template.render.should == '--(subtemplate)--a style'
+		expect( template.render ).to eq( '--(subtemplate)--a style' )
 	end
 
 	it "doesn't render anything if there are no publications with its key" do
@@ -57,12 +40,12 @@ describe Inversion::Template::SubscribeTag do
 
 		template.subtemplate = subtemplate
 
-		template.render.should == '----(subtemplate)'
+		expect( template.render ).to eq( '----(subtemplate)' )
 	end
 
 	it "renders a default value if one is supplied" do
 		template = Inversion::Template.new( "<?subscribe not_here || default value! ?>" )
-		template.render.should == "default value!"
+		expect( template.render ).to eq( "default value!" )
 	end
 
 	it "doesn't retain published nodes across renders" do
@@ -71,8 +54,8 @@ describe Inversion::Template::SubscribeTag do
 
 		template.subtemplate = subtemplate
 
-		template.render.should == '--a style--(subtemplate)'
-		template.render.should == '--a style--(subtemplate)'
+		expect( template.render ).to eq( '--a style--(subtemplate)' )
+		expect( template.render ).to eq( '--a style--(subtemplate)' )
 	end
 
 end

data/spec/inversion/template/tag_spec.rb

@@ -1,23 +1,13 @@
 #!/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'
+require_relative '../../helpers'
 
-	$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/tag'
 
 describe Inversion::Template::Tag do
 
 	before( :all ) do
-		setup_logging( :fatal )
 		@real_derivatives = Inversion::Template::Tag.derivatives.dup
 		@real_types = Inversion::Template::Tag.types.dup
 	end
@@ -30,46 +20,43 @@ describe Inversion::Template::Tag do
 	after( :all ) do
 		Inversion::Template::Tag.instance_variable_set( :@derivatives, @real_derivatives )
 		Inversion::Template::Tag.instance_variable_set( :@types, @real_types )
-		reset_logging()
 	end
 
 
 	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 ).
+		expect( Gem ).to receive( :find_files ).
 			with( Inversion::Template::Tag::TAG_PLUGIN_PATTERN ).
 			and_return([ pluginfile ])
-		Inversion::Template::Tag.should_receive( :require ).
-			with( 'inversion/template/zebratag' ).
-			and_return {
-				Class.new( Inversion::Template::Tag ) {
-					def self::name; "ZebraTag"; end
-				}
-			}
+		expect( Inversion::Template::Tag ).to receive( :require ) do |filename|
+			expect( filename ).to eq( 'inversion/template/zebratag' )
+			Class.new( Inversion::Template::Tag ) do
+				def self::name; "ZebraTag"; end
+			end
+		end
 		result = Inversion::Template::Tag.load_all
-		result.should be_a( Hash )
-		result.should have( 1 ).member
-		result.should have_key( :zebra )
-		result[:zebra].should be_a( Class )
-		result[:zebra].should < Inversion::Template::Tag
+		expect( result ).to be_a( Hash )
+		expect( result.size ).to eq( 1 )
+		expect( result ).to have_key( :zebra )
+		expect( result[:zebra] ).to be_a( Class )
+		expect( result[:zebra] ).to be < Inversion::Template::Tag
 	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 ).
+		expect( Gem ).to receive( :find_files ).
 			with( Inversion::Template::Tag::TAG_PLUGIN_PATTERN ).
 			and_return([ pluginfile ])
-		Inversion::Template::Tag.should_receive( :require ).
-			with( 'inversion/template/zebratag' ).
-			and_return {
-				Class.new( Inversion::Template::Tag ) {
-					include Inversion::AbstractClass
-					def self::name; "ZebraTag"; end
-				}
-			}
+		expect( Inversion::Template::Tag ).to receive( :require ) do |filename|
+			expect( filename ).to eq( 'inversion/template/zebratag' )
+			Class.new( Inversion::Template::Tag ) do
+				include Inversion::AbstractClass
+				def self::name; "ZebraTag"; end
+			end
+		end
 		result = Inversion::Template::Tag.load_all
-		result.should be_a( Hash )
-		result.should == {}
+		expect( result ).to be_a( Hash )
+		expect( result ).to eq( {} )
 	end
 
 
@@ -90,7 +77,7 @@ describe Inversion::Template::Tag do
 
 
 		it "can render itself as a comment for template debugging" do
-			@tag.as_comment_body.should == %{Concrete "the body" at line ??, column ??}
+			expect( @tag.as_comment_body ).to eq( %{Concrete "the body" at line ??, column ??} )
 		end
 
 	end

data/spec/inversion/template/textnode_spec.rb

@@ -1,41 +1,24 @@
 #!/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'
+require_relative '../../helpers'
 
-	$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/textnode'
 
 describe Inversion::Template::TextNode do
 
-	before( :all ) do
-		setup_logging( :fatal )
-	end
-
 	before( :each ) do
 		@state = Inversion::RenderState.new
 		@node = Inversion::Template::TextNode.new( "unto thee" )
 	end
 
-	after( :all ) do
-		reset_logging()
-	end
-
 
 	it "renders itself unchanged" do
-		@node.render( @state ).should == "unto thee"
+		expect( @node.render( @state ) ).to eq( "unto thee" )
 	end
 
 	it "renders a brief description when rendered as a comment" do
-		@node.as_comment_body.should == %{Text (9 bytes): "unto thee"}
+		expect( @node.as_comment_body ).to eq( %{Text (9 bytes): "unto thee"} )
 	end
 
 
@@ -47,12 +30,12 @@ describe Inversion::Template::TextNode do
 
 		it "strips the leading newline if :strip_tag_lines is set" do
 			@state.options[:strip_tag_lines] = true
-			@node.render( @state ).should == "\tSome stuff\nAnd some other stuff.\n  "
+			expect( @node.render( @state ) ).to eq( "\tSome stuff\nAnd some other stuff.\n  " )
 		end
 
 		it "renders as-is if :strip_tag_lines is not set" do
 			@state.options[:strip_tag_lines] = false
-			@node.render( @state ).should == @text
+			expect( @node.render( @state ) ).to eq( @text )
 		end
 
 	end
@@ -76,8 +59,9 @@ describe Inversion::Template::TextNode do
 			expected_content = LONGER_CONTENT[0,40].dump
 			expected_content[-1,0] = '...'
 
-			@node.as_comment_body.should ==
-				%Q{Text (488 bytes): "\\t\\t<p>Lorem ipsum dolor sit amet, consect..."}
+			expect(
+				@node.as_comment_body
+			).to eq( %Q{Text (488 bytes): "\\t\\t<p>Lorem ipsum dolor sit amet, consect..."} )
 		end
 
 	end

data/spec/inversion/template/timedeltatag_spec.rb

@@ -1,17 +1,8 @@
 #!/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'
+require_relative '../../helpers'
 
-	$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/timedeltatag'
 
 describe Inversion::Template::TimeDeltaTag do
@@ -32,8 +23,6 @@ describe Inversion::Template::TimeDeltaTag do
 		ENV['TZ'] = 'US/Pacific'
         ENV['TZ'] = 'PST8PDT' if Time.now.utc_offset.zero?
 
-		setup_logging( :fatal )
-
 		@past           = "Fri Aug 20 08:21:35.1876455 -0700 2010"
 		@pasttime       = Time.parse( @past )
 		@pastsecs       = @pasttime.to_i
@@ -49,63 +38,62 @@ describe Inversion::Template::TimeDeltaTag do
 
 	before( :each ) do
 		@tag = Inversion::Template::TimeDeltaTag.new( "foo" )
-		Time.stub( :now ).and_return( @now )
+		allow( Time ).to receive( :now ).and_return( @now )
 	end
 
 	after( :all ) do
-		reset_logging()
 		ENV['TZ'] = @real_tz
 	end
 
 
 	it "renders the attribute as an approximate interval of time if it's a future Time object" do
 		renderstate = Inversion::RenderState.new( :foo => @futuretime )
-		@tag.render( renderstate ).should == "about a day from now"
+		expect( @tag.render( renderstate ) ).to eq( "about a day from now" )
 	end
 
 	it "renders the attribute as an approximate interval of time if it's a past Time object" do
 		renderstate = Inversion::RenderState.new( :foo => @pasttime )
-		@tag.render( renderstate ).should == "about a day ago"
+		expect( @tag.render( renderstate ) ).to eq( "about a day ago" )
 	end
 
 	it "renders the attribute as an approximate interval of time if it's a future Date object" do
 		renderstate = Inversion::RenderState.new( :foo => @futuredate )
-		@tag.render( renderstate ).should == "16 hours from now"
+		expect( @tag.render( renderstate ) ).to eq( "16 hours from now" )
 	end
 
 	it "renders the attribute as an approximate interval of time if it's a past Date object" do
 		renderstate = Inversion::RenderState.new( :foo => @pastdate )
-		@tag.render( renderstate ).should == "2 days ago"
+		expect( @tag.render( renderstate ) ).to eq( "2 days ago" )
 	end
 
 	it "renders the attribute as an approximate interval of time if it's a future DateTime object" do
 		renderstate = Inversion::RenderState.new( :foo => @futuredatetime )
-		@tag.render( renderstate ).should == "about a day from now"
+		expect( @tag.render( renderstate ) ).to eq( "about a day from now" )
 	end
 
 	it "renders the attribute as an approximate interval of time if it's a past DateTime object" do
 		renderstate = Inversion::RenderState.new( :foo => @pastdatetime )
-		@tag.render( renderstate ).should == "about a day ago"
+		expect( @tag.render( renderstate ) ).to eq( "about a day ago" )
 	end
 
 	it "renders the attribute as an approximate interval of time if it's a future String object" do
 		renderstate = Inversion::RenderState.new( :foo => @future )
-		@tag.render( renderstate ).should == "about a day from now"
+		expect( @tag.render( renderstate ) ).to eq( "about a day from now" )
 	end
 
 	it "renders the attribute as an approximate interval of time if it's a past String object" do
 		renderstate = Inversion::RenderState.new( :foo => @past )
-		@tag.render( renderstate ).should == "about a day ago"
+		expect( @tag.render( renderstate ) ).to eq( "about a day ago" )
 	end
 
 	it "renders the attribute as an approximate interval of time if it's a future epoch Numeric" do
 		renderstate = Inversion::RenderState.new( :foo => @futuresecs )
-		@tag.render( renderstate ).should == "about a day from now"
+		expect( @tag.render( renderstate ) ).to eq( "about a day from now" )
 	end
 
 	it "renders the attribute as an approximate interval of time if it's a past epoch Numeric" do
 		renderstate = Inversion::RenderState.new( :foo => @pastsecs )
-		@tag.render( renderstate ).should == "about a day ago"
+		expect( @tag.render( renderstate ) ).to eq( "about a day ago" )
 	end
 
 
@@ -117,97 +105,97 @@ describe Inversion::Template::TimeDeltaTag do
 
 		it "renders a period of a minute or less as 'less than a minute'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 44 )
-			@tag.render( renderstate ).should == "less than a minute from now"
+			expect( @tag.render( renderstate ) ).to eq( "less than a minute from now" )
 		end
 
 		it "renders a period of 58 seconds as 'a minute'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 58 )
-			@tag.render( renderstate ).should == "a minute from now"
+			expect( @tag.render( renderstate ) ).to eq( "a minute from now" )
 		end
 
 		it "renders a period of 60 seconds as 'a minute'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 60 )
-			@tag.render( renderstate ).should == "a minute from now"
+			expect( @tag.render( renderstate ) ).to eq( "a minute from now" )
 		end
 
 		it "renders a period of 68 seconds as 'a minute'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 68 )
-			@tag.render( renderstate ).should == "a minute from now"
+			expect( @tag.render( renderstate ) ).to eq( "a minute from now" )
 		end
 
 		it "renders a period of 93 seconds as '2 minutes'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 93 )
-			@tag.render( renderstate ).should == "2 minutes from now"
+			expect( @tag.render( renderstate ) ).to eq( "2 minutes from now" )
 		end
 
 		it "renders a period of 30 minutes as '30 minutes'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 30 * MINUTES )
-			@tag.render( renderstate ).should == "30 minutes from now"
+			expect( @tag.render( renderstate ) ).to eq( "30 minutes from now" )
 		end
 
 		it "renders a period of 58 minutes as 'about an hour'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 58 * MINUTES )
-			@tag.render( renderstate ).should == "about an hour from now"
+			expect( @tag.render( renderstate ) ).to eq( "about an hour from now" )
 		end
 
 		it "renders a period of 89 minutes as 'about an hour'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 89 * MINUTES )
-			@tag.render( renderstate ).should == "about an hour from now"
+			expect( @tag.render( renderstate ) ).to eq( "about an hour from now" )
 		end
 
 		it "renders a period of 95 minutes as '2 hours'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 95 * MINUTES )
-			@tag.render( renderstate ).should == "2 hours from now"
+			expect( @tag.render( renderstate ) ).to eq( "2 hours from now" )
 		end
 
 		it "renders a period of 17 hours as '17 hours'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 17 * HOURS )
-			@tag.render( renderstate ).should == "17 hours from now"
+			expect( @tag.render( renderstate ) ).to eq( "17 hours from now" )
 		end
 
 		it "renders a period of 20 hours as 'about a day'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 20 * HOURS )
-			@tag.render( renderstate ).should == "about a day from now"
+			expect( @tag.render( renderstate ) ).to eq( "about a day from now" )
 		end
 
 		it "renders a period of 6 days as '6 days'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 6 * DAYS )
-			@tag.render( renderstate ).should == "6 days from now"
+			expect( @tag.render( renderstate ) ).to eq( "6 days from now" )
 		end
 
 		it "renders a period of 11 days as 'about a week'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 11 * DAYS )
-			@tag.render( renderstate ).should == "about a week from now"
+			expect( @tag.render( renderstate ) ).to eq( "about a week from now" )
 		end
 
 		it "renders a period of 18 days as '3 weeks'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 18 * DAYS )
-			@tag.render( renderstate ).should == "3 weeks from now"
+			expect( @tag.render( renderstate ) ).to eq( "3 weeks from now" )
 		end
 
 		it "renders a period of 10 weeks as '10 weeks'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 10 * WEEKS )
-			@tag.render( renderstate ).should == "10 weeks from now"
+			expect( @tag.render( renderstate ) ).to eq( "10 weeks from now" )
 		end
 
 		it "renders a period of 4 months as '4 months'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 4 * MONTHS )
-			@tag.render( renderstate ).should == "4 months from now"
+			expect( @tag.render( renderstate ) ).to eq( "4 months from now" )
 		end
 
 		it "renders a period of 14 months as '14 months'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 14 * MONTHS )
-			@tag.render( renderstate ).should == "14 months from now"
+			expect( @tag.render( renderstate ) ).to eq( "14 months from now" )
 		end
 
 		it "renders a period of 20 months as '2 years'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 20 * MONTHS )
-			@tag.render( renderstate ).should == "2 years from now"
+			expect( @tag.render( renderstate ) ).to eq( "2 years from now" )
 		end
 
 		it "renders a period of 120 years as '120 years'" do
 			renderstate = Inversion::RenderState.new( :foo => @now_epoch + 120 * YEARS )
-			@tag.render( renderstate ).should == "120 years from now"
+			expect( @tag.render( renderstate ) ).to eq( "120 years from now" )
 		end
 
 	end