arrow 1.0.7

data/lib/arrow/template/prettyprint.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require 'arrow/exceptions'
+require 'arrow/path'
+require 'arrow/template/call'
+
+require 'pp'
+
+# The Arrow::Template::PrettyPrintDirective class, a
+# derivative of Arrow::Template::CallDirective. This is the class which
+# defines the behaviour of the 'prettyprint' template directive, which
+# prettyprints and HTML-escapes its associated attribute/s.
+# 
+# == Syntax
+#
+#   <pre><?prettyprint object ?></pre>
+#
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# Please see the file LICENSE in the top-level directory for licensing details.
+#
+class Arrow::Template::PrettyPrintDirective < Arrow::Template::CallDirective # :nodoc:
+
+	# SVN Revision
+	SVNRev = %q$Rev$
+	
+	# SVN Id
+	SVNId = %q$Id$
+	
+	
+	### Render the content and return it as prettyprinted text.
+	def render( template, scope )
+		rawary = super
+		rary = []
+
+		rawary.each do |item|
+			ppstring = ''
+			PP.pp( item, ppstring )
+			
+			rary << ppstring.
+				gsub( /&/, '&amp;' ).
+				gsub( /</, '&lt;' ).
+				gsub( />/, '&gt;' )
+		end
+		
+		return rary
+	end
+
+end # class Arrow::Template::PrettyPrint
+
+

data/lib/arrow/template/render.rb

@@ -0,0 +1,191 @@
+#!/usr/bin/env ruby
+
+require 'arrow/template/nodes'
+require 'arrow/template/parser'
+
+# The Arrow::Template::RenderDirective class, a derivative of
+# Arrow::Template::Directive. This is the class which defines the
+# behaviour of the 'render' template directive.
+# 
+# === Syntax
+#
+#	<?render foo as bar in baz.tmpl ?>
+# 
+# == VCS Id
+# 
+# $Id$
+# 
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# Please see the file LICENSE in the top-level directory for licensing details.
+#
+class Arrow::Template::RenderDirective < Arrow::Template::AttributeDirective # :nodoc:
+	include Arrow::Template::Parser::Patterns
+
+
+	# Parse tokens
+	AS = /\s+as\s+/i
+	IN = /in/i
+
+
+	#############################################################
+	###	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 RenderDirective object.
+	def initialize( type, parser, state )
+		@target = nil
+		@subtemplate = nil
+
+		state[:templateCache] ||= {}
+
+		super
+	end
+
+
+	######
+	public
+	######
+
+	# An Array of Regexp objects which match the names of attributes to be
+	# rendered.
+	attr_reader :subtemplate
+
+
+	### Return a human-readable version of the object suitable for debugging
+	### messages.
+	def inspect
+		%Q{<%s %s%s as %s in %s>} % [
+			@type.capitalize,
+			@name,
+			@methodchain.strip.empty? ? "" : "." + @methodchain,
+			@target,
+			@subtemplate._file,
+		]
+	end
+
+
+
+	#########
+	protected
+	#########
+
+	### Parse the contents of the directive.
+	def parse_directive_contents( parser, state )
+		scanner = state.scanner
+
+		@name = parser.scan_for_identifier( state, true ) or
+			raise Arrow::ParseError, "missing or malformed identifier"
+
+		# If there's an infix operator, the rest of the tag up to the 'as' is
+		# the methodchain. Can't use the parser's
+		# #scan_for_methodchain because it just scans the rest of the tag.
+		if scanner.scan( INFIX )
+			# If the 'infix' was actually the left side of an index operator,
+			# include it in the methodchain.
+			start = scanner.matched == "[" ? scanner.pos - 1 : scanner.pos
+
+			# Find the end of the methodchain
+			# :FIXME: This will screw up if the methodchain itself has an ' as ' in it.
+			scanner.scan_until( AS ) or
+				raise Arrow::ParseError, "invalid render tag: no 'as' found"
+
+			# StringScanner#pre_match is broken, so we have to do the equivalent
+			# ourselves.
+			offset = scanner.pos - scanner.matched.length - 1
+			@methodchain = scanner.string[ start..offset ]
+
+		# No methodchain
+		else
+			scanner.scan_until( AS ) or
+				raise Arrow::ParseError, "invalid render tag: no 'as' found"
+			@methodchain = ''
+			self.log.debug "No methodchain parsed"
+		end
+
+		# Parse the target identifier
+		@target = parser.scan_for_identifier( state ) or
+			raise Arrow::ParseError, "missing or malformed target identifier"
+		self.log.debug "Parsed target identifier: %p" % [@target]
+
+		# Skip over the ' in ' bit
+		scanner.skip( WHITESPACE )
+		scanner.skip( IN ) or
+			raise Arrow::ParseError, "invalid render tag: no 'in'"
+		scanner.skip( WHITESPACE )
+
+		# Parse the filename of the subtemplate to load
+		filename = parser.scan_for_pathname( state ) or
+			raise Arrow::ParseError, "No filename found for 'render'"
+		filename.untaint
+		self.log.debug "Parsed subtemplate filename: %p" % [filename]
+
+		# Load and parse the subtemplate
+		@subtemplate = self.loadSubtemplate( filename, parser, state )
+		self.log.debug "Subtemplate set to: %p" % [@subtemplate]
+
+		return true
+	end
+
+
+	### Render the directive's value via the specified attribute in the delegate
+	### template.
+	def render_contents( template, scope )
+		data = super
+
+		@subtemplate.send( "#{@target}=", data )
+		self.log.debug "Rendering %p" % [@subtemplate]
+		return @subtemplate.render( nil, scope, template )
+	end
+
+
+	### Load and parse a subtemplate from the given filename using the specified
+	### parser.
+	def loadSubtemplate( filename, parser, state )
+		nodes = nil
+		load_path = state.template._load_path
+		path = Arrow::Template.find_file( filename, load_path )
+		subtemplate = nil
+
+		# If the template has already been loaded, just reuse the nodelist
+		state.data[:loadCache] ||= {}
+		if state.data[:loadCache].include?( path )
+			self.log.debug "Re-using cache template instance for %p" % path
+			subtemplate = state.data[:loadCache][ path ]
+
+		else
+			# Load the content of the file and untaint it
+			self.log.debug "Loading %p for the first time" % path
+			content = File.read( path )
+			content.untaint
+
+			# Load a blank template object, cache it, then parse the content
+			# into nodes and install the resulting syntax tree in the
+			# template. The template object is created before parsing so that
+			# recursive renders work.
+			initialData = state.data.dup
+			subtemplate = initialData[:loadCache][ path ] = Arrow::Template.new()
+			nodes = parser.parse( content, state.template, initialData )
+			subtemplate.install_syntax_tree( nodes )
+		end
+
+		return subtemplate
+	rescue Arrow::TemplateError, ::IOError => err
+		msg = "#{err.class.name}: Render with #{filename}: #{err.message}"
+		@nodes = [ Arrow::Template::CommentNode.new(msg) ]
+	end
+
+
+end # class Arrow::Template::RenderDirective
+
+

