arrow 1.0.7

data/lib/arrow/template/for.rb

@@ -0,0 +1,145 @@
+#!/usr/bin/env ruby
+
+require 'arrow/exceptions'
+require 'arrow/path'
+require 'arrow/template'
+require 'arrow/template/nodes'
+require 'arrow/template/iterator'
+
+# The Arrow::Template::ForDirective class, a derivative of
+# Arrow::Template::BracketingDirective. This is the class which defines the
+# behaviour of the 'for' template directive.
+#
+# == Syntax
+#
+#   <?for <arglist> in <obj>?>...<?end for?>
+#
+# This directive iterates over all the items in an Enumerable object (via the
+# #entities method), rendering the contents once for each object. The specified
+# #<em>arglist</em> is similar to Ruby's argument lists: it supports defaults,
+# as well as array (e.g., <tt>*rest</tt>) and hash arguments.
+#
+# While the contents are rendering, a special attribute named <em>iterator</em>
+# is set to an Arrow::Template::Iterator object, which can be used to get
+# information about the iteration itself. This directive doesn't add anything to
+# the output directly, but relies on its subnodes for content.
+# 
+# This directive only works with Enumerable objects; for other objects with
+# iterators or blocks, use the <?yield?> directive.
+#
+# === Examples
+#
+#  <!-- Iterate over the headers in a request -->
+#  <?for name, value in request.headers_in ?>
+#    <strong><?attr name?>:</strong> <?attr value?><br/>
+#  <?end for?>
+#
+#  <!-- Same thing, but this time in a table with alternating styles for each
+#       row. -->
+#  <table>
+#  <?for name, value in request.headers_in ?>
+#  <?if iterator.even? ?>
+#    <tr class="even-row">
+#  <?else?>
+#    <tr class="odd-row">
+#  <?end if?>
+#      <td><?attr name?></td> <td><?attr value?></td>
+#    </tr>
+#  <?end for?>
+#  </table>
+#
+#  <!-- Pair up words with their lengths and sort them shortest first, then
+#       print them out with their lengths -->
+#  <?for word, length in tests.
+#        collect {|item| [item, item.length]}.
+#        sort_by {|item| item[1]} ?>
+#  	<?attr word?>: <?attr length?>
+#  <?end for?>
+#
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# Please see the file LICENSE in the top-level directory for licensing details.
+#
+class Arrow::Template::ForDirective < Arrow::Template::BracketingDirective # :nodoc:
+	include Arrow::Template::Parser::Patterns
+
+	# The regexp for matching the 'in' part of the directive
+	IN = WHITESPACE + /in/i + WHITESPACE
+
+
+	#############################################################
+	###	I N S T A N C E   M E T H O D S
+	#############################################################
+
+	### Create a new Arrow::Template::ForDirective object.
+	def initialize( body, parser, state )
+		@args = []
+		@pureargs = []
+		super
+	end
+
+
+	######
+	public
+	######
+
+	# The argument list for the iterator, with sigils and defaults, if any.
+	attr_reader :args
+
+	# The argument list for the iterator, with any sigils and defaults
+	# stripped away.
+	attr_reader :pureargs
+
+
+	#########
+	protected
+	#########
+
+	### Parse the contents of the directive.
+	def parse_directive_contents( parser, state )
+		@args, @pureargs = parser.scan_for_arglist( state )
+		return nil unless @args
+
+		state.scanner.skip( IN ) or
+			raise Arrow::ParseError, "no 'in' for 'for'"
+
+		super
+	end
+
+
+	### Render the directive's bracketed nodes once for each item in the
+	### iterated content.
+	def render_subnodes( attribute, template, scope )
+		res = []
+
+		iterator = Arrow::Template::Iterator.new( attribute )
+		iterator.each {|iter,*blockArgs|
+			#self.log.debug "[FOR] Block args are: %p" % [ blockArgs ]
+
+			# Make an attributes hash from the pure args of left side of the
+			# 'for'.
+			attributes = {}
+			blockArgs.zip( self.pureargs ) {|pair|
+				attributes[ pair[1] ] = pair[0]
+			}
+			attributes['iterator'] = iter
+
+			# Process the nodes inside the 'for' block with the args being
+			# overridden.
+			#self.log.debug "  [FOR] calling into new scope with overridden " +
+			#	"attributes: %p" % [ attributes ]
+			template.with_overridden_attributes( scope, attributes ) {|template|
+				res << template.render( @subnodes, scope )
+			}
+		}
+
+		return *res
+	end
+
+
+
+end # class Arrow::Template::ForDirective
+
+

