inversion 0.0.1

data/lib/inversion/template/commenttag.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+# vim: set noet nosta sw=4 ts=4 :
+
+require 'inversion/template/tag'
+require 'inversion/template/containertag'
+
+
+# Inversion 'comment' tag.
+#
+# This tag hides its contents from the rendered output.
+#
+# == Syntax
+#
+#   <?comment ?><?end?>
+#   <?comment Disabled for now ?>
+#      <?attr some_hidden_attribute ?>
+#   <?end comment ?>
+#
+class Inversion::Template::CommentTag < Inversion::Template::Tag
+	include Inversion::Loggable,
+			Inversion::Template::ContainerTag
+
+	######
+	public
+	######
+
+	### Render (or don't render, actually) the comment's subnodes.
+	def render( state )
+		return ''
+	end
+
+
+	### Render the tag as the body of a comment, suitable for template 
+	### debugging.
+	def as_comment_body
+		firstnode, lastnode = self.subnodes.first, self.subnodes.last
+		nodecount = self.subnodes.length
+
+		linedesc = if firstnode.linenum == lastnode.linenum
+				"on line %d" % [ firstnode.linenum ]
+			else
+				"from line %d to %d" % [ firstnode.linenum, lastnode.linenum ]
+			end
+
+		return "Commented out %d nodes %s%s" % [
+			nodecount,
+			linedesc,
+			self.body.empty? ? '' : ': ' + self.body,
+		]
+
+	end
+
+end # class Inversion::Template::CommentTag
+

data/lib/inversion/template/conditionaltag.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+# vim: set noet nosta sw=4 ts=4 :
+
+require 'inversion/template'
+
+# A mixin for a tag that manages conditional rendering of its subnodes.
+module Inversion::Template::ConditionalTag
+
+	### Add conditional instance variables.
+	def initialize( *args ) # :notnew:
+		super
+
+		@rendering_enabled     = false
+		@rendering_was_enabled = false
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Enable rendering of subnodes.
+	def enable_rendering
+		self.log.debug "  enabling rendering."
+		@rendering_enabled = @rendering_was_enabled = true
+	end
+
+
+	### Disable rendering of subnodes.
+	def disable_rendering
+		self.log.debug "  disabling rendering."
+		@rendering_enabled = false
+	end
+
+
+	### Return +true+ if rendering is enabled.
+	def rendering_enabled?
+		return @rendering_enabled
+	end
+
+
+	### Return +true+ if rendering has been enabled since the tag started rendering.
+	def rendering_was_enabled?
+		return @rendering_was_enabled
+	end
+
+
+end # module Inversion::Template::ConditionalTag
+

data/lib/inversion/template/configtag.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+# vim: set noet nosta sw=4 ts=4 :
+
+require 'yaml'
+require 'inversion/mixins'
+require 'inversion/template/tag'
+
+
+# Inversion 'config' tag.
+#
+# A tag that dynamically alters the behavior of the template.
+#
+# == Examples
+#
+#   <?config comment_start: /* ?>
+#   <?config comment_end: */ ?>
+#
+#   <?config
+#       on_render_error: propagate
+#       debugging_comments: true
+#       comment_start: /*
+#       comment_end: */
+#   ?>
+#
+#   <?config { comment_start: "/*", comment_end: "*/" } ?>
+#
+#
+class Inversion::Template::ConfigTag < Inversion::Template::Tag
+	include Inversion::Loggable,
+			Inversion::HashUtilities
+
+
+	### Create a new ConfigTag with the specified +body+.
+	def initialize( body, linenum=nil, colnum=nil )
+		raise Inversion::ParseError, 'Empty config settings' if
+			body.nil? || body.strip.empty?
+
+		opts = YAML.load( body )
+		@options = symbolify_keys( opts )
+
+		super
+	end
+
+
+	######
+	public
+	######
+
+	# The config options that will be modified
+	attr_reader :options
+
+
+	### Override the options in the +parsestate+ when the config is appended to
+	### tree.
+	def before_appending( parsestate )
+		parsestate.options.merge!( self.options )
+	end
+
+end # class Inversion::Template::ConfigTag
+

data/lib/inversion/template/containertag.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+# vim: set noet nosta sw=4 ts=4 :
+
+require 'inversion' unless defined?( Inversion )
+require 'inversion/template' unless defined?( Inversion::Template )
+
+# A mixin for a tag that allows it to contain other nodes.
+module Inversion::Template::ContainerTag
+
+	### Setup subnodes for including classes.  :notnew:
+	def initialize( * )
+		@subnodes = []
+		super
+		yield( self ) if block_given?
+	end
+
+
+	# The nodes the tag contains
+	attr_reader :subnodes
+
+
+	### Append operator: add nodes to the correct part of the parse tree.
+	def <<( node )
+		@subnodes << node
+		return self
+	end
+
+
+	### Tell the parser to expect a matching <?end ?> tag.
+	def is_container?
+		return true
+	end
+	alias_method :container?, :is_container?
+
+
+	### Append the container's subnodes to the +renderstate+.
+	def render_subnodes( renderstate )
+		self.subnodes.each do |node|
+			renderstate << node
+		end
+	end
+
+end # module Inversion::Template::ContainerTag
+
+

