arrow 1.0.7

data/lib/arrow/template/unless.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+require 'arrow/template'
+require 'arrow/template/nodes'
+
+# The Arrow::Template::UnlessDirective 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:
+#
+#   <?unless <name>?>...<?end unless?>
+#   <?unless <name>.<methodchain>?>...<?end unless?>
+#   <?unless <name> (matches|=~) <regex>?>...<?end unless?>
+#   <?unless <name>.<methodchain> (matches|=~) <regex>?>...<?end unless?>
+# 
+# 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::UnlessDirective < 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 +false+, or
+	### the nodes after 'elsif' or 'else' subnodes if their conditions are
+	### met.
+	def render_contents( template, scope )
+		cond = has_been_true = !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 !has_been_true
+					cond = has_been_true = node.evaluate( template, scope )
+				else
+					cond = false
+				end
+
+			when Arrow::Template::ElseDirective
+				if !has_been_true
+					cond = has_been_true = true
+				else
+					cond = false
+				end
+
+			else
+				nodes.push( node ) if cond
+			end
+		end
+
+		return template.render( nodes, scope )
+	end
+
+
+
+end # class Arrow::Template::UnlessDirective

data/lib/arrow/template/urlencode.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+require 'arrow/exceptions'
+require 'arrow/path'
+require 'arrow/template/nodes'
+require 'arrow/template/call'
+
+# The Arrow::Template::URLEncodeDirective class, a derivative of
+# Arrow::Template::CallDirective. This is the class which defines the
+# behaviour of the 'urlencode' template directive.
+# 
+# == 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::URLEncodeDirective < Arrow::Template::CallDirective # :nodoc:
+
+	# Non-URIC Characters (RFC 2396)
+	NonUricRegexp = /[^A-Za-z0-9\-_.!~*'()]/
+
+
+	######
+	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 << line.to_s.gsub( NonUricRegexp ) do |match|
+				"%%%02x" % [ match[0] ]
+			end
+		end
+
+		return rary
+	end
+
+end # class Arrow::Template::URLEncodeDirective

data/lib/arrow/template/yield.rb

@@ -0,0 +1,139 @@
+#!/usr/bin/env ruby
+
+require 'arrow/exceptions'
+require 'arrow/path'
+require 'arrow/template/nodes'
+
+# The Arrow::Template::YieldDirective class, a derivative
+# of Arrow::Template::BracketingDirective. This is the class which defines the
+# behaviour of the 'yield' template directive.
+# 
+# == Syntax
+#
+#  <?yield <args> from <attribute>.<block_method> ?>
+#
+# The <em>args</em> portion is similar to Ruby argument lists: it supports
+# defaults, <tt>*vars</tt>, and hash arguments.
+#
+# == Examples
+#
+#  <!-- Iterate over the incoming headers of an Apache::Request -->
+#  <?yield name, value from request.headers_in.each ?>
+#    <?attr name ?>: <?escape value ?>
+#  <?end yield?>
+#
+#  
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# Please see the file LICENSE in the top-level directory for licensing details.
+#
+class Arrow::Template::YieldDirective < Arrow::Template::BracketingDirective # :nodoc:
+	include Arrow::Template::Parser::Patterns
+
+	# The regexp format of the 'yield' part of the directive tag.
+	FROM = WHITESPACE + /from/i + WHITESPACE
+
+
+	#############################################################
+	###	C L A S S   M E T H O D S
+	#############################################################
+
+	### Returns +false+; disallows prepended formats.
+	def self::allows_format?
+		false
+	end
+
+
+	#############################################################
+	###	I N S T A N C E   M E T H O D S
+	#############################################################
+
+	### Initialize a new YieldDirective object with the specified +type+,
+	### +parser+, and +state+.
+	def initialize( type, parser, state )
+		@args = []
+		@pureargs = []
+		super
+	end
+
+
+	######
+	public
+	######
+
+	# The argument list for the yield block, with sigils and defaults, if any.
+	attr_reader :args
+
+	# The argument list for the callback, with any sigils and defaults
+	# stripped away.
+	attr_reader :pureargs
+
+
+	#########
+	protected
+	#########
+
+	### Parse the contents of the directive, looking for an optional format
+	### for tags like <?directive "%-15s" % foo ?>, then a required
+	### identifier, then an optional methodchain attached to the identifier.
+	def parse_directive_contents( parser, state )
+		@args, @pureargs = parser.scan_for_arglist( state )
+		return nil unless @args
+		state.scanner.skip( FROM ) or
+			raise Arrow::ParseError, "no 'from' for yield"
+
+		super
+	end
+
+
+	### Build a Proc object that encapsulates the execution necessary to
+	### render the directive.
+	def build_rendering_proc( template, scope )
+		code = %q{
+			Proc.new {|__item, __callback|
+				res = []
+				__item%s {|%s| res << __callback.call(%s)}
+				res
+			}
+		} % [ self.methodchain, self.args.join(","), self.pureargs.join(",") ]
+		code.untaint
+
+		#self.log.debug "Rendering proc code is: %p" % code
+		desc = "[%s (%s): %s]" %
+			[ self.class.name, __FILE__, self.methodchain ]
+
+		return eval( code, scope.get_binding, desc, __LINE__ )
+	end
+
+
+	### Pass a callback to our inner node-rendering method as the block for
+	### the specified. Builds a callback which is yielded to from within the
+	### block passed to whatever this directive is calling, which in turn
+	### renders each of its subnodes with the arguments specified by the
+	### yield.
+	def render_contents( template, scope )
+		#self.log.debug "Bulding callback for rendering subnodes..."
+		callback = Proc.new {|*blockArgs|
+			res = []
+			attributes = {}
+			blockArgs.zip( self.pureargs ) do |pair|
+				attributes[ pair[1] ] = pair[0]
+			end
+			#self.log.debug "  override attributes are: %p" % [ attributes ]
+			template.with_overridden_attributes( scope, attributes ) do |template|
+				res << template.render( @subnodes, scope )
+			end
+
+			res
+		}
+
+		#self.log.debug "calling method chain; callback: %p" % callback
+		self.call_methodchain( template, scope, callback )
+	end
+
+
+end # class Arrow::Template::YieldDirective
+
+

data/lib/arrow/templatefactory.rb

@@ -0,0 +1,125 @@
+#!/usr/bin/env ruby
+
+require 'arrow/mixins'
+require 'arrow/object'
+require 'arrow/exceptions'
+require 'arrow/cache'
+
+# The TemplateFactory class, which is responsible for
+# interpreting the 'templates' section of the configuration, and providing 
+# template-loading and -caching according to that configuration, 
+# 
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# Please see the file LICENSE in the top-level directory for licensing details.
+#
+class Arrow::TemplateFactory < Arrow::Object
+	require 'arrow/template'
+
+
+	#############################################################
+	###	C L A S S   M E T H O D S
+	#############################################################
+
+	### Given an Arrow::Config object (+config+), attempt to load and
+	### instantiate the configured template loader object.
+	def self::build_template_loader( config )
+
+		# Resolve the loader name into the Class object by traversing
+		# constants.
+		klass = config.templates.loader.
+			split( /::/ ).
+			inject( Object ) {|mod, name|
+				mod.const_get( name ) or raise ConfigError,
+					"No such template loader class #{name} for #{mod.name}"
+			}
+
+		if klass.respond_to?( :load, false )
+			Arrow::Logger[ self ].debug "Loader (%s) class responds to ::load; using it directly: %p" %
+				[ klass.name, klass.method(:load) ]
+			return klass
+		else
+			Arrow::Logger[ self ].debug "Loader (%s) expects instantiation." % [ klass.name ]
+			return klass.new( config )
+		end
+	end
+
+
+	#############################################################
+	###	I N S T A N C E   M E T H O D S
+	#############################################################
+
+	### Create a new TemplateFactory from the given configuration object,
+	### which should specify a loader class for templates.
+	def initialize( config )
+		@config = config
+		@cache = nil
+		
+		if config.templates.cache
+			@cache = Arrow::Cache.new(
+				"Template Factory",
+				config.templates.cacheConfig,
+				&method(:template_expiration_hook) )
+		end
+
+		@loader = self.class.build_template_loader( config )
+		@path = config.templates.path
+
+		super()
+	end
+
+
+	######
+	public
+	######
+
+	# The Arrow::Cache object used to cache template objects.
+	attr_accessor :cache
+	
+	# The loader object that the factory uses to load templates
+	attr_accessor :loader
+
+	# The path to search for templates
+	attr_accessor :path
+	
+
+	### Load a template object with the specified name.
+	def get_template( name )
+		self.log.debug "Fetching template '#{name}'"
+
+		if @cache
+			self.log.debug "Doing cached fetch."
+			tmpl = @cache.fetch( name, &method(:load_from_file) )
+
+			if tmpl.changed?
+				self.log.debug "Template has changed on disk: reloading"
+				@cache.invalidate( name )
+				tmpl = @cache.fetch( name, &method(:load_from_file) )
+			end
+
+			return tmpl.dup
+		else
+			self.log.debug "Caching disabled. Loading from file."
+			return self.load_from_file( name )
+		end
+	end
+
+
+	### Load a template from its source file (ie., if caching is turned off
+	### or if the cached version is either expired or not yet seen)
+	def load_from_file( name )
+		self.log.debug "Loading template #{name} from the filesystem"
+		return @loader.load( name, @path )
+	end
+
+
+	### Called when a template is expired from the cache
+	def template_expiration_hook( key, template )
+		self.log.debug "Template %s is expiring." % key
+	end
+	
+end # class Arrow::TemplateFactory
+
+

data/lib/arrow/testcase.rb

@@ -0,0 +1,567 @@
+#!/usr/bin/env ruby
+# 
+# This is an abstract test case class for building Test::Unit unit tests for the
+# Arrow web application framework. It consolidates most of the maintenance work
+# that must be done to build a test file by adjusting the $LOAD_PATH to include
+# the lib/ and ext/ directories, as well as adding some other useful methods
+# that make building and maintaining the tests much easier (IMHO). See the docs
+# for Test::Unit for more info on the particulars of unit testing.
+# 
+# == Synopsis
+# 
+#	$LOAD_PATH.unshift "tests/lib" unless $LOAD_PATH.include?("tests/lib")
+#	require 'arrow/testcase'
+#
+#	class MySomethingTest < Arrow::TestCase
+#		def set_up
+#			super()
+#			@foo = 'bar'
+#		end
+#
+#		def test_00_something
+#			obj = nil
+#			assert_nothing_raised { obj = MySomething.new }
+#			assert_instance_of MySomething, obj
+#			assert_respond_to :myMethod, obj
+#		end
+#	end
+# 
+# == VCS Id
+# 
+#  $Id$
+# 
+# == Authors
+# 
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+# Copyright (c) 2003, 2004, 2006 RubyCrafters, LLC.
+# 
+# This work is licensed under the Creative Commons Attribution License. To view
+# a copy of this license, visit http://creativecommons.org/licenses/by/1.0 or
+# send a letter to Creative Commons, 559 Nathan Abbott Way, Stanford, California
+# 94305, USA.
+#
+# 
+
+begin 
+	require "readline"
+	include Readline
+rescue LoadError
+	def readline( prompt )
+		$defout.print( prompt )
+		$defout.flush
+		return $stdin.gets
+	end
+end
+
+begin
+	require 'rubygems'
+rescue LoadError
+end
+
+require 'test/unit'
+require 'test/unit/assertions'
+require 'test/unit/util/backtracefilter'
+
+require 'flexmock'
+require 'apache/fakerequest'
+
+require 'arrow'
+
+
+### Test case class
+class Arrow::TestCase < Test::Unit::TestCase
+
+	@@methodCounter = 0
+
+	# Set some ANSI escape code constants (Shamelessly stolen from Perl's
+	# Term::ANSIColor by Russ Allbery <rra@stanford.edu> and Zenin
+	# <zenin@best.com>
+	AnsiAttributes = {
+		'clear'      => 0,
+		'reset'      => 0,
+		'bold'       => 1,
+		'dark'       => 2,
+		'underline'  => 4,
+		'underscore' => 4,
+		'blink'      => 5,
+		'reverse'    => 7,
+		'concealed'  => 8,
+
+		'black'      => 30,   'on_black'   => 40, 
+		'red'        => 31,   'on_red'     => 41, 
+		'green'      => 32,   'on_green'   => 42, 
+		'yellow'     => 33,   'on_yellow'  => 43, 
+		'blue'       => 34,   'on_blue'    => 44, 
+		'magenta'    => 35,   'on_magenta' => 45, 
+		'cyan'       => 36,   'on_cyan'    => 46, 
+		'white'      => 37,   'on_white'   => 47
+	}
+
+	# The name of the file containing marshalled configuration values
+	ConfigSaveFile = "test.cfg"
+
+	### Inheritance callback -- adds @setupMethods and @teardownMethods ivars
+	### and accessors to the inheriting class.
+	def self::inherited( klass )
+		klass.module_eval {
+			@setupMethods = []
+			@teardownMethods = []
+
+			class << self
+				attr_accessor :setupMethods
+				attr_accessor :teardownMethods
+			end
+		}
+	end
+
+
+	### Returns a String containing the specified ANSI escapes suitable for
+	### inclusion in another string. The <tt>attributes</tt> should be one
+	### or more of the keys of AnsiAttributes.
+	def self::ansiCode( *attributes )
+		return '' unless /(?:xterm(?:-color)?|eterm|linux)/i =~ ENV['TERM']
+
+		attr = attributes.collect {|a|
+			AnsiAttributes[a] ? AnsiAttributes[a] : nil
+		}.compact.join(';')
+		if attr.empty? 
+			return ''
+		else
+			return "\e[%sm" % attr
+		end
+	end
+
+
+	### Output the specified <tt>msgs</tt> joined together to
+	### <tt>STDERR</tt> if <tt>$DEBUG</tt> is set.
+	def self::debugMsg( *msgs )
+		return unless $DEBUG
+		self.message "%sDEBUG>>> %s %s" %
+			[ ansiCode('dark', 'white'), msgs.join(''), ansiCode('reset') ]
+	end
+
+
+	### Output the specified <tt>msgs</tt> joined together to
+	### <tt>STDOUT</tt>.
+	def self::message( *msgs )
+		$stderr.puts msgs.join('')
+		$stderr.flush
+	end
+
+	### Append a setup block for the current testcase
+	def self::addSetupBlock( &block )
+		@@methodCounter += 1
+		newMethodName = "setup_#{@@methodCounter}".to_sym
+		define_method( newMethodName, &block )
+		self.setupMethods.push newMethodName
+	end
+
+
+	### Prepend a teardown block for the current testcase
+	def self::addTeardownBlock( &block )
+		@@methodCounter += 1
+		newMethodName = "teardown_#{@@methodCounter}".to_sym
+		define_method( newMethodName, &block )
+		self.teardownMethods.unshift newMethodName
+	end
+
+
+	#############################################################
+	###	I N S T A N C E   M E T H O D S
+	#############################################################
+
+
+	######
+	public
+	######
+
+	### Run dynamically-added setup methods
+	def setup( *args )
+		if self.class < Arrow::TestCase
+			self.class.setupMethods.each {|sblock|
+				self.send( sblock )
+			}
+		end
+	end
+	alias_method :set_up, :setup
+
+
+	### Run dynamically-added teardown methods
+	def teardown( *args )
+		if self.class < Arrow::TestCase
+			self.class.teardownMethods.each {|tblock|
+				self.send( tblock )
+			}
+		end
+	end
+	alias_method :tear_down, :teardown
+
+
+	### Skip the current step (called from #setup) with the +reason+ given.
+	def skip( reason=nil )
+		if reason
+			msg = "Skipping %s: %s" % [ @method_name, reason ]
+		else
+			msg = "Skipping %s: No reason given." % @method_name
+		end
+
+		$stderr.puts( msg ) if $VERBOSE
+		@method_name = :skipped_test
+	end
+
+
+	def skipped_test # :nodoc:
+	end
+
+
+	### Add the specified +block+ to the code that gets executed by #setup.
+	def addSetupBlock( &block ); self.class.addSetupBlock( &block ); end
+
+
+	### Add the specified +block+ to the code that gets executed by #teardown.
+	def addTeardownBlock( &block ); self.class.addTeardownBlock( &block ); end
+
+
+	### Turn off the stupid 'No tests were specified'
+	def default_test; end
+
+	#################################################################
+	###	A S S E R T I O N S
+	#################################################################
+
+	### Test Hashes for equivalent content
+	def assert_hash_equal( expected, actual, msg="" )
+		errmsg = "Expected hash <%p> to be equal to <%p>" % [expected, actual]
+		errmsg += ": #{msg}" unless msg.empty?
+
+		assert_block( errmsg ) {
+			diffs = compare_hashes( expected, actual )
+			unless diffs.empty?
+				errmsg += ": " + diffs.join("; ")
+				return false
+			else
+				return true
+			end
+		}
+	rescue Test::Unit::AssertionFailedError => err
+		cutframe = err.backtrace.reverse.find {|frame|
+			/assert_hash_equal/ =~ frame
+		}
+		firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
+		Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
+	end
+
+
+	### Compare two hashes for content, returning a list of their differences as
+	### descriptions. An empty Array return-value means they were the same.
+	def compare_hashes( hash1, hash2, subkeys=nil )
+		diffs = []
+		seenKeys = []
+
+		hash1.each {|k,v|
+			if !hash2.key?( k )
+				diffs << "missing %p pair" % k
+			elsif hash1[k].is_a?( Hash ) && hash2[k].is_a?( Hash )
+				diffs.push( compare_hashes(hash1[k], hash2[k]) )
+			elsif hash2[k] != hash1[k]
+				diffs << "value for %p expected to be %p, but was %p" %
+					[ k, hash1[k], hash2[k] ]
+			else
+				seenKeys << k
+			end
+		}
+
+		extraKeys = (hash2.keys - hash1.keys)
+		diffs << "extra key/s: #{extraKeys.join(', ')}" unless extraKeys.empty?
+
+		return diffs.flatten
+	end
+
+
+	### Test Hashes (or any other objects with a #keys method) for key set
+	### equality
+	def assert_same_keys( expected, actual, msg="" )
+		errmsg = "Expected keys of <%p> to be equal to those of <%p>" %
+			[ actual, expected ]
+		errmsg += ": #{msg}" unless msg.empty?
+
+		ekeys = expected.keys; akeys = actual.keys
+		assert_block( errmsg ) {
+			diffs = []
+
+			# XOR the arrays and make a diff for each one
+			((ekeys + akeys) - (ekeys & akeys)).each do |key|
+				if ekeys.include?( key )
+					diffs << "missing key %p" % [key]
+				else
+					diffs << "extra key %p" % [key]
+				end
+			end
+
+			unless diffs.empty?
+				errmsg += "\n" + diffs.join("; ")
+				return false
+			else
+				return true
+			end
+		}
+	rescue Test::Unit::AssertionFailedError => err
+		cutframe = err.backtrace.reverse.find {|frame|
+			/assert_hash_equal/ =~ frame
+		}
+		firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
+		Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
+	end
+
+	
+	### Override the stupid deprecated #assert_not_nil so when it
+	### disappears, code doesn't break.
+	def assert_not_nil( obj, msg=nil )
+		msg ||= "<%p> expected to not be nil." % obj
+		assert_block( msg ) { !obj.nil? }
+	rescue Test::Unit::AssertionFailedError => err
+		cutframe = err.backtrace.reverse.find {|frame|
+			/assert_not_nil/ =~ frame
+		}
+		firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
+		Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
+	end
+
+
+	### Succeeds if +obj+ include? +item+.
+	def assert_include( item, obj, msg=nil )
+		msg ||= "<%p> expected to include <%p>." % [ obj, item ]
+		assert_block( msg ) { obj.respond_to?(:include?) && obj.include?(item) }
+	rescue Test::Unit::AssertionFailedError => err
+		cutframe = err.backtrace.reverse.find {|frame|
+			/assert_include/ =~ frame
+		}
+		firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
+		Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
+	end
+
+
+	### Negative of assert_respond_to
+	def assert_not_tainted( obj, msg=nil )
+		msg ||= "<%p> expected to NOT be tainted" % [ obj ]
+		assert_block( msg ) {
+			!obj.tainted?
+		}
+	rescue Test::Unit::AssertionFailedError => err
+		cutframe = err.backtrace.reverse.find {|frame|
+			/assert_not_tainted/ =~ frame
+		}
+		firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
+		Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
+	end
+
+
+	### Negative of assert_respond_to
+	def assert_not_respond_to( obj, meth )
+		msg = "%s expected NOT to respond to '%s'" %
+			[ obj.inspect, meth ]
+		assert_block( msg ) {
+			!obj.respond_to?( meth )
+		}
+	rescue Test::Unit::AssertionFailedError => err
+		cutframe = err.backtrace.reverse.find {|frame|
+			/assert_not_respond_to/ =~ frame
+		}
+		firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
+		Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
+	end
+
+
+	### Assert that the instance variable specified by +sym+ of an +object+
+	### is equal to the specified +value+. The '@' at the beginning of the
+	### +sym+ will be prepended if not present.
+	def assert_ivar_equal( value, object, sym )
+		sym = "@#{sym}".to_sym unless /^@/ =~ sym.to_s
+		msg = "Instance variable '%s'\n\tof <%s>\n\texpected to be <%s>\n" %
+			[ sym, object.inspect, value.inspect ]
+		msg += "\tbut was: <%p>" % [ object.instance_variable_get(sym) ]
+		assert_block( msg ) {
+			value == object.instance_variable_get(sym)
+		}
+	rescue Test::Unit::AssertionFailedError => err
+		cutframe = err.backtrace.reverse.find {|frame|
+			/assert_ivar_equal/ =~ frame
+		}
+		firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
+		Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
+	end
+
+
+	### Assert that the specified +object+ has an instance variable which
+	### matches the specified +sym+. The '@' at the beginning of the +sym+
+	### will be prepended if not present.
+	def assert_has_ivar( sym, object )
+		sym = "@#{sym}" unless /^@/ =~ sym.to_s
+		msg = "Object <%s> expected to have an instance variable <%s>" %
+			[ object.inspect, sym ]
+		assert_block( msg ) {
+			object.instance_variables.include?( sym.to_s )
+		}
+	rescue Test::Unit::AssertionFailedError => err
+		cutframe = err.backtrace.reverse.find {|frame|
+			/assert_has_ivar/ =~ frame
+		}
+		firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
+		Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
+	end
+
+
+	### Assert that the specified +str+ does *not* match the given regular
+	### expression +re+.
+	def assert_not_match( re, str )
+		msg = "<%s> expected not to match %p" %
+			[ str, re ]
+		assert_block( msg ) {
+			!re.match( str )
+		}
+	rescue Test::Unit::AssertionFailedError => err
+		cutframe = err.backtrace.reverse.find {|frame|
+			/assert_not_match/ =~ frame
+		}
+		firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
+		Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
+	end
+
+
+	### Assert that the specified +klass+ defines the specified instance
+	### method +meth+.
+	def assert_has_instance_method( klass, meth )
+		msg = "<%s> expected to define instance method #%s" %
+			[ klass, meth ]
+		assert_block( msg ) {
+			klass.instance_methods.include?( meth.to_s )
+		}
+	rescue Test::Unit::AssertionFailedError => err
+		cutframe = err.backtrace.reverse.find {|frame|
+			/assert_has_instance_method/ =~ frame
+		}
+		firstIdx = (err.backtrace.rindex( cutframe )||0) + 1
+		Kernel.raise( err, err.message, err.backtrace[firstIdx..-1] )
+	end
+
+
+
+	#################################################################
+	###	M E S S A G E   M E T H O D S
+	#################################################################
+
+	### Instance alias for the like-named class method.
+	def message( *msgs )
+		self.class.message( *msgs )
+	end
+
+
+	### Instance-alias for the like-named class method
+	def ansiCode( *attributes )
+		self.class.ansiCode( *attributes )
+	end
+
+
+	### Instance alias for the like-named class method
+	def debugMsg( *msgs )
+		self.class.debugMsg( *msgs )
+	end
+
+
+	### Return a separator line made up of <tt>length</tt> of the specified
+	### <tt>char</tt>.
+	def hrule( length=75, char="-" )
+		return (char * length ) + "\n"
+	end
+
+	### Return a section delimited by hrules with the specified +caption+ and
+	### +content+.
+	def hruleSection( content, caption='' )
+		caption << ' ' unless caption.empty?
+		return caption +
+			hrule( 75 - caption.length ) +
+			content.chomp + "\n" +
+			hrule()
+	end
+
+
+	### Output a header for delimiting tests
+	def printTestHeader( desc )
+		return unless $VERBOSE || $DEBUG
+		message "%s>>> %s <<<%s" % 
+			[ ansiCode('bold','yellow','on_blue'), desc, ansiCode('reset') ]
+	end
+
+
+	#################################################################
+	###	T E S T I N G   U T I L I T I E S
+	#################################################################
+
+	### Try to force garbage collection to start.
+	def collectGarbage
+		a = []
+		1000.times { a << {} }
+		a = nil
+		GC.start
+	end
+
+
+	### Touch a file and truncate it to 0 bytes
+	def zerofile( filename )
+		File.open( filename, File::WRONLY|File::CREAT ) {}
+		File.truncate( filename, 0 )
+	end
+
+
+	### Output the name of the test as it's running if in verbose mode.
+	def run( result )
+		$stderr.puts self.name if $VERBOSE || $DEBUG
+
+		# Support debugging for individual tests
+		olddb = nil
+		if $DebugPattern && $DebugPattern =~ @method_name
+			Arrow::Logger.global.outputters <<
+				Arrow::Logger::Outputter.create( 'file:stderr' )
+			Arrow::Logger.global.level = :debug
+
+			olddb = $DEBUG
+			$DEBUG = true
+		end
+		
+		super
+
+		unless olddb.nil?
+			$DEBUG = olddb 
+			Arrow::Logger.global.outputters.clear
+		end
+	end
+
+
+	#################################################################
+	###	P R O M P T I N G   M E T H O D S
+	#################################################################
+
+	### Output the specified <tt>promptString</tt> as a prompt (in green) and
+	### return the user's input with leading and trailing spaces removed.
+	def prompt( promptString )
+		promptString.chomp!
+		return readline( ansiCode('bold', 'green') + "#{promptString}: " +
+						 ansiCode('reset') ).strip
+	end
+
+
+	### Prompt the user with the given <tt>promptString</tt> via #prompt,
+	### substituting the given <tt>default</tt> if the user doesn't input
+	### anything.
+	def promptWithDefault( promptString, default )
+		response = prompt( "%s [%s]" % [ promptString, default ] )
+		if response.empty?
+			return default
+		else
+			return response
+		end
+	end
+
+end # module Arrow
+