inversion 1.0.0 → 1.3.1

data/lib/inversion/template/textnode.rb

@@ -1,6 +1,8 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 # vim: set noet nosta sw=4 ts=4 :
 
+require 'inversion/template' unless defined?( Inversion::Template )
 require 'inversion/template/node'
 
 # Inversion text node class -- container for static content in templates between tags.

data/lib/inversion/template/timedeltatag.rb

@@ -1,11 +1,15 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 # vim: set noet nosta sw=4 ts=4 :
 
 require 'uri'
 require 'time'
 require 'date'
+
+require 'inversion/template' unless defined?( Inversion::Template )
 require 'inversion/template/attrtag'
 
+
 # Inversion time delta tag.
 #
 # This tag is a derivative of the 'attr' tag that transforms the results of its method call
@@ -37,6 +41,11 @@ class Inversion::Template::TimeDeltaTag < Inversion::Template::AttrTag
 	def render( renderstate )
 		val = super( renderstate )
 		time = nil
+		omit_decorator = false
+
+		if val.respond_to?( :key )
+			val, omit_decorator = val.values_at( :time, :omit_decorator )
+		end
 
 		if val.respond_to?( :to_time )
 			time = val.to_time
@@ -49,10 +58,14 @@ class Inversion::Template::TimeDeltaTag < Inversion::Template::AttrTag
 		now = Time.now
 		if now > time
 			seconds = now - time
-			return "%s ago" % [ timeperiod(seconds) ]
+			period = timeperiod( seconds )
+			period += ' ago' unless omit_decorator
+			return period
 		else
 			seconds = time - now
-			return "%s from now" % [ timeperiod(seconds) ]
+			period = timeperiod( seconds )
+			period += ' from now' unless omit_decorator
+			return period
 		end
 	end
 

data/lib/inversion/template/unlesstag.rb

@@ -1,7 +1,9 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 # vim: set noet nosta sw=4 ts=4 :
 
 require 'inversion/mixins'
+require 'inversion/template' unless defined?( Inversion::Template )
 require 'inversion/template/attrtag'
 require 'inversion/template/containertag'
 require 'inversion/template/elsetag'
@@ -20,14 +22,40 @@ require 'inversion/template/elsetag'
 class Inversion::Template::UnlessTag < Inversion::Template::AttrTag
 	include Inversion::Template::ContainerTag
 
-	# Inherits AttrTag's tag patterns
+	# Inherit AttrTag's tag patterns first.
+	inherit_tag_patterns
+
+	# Append a 'not' tag matcher.
+	# <?unless ! foo ?>, <?unless !foo ?>
+	tag_pattern '$(op) sp* $(ident)' do |tag, match|
+		op = match.string( 1 )
+		raise Inversion::ParseError, "expected '!', got %p instead" % [ op ] unless op == '!'
+
+		tag.send( :log ).debug "  Identifier is: %p (inverted)" % [ match.string(2) ]
+		tag.name = match.string( 2 ).to_sym
+		tag.inverted = true
+	end
+
+
+	### Create a new UnlessTag.
+	def initialize( body, linenum=nil, colnum=nil )
+		@inverted = false
+		super
+	end
+
+	# Invert the tag's renderstate if created with the 'not' operator.
+	attr_accessor :inverted
+
 
 	### Render the tag's contents if the condition is true, or any else or elsif sections
 	### if the condition isn't true.
 	def render( state )
 
+		evaluated_state = self.evaluate( state )
+		evaluated_state = ! evaluated_state if self.inverted
+
 		# Start out with rendering *disabled* if the tag body evaluates trueishly
-		if self.evaluate( state )
+		if evaluated_state
 			self.log.debug "Initial state was TRUE; disabling rendering"
 			state.disable_rendering
 		else

data/lib/inversion/template/uriencodetag.rb

@@ -1,7 +1,9 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 # vim: set noet nosta sw=4 ts=4 :
 
 require 'uri'
+require 'inversion/template' unless defined?( Inversion::Template )
 require 'inversion/template/attrtag'
 
 # Inversion URL encoding tag.