data/lib/arrow/template/selectlist.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+require 'arrow/exceptions'
+require 'arrow/path'
+require 'arrow/template/nodes'
+
+# The Arrow::Template::SelectListDirective class, a derivative of
+# Arrow::Template::AttributeDirective. This is the class which defines the
+# behaviour of the 'selectlist' template directive.
+#
+# == Syntax
+#
+#   <?selectlist categories ?><?end?>
+#   <?selectlist category FROM categories ?><?end?>
+#   <?selectlist category FROM categories.sort_by {|c| c.name } ?><?end?>
+#
+# == VCS Id
+# 
+# $Id$
+# 
+# == Authors
+# 
+# * Michael Granger <mgranger@rubycrafters.com>
+# 
+# Please see the file LICENSE in the top-level directory for licensing details.
+#
+class Arrow::Template::SelectListDirective < Arrow::Template::BracketingDirective
+	include Arrow::Template::Parser::Patterns
+
+	# SVN Revision
+	SVNRev = %q$Rev$
+	
+	# SVN Id
+	SVNId = %q$Id$
+
+	NAMEDLIST = CAPTURE[ IDENTIFIER ] + /\s+from\s+/i
+
+
+	### This directive doesn't allow formatting.
+	def self::allows_format?
+		false
+	end
+	
+	
+	### Create a new Arrow::Template::SelectListDirective object.
+	def initialize( body, parser, state )
+		@select_name = nil
+		super
+	end
+
+
+	######
+	public
+	######
+
+	attr_reader :select_name
+	
+	
+
+	#########
+	protected
+	#########
+
+	### Parse the contents of the directive
+	def parse_directive_contents( parser, state )
+		state.scanner.skip( WHITESPACE )
+		
+		if state.scanner.scan( NAMEDLIST )
+			@select_name = state.scanner[1]
+		end
+
+		super
+
+		return true
+	end
+	
+
+	### Render the directive's bracketed nodes once for each item in the
+	### iterated content.
+	def render_subnodes( attribute, template, scope )
+		res = []
+
+		res << %{<select name="%s">\n} % [ self.select_name || self.name ]
+		attribute.each do |attrib|
+			res << %{  <option value="%s">%s</option>\n} % [ attrib, attrib ]
+		end
+		res << %{</select>\n}
+
+		return *res
+	end
+	
+
+end # class Arrow::Template::SelectListDirective
+