data/lib/arrow/template/if.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+require 'arrow/template'
+require 'arrow/template/nodes'
+
+# The Arrow::Template::IfDirective class, a derivative of
+# Arrow::Template::BracketingDirective. Instances of this class represent a
+# section of a template that is rendered conditionally.
+#
+# The formats the directive supports are:
+#
+#   <?if <name>?>...<?end if?>
+#   <?if <name>.<methodchain>?>...<?end if?>
+#   <?if <name> (matches|=~) <regex>?>...<?end if?>
+#   <?if <name>.<methodchain> (matches|=~) <regex>?>...<?end if?>
+# 
+# Note that this directive does not support all possible Ruby expressions in the
+# conditional, and must have a valid associated identifier (the <em>name</em>
+# bit).
+#
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# Please see the file LICENSE in the top-level directory for licensing details.
+#
+class Arrow::Template::IfDirective < Arrow::Template::BracketingDirective # :nodoc:
+	include Arrow::Template::ConditionalDirective
+
+	require 'arrow/template/else'
+	require 'arrow/template/elsif'
+
+
+	#############################################################
+	###	I N S T A N C E   M E T H O D S
+	#############################################################
+
+	#########
+	protected
+	#########
+
+	### Render the contents of the conditional if it evaluates to +true+, or
+	### the nodes after 'elsif' or 'else' subnodes if their conditions are
+	### met.
+	def render_contents( template, scope )
+		cond = hasBeenTrue = self.evaluate( template, scope )
+
+		nodes = []
+		
+		# Now splice out the chunk of nodes that should be rendered based on
+		# the conditional.
+		@subnodes.each do |node|
+			case node
+			when Arrow::Template::ElsifDirective
+				if !hasBeenTrue
+					cond = hasBeenTrue = node.evaluate( template, scope )
+				else
+					cond = false
+				end
+
+			when Arrow::Template::ElseDirective
+				if !hasBeenTrue
+					cond = hasBeenTrue = true
+				else
+					cond = false
+				end
+
+			else
+				nodes.push( node ) if cond
+			end
+		end
+
+		return template.render( nodes, scope )
+	end
+
+
+
+end # class Arrow::Template::IfDirective