@@ -14,16 +16,14 @@ require 'inversion/template/attrtag'
 #   <?uriencode foo.bar ?>
 #
 class Inversion::Template::UriencodeTag < Inversion::Template::AttrTag
+	include Inversion::Escaping
 
-	# Unreserved characters from section 2.3 of RFC 3986
-	# ALPHA / DIGIT / "-" / "." / "_" / "~"
-	DEFAULT_ENCODED_CHARACTERS = /[^\w\-\.~]/
 
 	### Render the method chains against the attributes of the specified +render_state+
 	### and return them.
 	def render( render_state )
 		raw = super
-		return URI.encode( raw.to_s, DEFAULT_ENCODED_CHARACTERS )
+		return escape_uri( raw.to_s )
 	end
 
 end # class Inversion::Template::UriencodeTag

data/lib/inversion/template/yieldtag.rb

@@ -1,8 +1,10 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
 # vim: set noet nosta sw=4 ts=4 :
 
 require 'pathname'
 require 'inversion/mixins'
+require 'inversion/template' unless defined?( Inversion::Template )
 require 'inversion/template/tag'
 
 

data/lib/inversion/tilt.rb

@@ -1,4 +1,6 @@
-#!/usr/bin/env ruby
+# -*- ruby -*-
+# frozen_string_literal: true
+# vim: set noet nosta sw=4 ts=4 :
 
 require 'tilt'
 

data/spec/helpers.rb

@@ -5,6 +5,7 @@
 require 'simplecov' if ENV['COVERAGE']
 
 require 'rspec'
+require 'rspec/wait'
 require 'loggability'
 require 'loggability/spechelpers'
 
@@ -44,6 +45,8 @@ RSpec.configure do |c|
 	c.mock_with( :rspec ) do |mock|
 		mock.syntax = :expect
 	end
+	c.wait_timeout = 3
+	c.example_status_persistence_file_path = 'spec/.state'
 
 	c.include( Inversion::SpecHelpers )
 	c.include( Loggability::SpecHelpers )

data/spec/inversion/mixins_spec.rb

@@ -108,7 +108,7 @@ describe Inversion, "mixins" do
 				include Inversion::Escaping
 
 				def render( state )
-					return self.escape( "<something>", state )
+					return self.escape( "</something>", state )
 				end
 			end
 			@obj = objclass.new
@@ -116,18 +116,28 @@ describe Inversion, "mixins" do
 
 		it "adds configurable escaping to including classes" do
 			render_state = Inversion::RenderState.new( {}, :escape_format => :html )
-			expect( @obj.render( render_state ) ).to eq( "&lt;something&gt;" )
+			expect( @obj.render( render_state ) ).to eq( "&lt;/something&gt;" )
 		end
 
 		it "doesn't escape anything if escaping is disabled" do
 			render_state = Inversion::RenderState.new( {}, :escape_format => nil )
-			expect( @obj.render( render_state ) ).to eq( "<something>" )
+			expect( @obj.render( render_state ) ).to eq( "</something>" )
 		end
 
 		it "doesn't escape anything if escaping is set to ':none'" do
 			render_state = Inversion::RenderState.new( {}, :escape_format => :none )
-			expect( @obj.render( render_state ) ).to eq( "<something>" )
+			expect( @obj.render( render_state ) ).to eq( "</something>" )
 		end
+
+		it "supports URI escaping" do
+			render_state = Inversion::RenderState.new( {}, :escape_format => :uri )
+
+			rval = @obj.render( render_state )
+
+			expect( rval.encoding ).to eq( Encoding::US_ASCII )
+			expect( rval ).to eq( "%3C%2Fsomething%3E" )
+		end
+
 	end
 
 
@@ -235,16 +245,6 @@ describe Inversion, "mixins" do
 			expect( copy.default_proc ).to eq( original.default_proc )
 		end
 
-		it "preserves taintedness of copied objects" do
-			original = Object.new
-			original.taint
-
-			copy = Inversion::DataUtilities.deep_copy( original )
-
-			expect( copy ).to_not be( original )
-			expect( copy ).to be_tainted()
-		end
-
 		it "preserves frozen-ness of copied objects" do
 			original = Object.new
 			original.freeze