data/lib/inversion/template/elsetag.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+# vim: set noet nosta sw=4 ts=4 :
+
+require 'inversion/template/tag'
+
+
+# Inversion 'else' tag.
+#
+# This tag adds a logical switch to an IfTag. If the IfTag's condition was false, 
+# start rendering.
+#
+# == Syntax
+#
+#   <?if attr ?>
+#       ...
+#   <?else ?>
+#       ...
+#   <?end?>
+#
+class Inversion::Template::ElseTag < Inversion::Template::Tag
+	include Inversion::Loggable
+
+
+	### Overridden to default body to nothing, and raise an error if it has one.
+	def initialize( body='', linenum=nil, colnum=nil ) # :notnew:
+		raise Inversion::ParseError, "else can't have a condition" unless body.to_s.strip == ''
+		super
+	end
+
+
+	######
+	public
+	######
+
+
+	### Parsing callback -- check to be sure the node tree can have an
+	### 'else' tag appended to it.
+	def before_appending( parsestate )
+		condtag = parsestate.node_stack.reverse.find do |node|
+			case node
+
+			# If there was a previous 'if' or 'unless', the else belongs to it. Also
+			# allow it to be appended to a 'comment' section so you can comment out an 
+			# else clause
+			when Inversion::Template::IfTag,
+			     Inversion::Template::UnlessTag,
+			     Inversion::Template::CommentTag
+				break node
+
+			# If it's some other kind of container, it's an error
+			when Inversion::Template::ContainerTag
+				raise Inversion::ParseError, "'%s' tags can't have '%s' clauses" %
+					[ node.tagname.downcase, self.tagname.downcase ]
+			end
+		end
+
+		# If there wasn't a valid container, it's an error too
+		raise Inversion::ParseError, "orphaned '%s' tag" % [ self.tagname.downcase ] unless condtag
+	end
+
+end # class Inversion::Template::ElseTag
+

data/lib/inversion/template/elsiftag.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+# vim: set noet nosta sw=4 ts=4 :
+
+require 'inversion/template/attrtag'
+require 'inversion/template/iftag'
+require 'inversion/template/commenttag'
+
+
+# Inversion 'elsif' tag.
+#
+# This tag adds a conditional logical switch to an IfTag. If the IfTag's condition was false, 
+# but the attribute or methodchain of the elsif is true, start rendering.
+#
+# == Syntax
+#
+#   <?if attr ?>
+#       ...
+#   <?elsif attr ?>
+#       ...
+#   <?elsif attr.methodchain ?>
+#       ...
+#   <?end?>
+#
+class Inversion::Template::ElsifTag < Inversion::Template::AttrTag
+	include Inversion::Loggable
+
+	# Inherits AttrTag's tag patterns
+
+	### Parsing callback -- check to be sure the node tree can have an
+	### 'elsif' tag appended to it (i.e., it has an opening 'if' tag).
+	def before_appending( parsestate )
+		condtag = parsestate.node_stack.reverse.find do |node|
+			case node
+			when Inversion::Template::IfTag,
+			     Inversion::Template::CommentTag
+				break node
+			when Inversion::Template::ContainerTag
+				raise Inversion::ParseError, "'%s' tags can't have '%s' clauses" %
+					[ node.tagname.downcase, self.tagname.downcase ]
+			end
+		end
+
+		unless condtag
+			raise Inversion::ParseError, "orphaned '%s' tag" % [ self.tagname.downcase ]
+		end
+	end
+
+end # class Inversion::Template::ElsifTag
+

data/lib/inversion/template/endtag.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+# vim: set noet nosta sw=4 ts=4 :
+
+require 'inversion' unless defined?( Inversion )
+require 'inversion/template' unless defined?( Inversion::Template )
+require 'inversion/template/tag' unless defined?( Inversion::Template::Tag )
+
+# Closing tag class
+class Inversion::Template::EndTag < Inversion::Template::Tag
+	include Inversion::Loggable
+
+
+	### Overridden to provide a default +body+.
+	def initialize( body='', linenum=nil, colnum=nil )
+		super
+		@opener = nil
+	end
+
+
+	######
+	public
+	######
+
+	# The ContainerTag that this end tag closes
+	attr_reader :opener
+
+
+	### Parser callback -- close the given +state+'s currently-open container node.
+	def before_appending( state )
+		@opener = state.pop
+		self.log.debug "End tag for %s at %s" % [ @opener.tagname, @opener.location ]
+
+		# If the end tag has a body, it should match the container that's just
+		# been popped.
+		if self.body &&
+			!self.body.empty? &&
+			self.body.downcase != @opener.tagname.downcase
+
+			raise Inversion::ParseError, "unbalanced end: expected %p, got %p" % [
+				@opener.tagname.downcase,
+				self.body.downcase,
+			]
+		end
+
+		super
+	end
+
+
+	### Render the tag as the body of a comment, suitable for template debugging.
+	def as_comment_body
+		return "End of %s" % [ self.opener.as_comment_body ]
+	end
+
+end # class Inversion::Template::EndTag
+