data/lib/arrow/template/import.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+
+require 'arrow/template/nodes'
+require 'arrow/template/parser'
+
+# The Arrow::Template::ImportDirective class, a derivative of
+# Arrow::Template::Directive. This is the class which defines the behaviour of
+# the 'import' template directive.
+#
+# === Syntax
+#
+#   <?import foo?>
+#   <?import foo as superfoo?>
+#	<?import foo, bar?>
+#	<?import foo as superfoo, bar, baz as bazish?>
+# 
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# Please see the file LICENSE in the top-level directory for licensing details.
+#
+class Arrow::Template::ImportDirective < Arrow::Template::Directive # :nodoc:
+	include Arrow::Template::Parser::Patterns
+
+	# SVN Revision
+	SVNRev = %q$Rev$
+	
+	# SVN Id
+	SVNId = %q$Id$
+	
+	# Various patterns
+	SIMPLEIMPORT = CAPTURE[ IDENTIFIER ]
+	ALIASIMPORT = CAPTURE[ IDENTIFIER ] + /\s+as\s+/i + CAPTURE[ IDENTIFIER ]
+
+
+	#############################################################
+	###	C L A S S   M E T H O D S
+	#############################################################
+	
+	### Disallow formats
+	def self::allows_format?; false; end
+
+
+	#############################################################
+	###	I N S T A N C E   M E T H O D S
+	#############################################################
+	
+	### Create a new ImportDirective object.
+	def initialize( type, parser, state )
+		@imports = {}
+		super
+	end
+
+
+	######
+	public
+	######
+
+	# An Array of Regexp objects which match the names of attributes to be
+	# imported.
+	attr_reader :patterns
+
+
+	### Add the imported attributes when this node is rendered.
+	def render( template, scope )
+		imports = []
+
+		if (( st = template._enclosing_template ))
+			@imports.each do |source,dest|
+				imports << "%s as %s (%p)" %
+					[ source, dest, st._attributes[source] ]
+				template._attributes[dest] = st._attributes[source]
+			end
+		end
+
+		if template._config[:debuggingComments]
+			return template.render_comment( "Importing: " + imports.join(", ") )
+		else
+			return ''
+		end
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Parse the contents of the directive.
+	def parse_directive_contents( parser, state )
+		super
+
+		state.scanner.skip( WHITESPACE )
+		#self.log.debug "Scanning for tag middle at: '%20s'" % state.scanner.rest
+
+		body = state.scanner.scan( state.tag_middle ) or return nil
+		#self.log.debug "Found body = %p" % body
+
+		body.strip.split( /\s*,\s*/ ).each do |import|
+			#self.log.debug "Parsing import: %p" % import
+			case import
+			when ALIASIMPORT
+				@imports[ $1 ] = $2
+				#self.log.debug "Alias import: %s => %s" % 
+				#	[ $1, $2 ]
+
+			when SIMPLEIMPORT
+				@imports[ $1 ] = $1
+				#self.log.debug "Simple import: %s" % $1
+
+			else
+				raise Arrow::ParseError, "Failed to parse body: %p" % body
+			end
+		end
+
+		return true
+	end
+
+end # class Arrow::Template::ImportDirective

data/lib/arrow/template/include.rb