data/spec/inversion/renderstate_spec.rb

@@ -41,15 +41,6 @@ describe Inversion::RenderState do
 			expect( state.scope[:bear] ).to_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 )
-
-			expect( state.scope[:danger] ).to be_tainted()
-		end
-
 		it "preserves singleton methods on attribute objects when copying" do
 			obj = Object.new
 			def obj.foo; "foo!"; end

data/spec/inversion/template/codetag_spec.rb

@@ -28,6 +28,46 @@ describe Inversion::Template::CodeTag do
 			expect( subclass.tag_patterns.first[1].call(:dummy, :king_dummy) ).to eq( :foo )
 		end
 
-	end
 
+		it "can explicitly declare pattern inheritence" do
+			parentclass = Class.new( Inversion::Template::CodeTag ) do
+				tag_pattern "$(ident)" do |tag, match|
+					:foo
+				end
+			end
+
+			subclass = Class.new( parentclass ) do
+				inherit_tag_patterns
+				tag_pattern "$(op) $(ident)" do |tag, match|
+					:bar
+				end
+			end
+
+			expect( subclass.tag_patterns.size ).to eq( 2 )
+			expect( subclass.tag_patterns.first[0] ).
+				to be_an_instance_of( Inversion::Template::CodeTag::TokenPattern )
+			expect( subclass.tag_patterns.last[0] ).
+				to be_an_instance_of( Inversion::Template::CodeTag::TokenPattern )
+			expect( subclass.tag_patterns.first[1].call(:dummy, :king_dummy) ).to eq( :foo )
+			expect( subclass.tag_patterns.last[1].call(:dummy, :king_dummy) ).to eq( :bar )
+		end
+
+
+		it "throws an error if trying to inherit patterns after they are declared" do
+			parentclass = Class.new( Inversion::Template::CodeTag ) do
+				tag_pattern "$(ident)" do |tag, match|
+					:foo
+				end
+			end
+
+			expect {
+				Class.new( parentclass ) do
+					tag_pattern "$(op) $(ident)" do |tag, match|
+						:bar
+					end
+					inherit_tag_patterns
+				end
+			}.to raise_exception( ScriptError, /patterns already exist/i )
+		end
+	end
 end

data/spec/inversion/template/elsiftag_spec.rb

@@ -58,6 +58,31 @@ describe Inversion::Template::ElsifTag do
 	end
 
 
+	it "inverts its attribute with a ! operator" do
+		template = Inversion::Template.new( <<-END_TEMPLATE )
+		<?if thing ?>
+			Thing!
+		<?elsif ! otherthing ?>
+			Otherthing!
+		<?else ?>
+			Nope.
+		<?end?>
+		END_TEMPLATE
+
+		template.thing = true
+		template.otherthing = true
+		expect( template.render ).to include( "Thing!" )
+
+		template.thing = false
+		template.otherthing = false
+		expect( template.render ).to include( "Otherthing!" )
+
+		template.thing = false
+		template.otherthing = true
+		expect( template.render ).to include( "Nope." )
+	end
+
+
 	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' )

data/spec/inversion/template/fortag_spec.rb

@@ -11,12 +11,12 @@ require 'inversion/renderstate'
 
 describe Inversion::Template::ForTag do
 
-
 	it "knows which identifiers should be added to the template" do
 		tag = Inversion::Template::ForTag.new( 'foo in bar' )
 		expect( tag.identifiers ).to eq( [ :bar ] )
 	end
 
+
 	it "can iterate over single items of a collection attribute" do
 		tag = Inversion::Template::ForTag.new( 'foo in bar' )
 
@@ -24,6 +24,7 @@ describe Inversion::Template::ForTag do
 		expect( tag.enumerator ).to eq( 'bar' )
 	end
 
+
 	it "should render as nothing if the corresponding attribute in the template is unset" do
 		render_state = Inversion::RenderState.new( :bar => nil )
 
@@ -38,6 +39,7 @@ describe Inversion::Template::ForTag do
 		expect( tag.render( render_state ) ).to be_nil()
 	end
 