data/lib/inversion/template/escapetag.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# vim: set noet nosta sw=4 ts=4 :
+
+require 'inversion/template/attrtag'
+
+# Inversion escaping tag.
+#
+# This tag is a derivative of the 'attr' tag that escapes the results of its method call
+# via the format specified in the template config option 'escape_format'.
+#
+# == Syntax
+#
+#   <?escape foo.bar ?>
+#   <?escape "Got <%d> items at <$%0.2f>" % [ line_item.count, line_item.price ] ?>
+#
+class Inversion::Template::EscapeTag < Inversion::Template::AttrTag
+	include Inversion::Escaping
+
+	### Render the method chains against the attributes of the specified +render_state+
+	### and return them.
+	def render( render_state )
+		result = self.escape( super, render_state )
+	end
+
+end # class Inversion::Template::EscapeTag
+

data/lib/inversion/template/fortag.rb

@@ -0,0 +1,120 @@
+#!/usr/bin/env ruby
+# vim: set noet nosta sw=4 ts=4 :
+
+require 'inversion/template/codetag'
+require 'inversion/template/containertag'
+
+
+# Inversion 'for' tag.
+#
+# Iteration tag for outputting a template part for each member of a collection (i.e.,
+# an object that is Enumerable).
+#
+# == Syntax
+#
+#   <?for var in attribute ?>
+#   <?for var in attribute.methodchain ?>
+#   <?for var1, var2 in attribute.methodchain ?>
+#
+#
+# == Examples
+#
+#    <?for employee in company.employees ?>
+#
+#    Hey <?call employee.name ?>! You're fired!
+#
+#    <?end ?>
+#
+class Inversion::Template::ForTag < Inversion::Template::CodeTag
+	include Inversion::Loggable,
+			Inversion::Template::ContainerTag
+
+	# <?for var in attribute ?>
+	# <?for var in attribute.methodchain ?>
+	tag_pattern 'kw sp $(ident) sp $(kw) sp $(ident) $( .* )' do |tag, match|
+		raise Inversion::ParseError, "invalid keyword: expected 'in', got %p for %p" %
+			[ match.string(2), tag.body ] unless match.string(2) == 'in'
+
+		tag.block_args << match.string( 1 ).untaint.to_sym
+		tag.identifiers << match.string( 3 ).untaint.to_sym
+
+		tag.enumerator = match.string( 3 )
+		tag.enumerator << match.string( 4 ) if match.string( 4 )
+	end
+
+
+	# <?for var1, var2, var3 in attribute ?>
+	# <?for var1, var2, var3 in attribute.methodchain ?>
+	tag_pattern 'kw sp $(ident (comma sp? ident)+) sp $(kw) sp $(ident) $( .* )' do |tag, match|
+		raise Inversion::ParseError, "invalid keyword: expected 'in', got %p for %p" %
+			[ match.string(2), tag.body ] unless match.string(2) == 'in'
+
+		tag.block_args += match.string( 1 ).untaint.split(/,\s?/).map( &:to_sym )
+		tag.identifiers << match.string( 3 ).untaint.to_sym
+
+		tag.enumerator = match.string( 3 )
+		tag.enumerator << match.string( 4 ) if match.string( 4 )
+	end
+
+
+
+	### Create a new ForTag with the specified +body+.
+	def initialize( body, linenum=nil, colnum=nil )
+		@block_args = []
+		@enumerator = nil
+
+		super( 'for ' + body, linenum, colnum )
+	end
+
+
+	######
+	public
+	######
+
+	# The array of attribute names that will be assigned to the rendering scope
+	# by the block for each iteration
+	attr_accessor :block_args
+
+	# The attribute or methodchain that yields the enumerable object
+	attr_accessor :enumerator
+
+
+	### Iterate over the enumerator in +state+ and render the tag's
+	### contents for each iteration.
+	def render( state )
+		result = []
+		lvalue = state.eval( self.enumerator ) or return nil
+
+		self.log.debug "Rendering %p via block args: %p" % [ lvalue, self.block_args ]
+
+		lvalue.each do |*args|
+			# Turn the block arguments into an overrides hash by zipping up
+			# the arguments names and values
+			overrides = Hash[ self.block_args.zip(args) ]
+
+			# Overlay the block args from the 'for' over the template attributes and render 
+			# each subnode
+			state.with_attributes( overrides ) do
+				self.subnodes.each do |node|
+					result << node.render( state )
+				end
+			end
+		end
+
+		return result.join
+	end
+
+
+	### Render the tag as the body of a comment, suitable for template debugging.
+	def as_comment_body
+		comment = "%s: { %s IN template.%s }" % [
+			self.tagname,
+			self.block_args.join(', '),
+			self.enumerator
+		]
+
+		return comment
+	end
+
+end # class Inversion::Template::ForTag
+