@@ -0,0 +1,206 @@
+#!/usr/bin/env ruby
+
+require 'arrow/exceptions'
+require 'arrow/path'
+require 'arrow/template/nodes'
+
+# The Arrow::Template::IncludeDirective class, a derivative of
+# Arrow::Template::Directive. This is the class which defines the
+# behaviour of the 'include' template directive.
+# 
+# == Syntax
+#
+#   <!-- Include a subtemplate directly -->
+#   <?include subtemplate.tmpl ?>
+#
+#   <!-- Include a subtemplate as a callable sub-entity -->
+#   <?include subtemplate.tmpl as sub ?>
+#
+# == Example
+# If 'subtemplate.tmpl' contains:
+#   <?attr foo?>
+# and the main template contains:
+#   <?include subtemplate.tmpl?>
+#   <?include subtemplate.tmpl as sub?>
+# and the code (+template+ is the Template object) looks like:
+#   template.foo = "argle"
+#   template.sub.foo = "bargle"
+# the template will render as:
+#   argle
+#   bargle
+#
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# Please see the file LICENSE in the top-level directory for licensing details.
+#
+class Arrow::Template::IncludeDirective < Arrow::Template::Directive # :nodoc:
+	include Arrow::Template::Parser::Patterns
+
+	# SVN Revision
+	SVNRev = %q$Rev$
+	
+	# SVN Id
+	SVNId = %q$Id$
+	
+
+
+	#############################################################
+	###	I N S T A N C E   M E T H O D S
+	#############################################################
+
+	### Initialize a new IncludeDirective object.
+	def initialize( type, parser, state ) # :notnew:
+		@nodes			= nil
+		@identifier		= nil
+		@subtemplate	= nil
+
+		state[:includeStack] ||= []
+		super
+	end
+
+
+	######
+	public
+	######
+
+	# The identifier associated with an include that has an 'as <name>'
+	# part.
+	attr_accessor :identifier
+	alias_method :name, :identifier
+	alias_method :name=, :identifier=
+
+	# The template object associated with an include that has an 'as <name>'
+	# part.
+	attr_accessor :subtemplate
+
+
+	### Add the nodes that were included to the given +template+ object.
+	def add_to_template( template )
+		#self.log.debug "Installing an include's subnodes"
+
+		if @identifier
+			template.install_node( self )
+			template.send( "#{@identifier}=", @subtemplate )
+			targetTemplate = @subtemplate
+		else
+			targetTemplate = template
+		end
+
+		@nodes.each do |node|
+			targetTemplate.install_node( node )
+		end
+	end
+
+
+	### Render the include.
+	def render( template, scope )
+		rary = super
+
+		# Render the included nodes
+		if @subtemplate
+			#self.log.debug "Rendering an include's subtemplate"
+			rary.push( *(@subtemplate.render) )
+		else
+			#self.log.debug "Rendering an include's subnodes"
+			rary.push( *(template.render( @nodes, scope )) )
+		end
+
+		return rary
+	end
+
+
+	### Return an HTML fragment that can be used to represent the node
+	### symbolically in a web-based introspection interface.
+	def to_html
+		nodeclass = self.css_class
+
+		if @subtemplate
+			subtree = @subtemplate._syntax_tree
+			html = ''
+			html << %q{<strong>#%s</strong> } % @identifier
+			html <<
+				%q{<div class="node-subtemplate %s-node-subtemplate">
+				<div class="node-subtemplate-head %s-node-subtemplate-head"
+				>Subtemplate</div>%s</div>} % [
+					nodeclass, nodeclass,
+					subtree.collect {|node| node.to_html}.join(''),
+				]
+
+			super { html }
+		else
+			super {
+				%q{<div class="node-subtree %s-node-subtree">
+				<div class="node-subtree-head %s-node-subtree-head"
+				>Subnodes</div>%s</div>} % [
+					nodeclass, nodeclass,
+					@nodes.collect {|node| node.to_html}.join
+				]
+			}
+		end
+	end
+
+
+	#########
+	protected
+	#########
+	
+	### Parse the contents of the directive, loading the specified file into
+	### the scanner, if possible.
+	def parse_directive_contents( parser, state )
+		filename = parser.scan_for_pathname( state ) or
+			raise Arrow::ParseError, "No filename found for 'include'"
+		filename.untaint
+
+		state.scanner.skip( WHITESPACE )
+		if state.scanner.scan( /\bas\b/i )
+			@identifier = parser.scan_for_identifier( state )
+		end
+
+		# Try to do the include. Handle errors ourselves since this happens
+		# during parse time.
+		begin
+			#self.log.debug "Include stack is: ", state[:includeStack]
+
+			# Catch circular includes
+			if state[:includeStack].include?( filename )
+				raise Arrow::TemplateError, "Circular include: %s -> %s" %
+					[ state[:includeStack].join(" -> "), filename ]
+
+			# Parse the included file into nodes, passing the state from
+			# the current parse into the subparse.
+			else
+				initialData = state.data.dup
+				initialData[:includeStack].push filename
+				
+				load_path = state.template._load_path
+				#self.log.debug "Load path from including template is: %p" %
+				#	load_path
+				path = Arrow::Template.find_file( filename, load_path )
+				content = File.read( path )
+				content.untaint
+
+				#self.log.debug "initialData is: %p" % initialData
+				@nodes = parser.parse( content, state.template, initialData )
+				initialData[:includeStack].pop
+			end
+
+		# Some errors just turn into comment nodes
+		# :TODO: Make this configurable somehow?
+		rescue Arrow::TemplateError, IOError => err
+			msg = "#{err.class.name}: Include #{filename}: #{err.message}"
+			@nodes = [ Arrow::Template::CommentNode.new(msg) ]
+		end
+
+		# If the directive has an "as <id>" part, create the subtemplate
+		# that will be associated with that identifier.
+		if @identifier
+			@subtemplate = Arrow::Template.new( @nodes, state.template._config )
+		end
+
+		return true
+	end
+
+
+end # class Arrow::Template::IncludeDirective