+
 	it "renders each of its subnodes for each iteration, replacing its " +
 	   "block arguments with the yielded values" do
 		render_state = Inversion::RenderState.new( :bar => %w[monkey goat] )
@@ -54,6 +56,7 @@ describe Inversion::Template::ForTag do
 		expect( render_state.to_s ).to eq( "[monkey][goat]" )
 	end
 
+
 	it "supports nested iterators" do
 		render_state = Inversion::RenderState.new( :tic => [ 'x', 'o'], :tac => ['o', 'x'] )
 
@@ -74,6 +77,7 @@ describe Inversion::Template::ForTag do
 		expect( render_state.to_s ).to eq( "[x, o][x, x][o, o][o, x]" )
 	end
 
+
 	it "supports iterating over a range" do
 
 		# <?for omarker in tic ?><?for imarker in tac ?>
@@ -87,12 +91,14 @@ describe Inversion::Template::ForTag do
 		expect( render_state.to_s ).to eq( "0 1 2 3 4 5 6 7 8 9 10 " )
 	end
 
+
 	it "raises a ParseError if a keyword other than 'in' is used" do
 		expect {
 			Inversion::Template::ForTag.new( 'foo begin bar' )
 		}.to raise_error( Inversion::ParseError, /invalid/i )
 	end
 
+
 	context "multidimensional collections" do
 
 		it "can be expanded into multiple block arguments" do
@@ -103,6 +109,27 @@ describe Inversion::Template::ForTag do
 		end
 
 
+		it "can be expanded by nesting" do
+			tmpl = Inversion::Template.new( <<-"END_TEMPLATE" )
+			<?for outer in numbers ?>
+				-
+				<?for inner in outer ?>
+				:<?attr inner ?>:
+				<?end for ?>
+				-
+			<?end for ?>
+			END_TEMPLATE
+
+			tmpl.numbers = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]]
+			results = ''
+			wait_for { results = tmpl.render }.to be_a( String )
+
+			expect( results ).to match( /-\s+:1:\s+:2:\s+:3:\s*:4:\s+-/ )
+			expect( results ).to match( /-\s+:5:\s+:6:\s+:7:\s*:8:\s+-/ )
+			expect( results ).to match( /-\s+:9:\s+:10:\s+-/ )
+		end
+
+
 		it "can be expanded into multiple block arguments (sans spaces)" do
 			tag = Inversion::Template::ForTag.new( 'splip,splorp,sploop in splap' )
 
@@ -110,6 +137,7 @@ describe Inversion::Template::ForTag do
 			expect( tag.enumerator ).to eq( 'splap' )
 		end
 
+
 		it "can be expanded into multiple block arguments from hash pairs" do
 			tag = Inversion::Template::ForTag.new( 'key, value in splap' )
 
@@ -129,6 +157,7 @@ describe Inversion::Template::ForTag do
 			expect( render_state.to_s ).to eq( '[one translates to uno][two translates to dos]' )
 		end
 
+
 		it "can be expanded into multiple block arguments with complex values" do
 			# [<?attr key?> translates to <?attr value?>]
 			tree = Inversion::Parser.new( nil ).parse( <<-"END_TEMPLATE" )
@@ -153,6 +182,7 @@ describe Inversion::Template::ForTag do
 			expect( render_state.to_s ).to match( /ch \(1\) => ch/ )
 		end
 
+
 		it "preserves an array of subhashes" do
 			tree = Inversion::Parser.new( nil ).parse( <<-"END_TEMPLATE" )
 			<?for subhash in the_hash[:a] ?>
@@ -168,7 +198,7 @@ describe Inversion::Template::ForTag do
 			render_state = Inversion::RenderState.new( :the_hash => the_hash )
 			tree.first.render( render_state )
 
-			expect( render_state.to_s ).to match( /Subhash is a Hash/i )
+			expect( render_state.to_s ).to match( /subhash is a hash.*subhash is a hash/i )
 		end
 
 	end
@@ -245,7 +275,9 @@ describe Inversion::Template::ForTag do
 			</section>
 			END_OUTPUT
 		end
+
 	end
+
 end