data/lib/arrow/template/set.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+require 'arrow/template/nodes'
+
+# The Arrow::Template::SetDirective class, a derivative of
+# Arrow::Template::Directive. This is the class which defines the behaviour of
+# the 'set' template directive.
+# 
+# == Syntax
+#
+#   <?set foo 1?>
+#
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# Please see the file LICENSE in the top-level directory for licensing details.
+#
+class Arrow::Template::SetDirective < Arrow::Template::Directive # :nodoc:
+
+	# SVN Revision
+	SVNRev = %q$Rev$
+	
+	# SVN Id
+	SVNId = %q$Id$
+	
+
+	### Create and return a new Arrow::Template::SetDirective object.
+	def initialize( type, parser, state )
+		@name = nil
+		@value = nil
+
+		super
+	end
+
+
+	######
+	public
+	######
+
+	# The name of the definition set by this directive.
+	attr_reader :name
+
+	# The raw (unevaluated) value of the definition
+	attr_reader :value
+
+
+	### Render the directive. This adds the defined variable to the
+	### +template+'s rendering +scope+ and returns an empty string (or a
+	### comment if +:debuggingComments+ is turned on in the template.
+	def render( template, scope )
+		rval = super
+
+		self.log.debug "Evaling <%s> for 'set' directive." % @value
+		template[@name] = eval( @value, scope.get_binding, __FILE__, __LINE__ )
+
+		if template._config[:debuggingComments]
+			rval << template.render_comment( "Set '%s' to '%s'" %
+				[ @name, template[@name] ] )
+		end
+
+		return rval
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Parse the contents of the directive.
+	def parse_directive_contents( parser, state )
+		@name = parser.scan_for_identifier( state )
+
+		state.scanner.skip( /\s*=\s*/ )
+
+		@value = parser.scan_for_identifier( state ) ||
+			parser.scan_for_quoted_string( state ) or
+			raise Arrow::ParseError, "No value for 'set' directive"
+
+		if (( chain = parser.scan_for_methodchain(state) ))
+			@value << chain
+		end
+	end
+
+end # class Arrow::Template::SetDirective
+
+

data/lib/arrow/template/timedelta.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+require 'arrow/exceptions'
+require 'arrow/path'
+require 'arrow/template/nodes'
+require 'arrow/template/call'
+
+# The Arrow::Template::TimeDeltaDirective class, a derivative of
+# Arrow::Template::CallDirective. This plugin defines the 'timedelta' template directive.
+# 
+# === Syntax
+#
+#   <?timedelta process.uptime ?>
+# 
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+#:include: LICENSE
+#
+#--
+#
+# Please see the file LICENSE in the 'docs' directory for licensing details.
+#
+class Arrow::Template::TimeDeltaDirective < Arrow::Template::CallDirective # :nodoc:
+
+	# Approximate Time Constants (in seconds)
+	MINUTES = 60
+	HOURS   = 60  * MINUTES
+	DAYS    = 24  * HOURS
+	WEEKS   = 7   * DAYS
+	MONTHS  = 30  * DAYS
+	YEARS   = 365.25 * DAYS
+
+	######
+	public
+	######
+
+	### Render the content and return it as URL-escaped text.
+	def render( template, scope )
+		rawary = super
+		rary = []
+
+		# Try our best to skip debugging comments
+		if template._config[:debuggingComments]
+			rary.push( rawary.shift ) if /^<!--.*-->$/ =~ rawary.first
+		end
+
+		rawary.each do |line|
+			rary << time_delta_string( line.to_i )
+		end
+
+		return rary
+	end
+
+
+	#######
+	private
+	#######
+
+	### Return a string describing the amount of time in the given number of
+	### seconds in terms a human can understand easily.
+	def time_delta_string( seconds )
+		return 'less than a minute' if seconds < 60
+
+		if seconds < 50 * 60
+			return "%d minute%s" % [seconds / 60, seconds/60 == 1 ? '' : 's']
+		end
+
+		return 'about an hour'					if seconds < 90 * MINUTES
+		return "%d hours" % [seconds / HOURS]	if seconds < 18 * HOURS
+		return 'one day' 						if seconds <  1 * DAYS
+		return 'about a day' 					if seconds <  2 * DAYS
+		return "%d days" % [seconds / DAYS] 	if seconds <  1 * WEEKS
+		return 'about a week' 					if seconds <  2 * WEEKS
+		return "%d weeks" % [seconds / WEEKS] 	if seconds <  3 * MONTHS
+		return "%d months" % [seconds / MONTHS] if seconds <  2 * YEARS
+		return "%d years" % [seconds / YEARS]
+	end
+
+end # class Arrow::Template::URLEncodeDirective