RubyGems - ltdtemplate - Versions diffs - 0.2.4 → 1.0.0 - Mend

ltdtemplate 0.2.4 → 1.0.0

Files changed (40) hide show

data/CHANGELOG +10 -1
data/Gemfile +2 -1
data/RESOURCES +18 -32
data/TEMPLATE_MANUAL.html +126 -47
data/lib/ltdtemplate.rb +352 -242
data/lib/ltdtemplate/code.rb +14 -87
data/lib/ltdtemplate/code/call.rb +20 -16
data/lib/ltdtemplate/code/parameters.rb +28 -31
data/lib/ltdtemplate/code/sequence.rb +39 -0
data/lib/ltdtemplate/code/subscript.rb +57 -50
data/lib/ltdtemplate/code/variable.rb +22 -39
data/lib/ltdtemplate/proxy.rb +26 -0
data/lib/ltdtemplate/proxy/array.rb +258 -0
data/lib/ltdtemplate/proxy/boolean.rb +74 -0
data/lib/ltdtemplate/proxy/match.rb +40 -0
data/lib/ltdtemplate/proxy/nil.rb +27 -0
data/lib/ltdtemplate/proxy/number.rb +77 -0
data/lib/ltdtemplate/proxy/regexp.rb +74 -0
data/lib/ltdtemplate/proxy/string.rb +196 -0
data/lib/ltdtemplate/value.rb +94 -0
data/lib/ltdtemplate/value/array_splat.rb +34 -0
data/lib/ltdtemplate/value/code_block.rb +21 -17
data/lib/ltdtemplate/value/namespace.rb +77 -79
data/ltdtemplate.gemspec +2 -2
data/test/04number.rb +0 -7
data/test/05string.rb +0 -7
data/test/06array.rb +0 -9
data/test/07each.rb +3 -3
data/test/08interpolate.rb +1 -1
data/test/10missing_meth.rb +1 -1
data/test/11classes.rb +9 -9
metadata +15 -13
data/lib/ltdtemplate/code/code_block.rb +0 -30
data/lib/ltdtemplate/value/array.rb +0 -210
data/lib/ltdtemplate/value/boolean.rb +0 -82
data/lib/ltdtemplate/value/nil.rb +0 -30
data/lib/ltdtemplate/value/number.rb +0 -96
data/lib/ltdtemplate/value/string.rb +0 -215
data/lib/test.rb +0 -10
data/test/03tpl_singletons.rb +0 -48

data/CHANGELOG CHANGED Viewed

@@ -1,3 +1,12 @@
+2014-05-07 Version 1.0.0
+	Major rewrite to work with native types proxied into a template
+	Rubyverse.
+	RESOURCES file now built from shell script find_resources.
+	Added support for regexp.match(string) and string.match(regexp).
 2014-03-15 Version 0.2.4
 	Fixed a bug in the parameter scalar assignment determination.
@@ -31,7 +40,7 @@
 2013-07-28 Version 0.2.1
-	Added array.{each,each_rnd,each_seq} methods (executing the code
+	Added array.\{each,each_rnd,each_seq} methods (executing the code
 	block supplied as the first parameter with parameters key and
 	value).

data/Gemfile CHANGED Viewed

@@ -1,4 +1,5 @@
 source "https://rubygems.org"
-gem "sarah", "~> 0.0.2"
+gem "rubyverse", "~> 0.0.1"
+gem "sarah", "~> 2.0.0"
 gem "htmlentities", "~> 4.3.1"

data/RESOURCES CHANGED Viewed

@@ -1,32 +1,18 @@
-Resource Usage/Limit Summary
-arrays
-    The total number of arrays created
-array_size
-    The size of the largest array
-call_depth
-    The current/maximum call depth
-calls
-    The total number of calls made
-iterations
-    The total number of loop iterations
-regexp (limit)
-    A string may only be converted to a regexp if limit regexp
-    is set to false before rendering
-string_length
-    The combined total length of strings created
-subscript_depth
-    The maximum subsubscript depth
-subscripts
-    The total number of subscripts
-use
-    The total number of "$.use" calls
+array (proxy/array.rb): Total number of arrays created
+array_growth (code/parameters.rb): Increases in array sizes
+array_growth (proxy/array.rb): Increases in array sizes
+array_size (proxy/array.rb): Size of largest modified array
+call_depth (code/call.rb): The current method call depth
+calls (code/call.rb): Total number of method calls
+code_steps (code/sequence.rb): Total number of code steps executed
+iterations (value/namespace.rb): Total loop iterations
+string_length (code/sequence.rb): Length of longest modified string
+string_length (proxy/array.rb): Length of longest modified string
+string_length (proxy/regexp.rb): Length of longest modified string
+string_length (proxy/string.rb): Length of longest modified string
+string_total (proxy/array.rb): Combined length of computed strings
+string_total (proxy/regexp.rb): Combined length of computed strings
+string_total (proxy/string.rb): Combined length of computed strings
+subscript_depth (code/subscript.rb): Deepest subscript depth
+subscripts (code/subscript.rb): Total number of subscripts
+use (value/namespace.rb): Total $.use invocations

data/TEMPLATE_MANUAL.html CHANGED Viewed

@@ -11,7 +11,7 @@ td:first-child, th:first-child { padding-left: 0.3em }
 </head>
 <body>
 <h1 id='top'>LtdTemplate Manual<br>
-<span style='font-size: smaller'>Version 0.2.2; July 29, 2013</span></h1>
+<span style='font-size: smaller'>Version 1.0.0; 2014-05-07</span></h1>
 <h2>Author(s)</h2>
@@ -100,8 +100,8 @@ themselves.</p>
 <li><a href='#assignment_syntax'>Assignments</a></li>
 <li><a href='#predefined_vars'>Pre-Defined Variables</a></li>
 <li><a href='#codeseq_syntax'>Code Sequences</a></li>
-<li><a href='#codeblock_syntax'>Code Blocks</a></li>
-<li><a href='#subscript_syntax'>Subscripts And Code-Block Bindings</a></li>
+<li><a href='#codeblock_syntax'>Code Blocks And Bindings</a></li>
+<li><a href='#subscript_syntax'>Subscripts</a></li>
 </ul>
 <h3 id='comment_syntax'>Comments</h3>
@@ -190,8 +190,8 @@ digits.</p>
 <blockquote><code>0.125 1 -2 3.0 -4.5</code></blockquote>
-<p>LtdTemplate does not support numeric literals in scientific notation
-or bases other than ten.</p>
+<p>LtdTemplate does not currently support numeric literals in scientific
+notation or bases other than ten.</p>
 <p>[<a href='#contents'>Contents</a>] [<a href='#code_syntax'>Template Code Syntax</a>]</p>
@@ -269,10 +269,12 @@ if not immediately preceded by punctuation.</p>
 <h3 id='assignment_syntax'>Assignments</h3>
-<p>Variables support two assignment method calls: unconditional
-(<code>=</code>) and conditional (<code>?=</code>). A conditional
-assignment does nothing if the variable is already bound to (holds a
-reference to) a value (including the nil value). Assignments do not
+<p>Variables (and array subscripts, covered later) support two assignment
+method calls: unconditional (<code>=</code>) and conditional
+(<code>?=</code>). A conditional assignment does nothing if the variable is
+already bound to (holds a reference to) a value other than the nil
+value. (This is a change from versions prior to 1.0.0; in those versions
+even a nil value prevented a conditional assignment.) Assignments do not
 render in the template output.</p>
 <p>If called with a single parameter and no "dot dot" symbol, the value of
@@ -310,11 +312,11 @@ others will be created in the current namespace.</p>
     destroyed when the code block completes.</td></tr>
 <tr><td><code>^</code></td>
-    <td>This variable refers to the previous namespace if there is one,
-    or <a href='#nil_value'>nil</a> if there isn't.</td></tr>
+    <td>This variable refers to the previous (parent) namespace if there
+    is one, or <a href='#nil_value'>nil</a> if there isn't.</td></tr>
 <tr><td><code>@</code></td>
-    <td>This variable refers to the first (also known as "root" or
+    <td>This variable refers to the first (also known as the "root" or
     "top-level") namespace.</td></tr>
 <tr><td><code>_</code></td>
@@ -333,20 +335,20 @@ expressions. <a href='#template_syntax'>Templates</a>,
 <a href='#call_syntax'>method call</a> parameters, and
 <a href='#codeblock_syntax'>code block</a> bodies are all code sequences.</p>
-<p>If a code sequence consists of a single, non-string value and does
-not constitute the entire template code, it is retained as-is. Otherwise,
-the string value of each element in the sequence, if any, is combined to
+<p>If a code sequence consists of a single value and does not constitute
+the entire template code, it is retained as-is. Otherwise, the string
+value of each element in the sequence, if any, is combined to
 produce the result of the code sequence.</p>
 <blockquote><code>'Hello $.true ", " num=(5) num-(4) " world!"<br>
-/* 5 and 4 are single, non-string values in their code sequences */<br>
+/* 5 and 4 are single values in their code sequences */<br>
 /* $.true and num=(5) render nothing */<br>
 /* num-(4) returns the number 1 but it's string value gets used */<br>
 /* => Hello, 1 world! */</code></blockquote>
 <p>[<a href='#contents'>Contents</a>] [<a href='#code_syntax'>Template Code Syntax</a>]</p>
-<h3 id='codeblock_syntax'>Code Blocks</h3>
+<h3 id='codeblock_syntax'>Code Blocks And Bindings</h3>
 <p>If you surround a <a href='#codeseq_syntax'>code sequence</a>
 by braces (<code>{</code> and <code>}</code>), you create a code
@@ -358,9 +360,34 @@ the code sequence within the code block.</p>
 render_method.hi " " render_method.there
 /* => hi there */</code></blockquote>
+<p>Code blocks (or other values) may be bound to values using the
+<code>methods</code> method and subsequently called like
+<a href='#call_syntax'>methods</a>.
+<p>The <code>methods</code> method takes any number of name-and-binding
+pairs to be added or updated. If there are an odd number of parameters
+(i.e. there is a final name without a binding), the existing binding, if any,
+associated with that name is returned. Specifying nil ($.nil) as the
+binding will actually delete any existing binding for the given name.</p>
+<blockquote><code>@.methods('greet,{"Hello, "_[0]"."})<br>
+@.greet('Dave) /* => Hello, Dave. */</code></blockquote>
+<p>You can also bind code blocks to proxy objects to be used by an entire
+class of values. For convenience, binding to an unset variable automatically
+causes the variable to be set to an empty string.</p>
+<blockquote><code>@Array?=(') /* bind the Array proxy to a unique object
+(before 1.0.0) */<br>
+@Array.methods('list, { $.target.join(", ") }) /* bind the list method */<br>
+$.*(1, 2, 3).list /* => 1, 2, 3 */</code></blockquote>
+<p>Methods added this way are only called if there is no standard method
+with the same name.</p>
 <p>[<a href='#contents'>Contents</a>] [<a href='#code_syntax'>Template Code Syntax</a>]</p>
-<h3 id='subscript_syntax'>Subscripts And Code-Block Bindings</h3>
+<h3 id='subscript_syntax'>Subscripts</h3>
 <p>Any expression that evaluates to an array (or tree of nested arrays)
 may be subscripted to select a particular value or nested array from the
@@ -377,20 +404,13 @@ array_var['items][5] /* as above - alternate syntax */</code></blockquote>
 <p>If the requested item does not exist, the special value
 "<a href='#nil_value'>nil</a>" is used instead.</p>
-<p>LtdTemplate also uses subscript syntax to bind
-<a href='#codeblock_syntax'>code blocks</a> to non-array values. These can
-subsequently be called like <a href='#call_syntax'>methods</a>. They
-never override standard methods.</p>
+<p>Prior to version 1.0.0, subscript syntax could also be used to bind
+<a href='#codeblock_syntax'>code blocks</a> to non-array values. The syntax
+is shown here for historical reference but is <strong>no longer
+supported</strong>:</p>
 <blockquote><code>x['greeting]=({'hello}) /* where x is not an array
-value */<br>x.greeting /* => hello */</code></blockquote>
-<p>You can also bind code blocks to proxy objects to be used by all
-array, boolean, number, or string values.</p>
-<blockquote><code>@Array?=(') /* bind the array proxy to a unique object */<br>
-@Array['list]=({ $.target.join(", ") }) /* bind the list method */<br>
-$.*(1, 2, 3).list /* => 1, 2, 3 */</code></blockquote>
+value */<br>/* this syntax is no longer supported! */</code></blockquote>
 <p>[<a href='#contents'>Contents</a>] [<a href='#code_syntax'>Template Code Syntax</a>]</p>
@@ -404,7 +424,7 @@ $.*(1, 2, 3).list /* => 1, 2, 3 */</code></blockquote>
 <li><a href='#nil_value'>Nil</a></li>
 <li><a href='#number_values'>Numbers</a></li>
 <li><a href='#string_values'>Strings</a></li>
-<li><a href='#regexp_values'>Regular Expressions</a></li>
+<li><a href='#regexp_values'>Regular Expressions And Matches</a></li>
 </ul>
 <h3 id='array_values'>Arrays</h3>
@@ -502,8 +522,7 @@ matrix[0, 0] /* => 1 */ matrix['type] /* => identity */</code></blockquote>
 <p><a href='#codeblock_syntax'>Code blocks</a> may be bound as methods for
 all array values as follows:</p>
-<blockquote><code>@Array?=(')
-@Array['</code><i>method_name</i><code>]=({</code>
+<blockquote><code>@Array.methods('</code><i>method_name</i><code>, {</code>
 <i>code sequence</i> <code>})</code></blockquote>
 <p>[<a href='#contents'>Contents</a>] [<a href='#values_methods'>Values And Methods</a>]</p>
@@ -553,11 +572,11 @@ empty strings, are treated as true).</p>
 for true, false, or both boolean
 values as follows:</p>
-<blockquote><code>$.true['</code><i>method_name</i><code>]=({</code>
+<blockquote><code>$.true.methods('</code><i>method_name</i><code>, {</code>
 <i>code sequence</i> <code>})<br>
-$.false['</code><i>method_name</i><code>]=({</code>
+$.false.methods('</code><i>method_name</i><code>, {</code>
 <i>code sequence</i> <code>})<br>
-@Boolean?=(') @Boolean['</code><i>method_name</i><code>]=({</code>
+@Boolean.methods('</code><i>method_name</i><code>, {</code>
 <i>code sequence</i> <code>})</code></blockquote>
 <p>[<a href='#contents'>Contents</a>] [<a href='#values_methods'>Values And Methods</a>]</p>
@@ -657,6 +676,12 @@ programming environments.</p>
 </table>
+<p><a href='#codeblock_syntax'>Code blocks</a> may be bound as methods for
+all namespaces as follows:</p>
+<blockquote><code>@Namespace.methods('</code><i>method_name</i><code>, {</code>
+<i>code sequence</i> <code>})</code></blockquote>
 <p>[<a href='#contents'>Contents</a>] [<a href='#values_methods'>Values And Methods</a>]</p>
 <h3 id='nil_value'>Nil</h3>
@@ -678,7 +703,7 @@ value. It can be accessed via the namespace method call
 <p><a href='#codeblock_syntax'>Code blocks</a> may be bound as methods
 for the nil value as follows:</p>
-<blockquote><code>$.nil['</code><i>method_name</i><code>]=({</code>
+<blockquote><code>$.nil.methods('</code><i>method_name</i><code>, {</code>
 <i>code sequence</i> <code>})</code></blockquote>
 <p>[<a href='#contents'>Contents</a>] [<a href='#values_methods'>Values And Methods</a>]</p>
@@ -762,8 +787,7 @@ for the nil value as follows:</p>
 <p><a href='#codeblock_syntax'>Code blocks</a> may be bound as methods for
 all numeric values as follows:</p>
-<blockquote><code>@Number?=(')
-@Number['</code><i>method_name</i><code>]=({</code>
+<blockquote><code>@Number.methods('</code><i>method_name</i><code>, {</code>
 <i>code sequence</i> <code>})</code></blockquote>
 <p>[<a href='#contents'>Contents</a>] [<a href='#values_methods'>Values And Methods</a>]</p>
@@ -812,6 +836,12 @@ all numeric values as follows:</p>
 <tr><td><code>len</code>, <code>length</code></td>
     <td>Returns the length of the string</td></tr>
+<tr><td><code>match(</code><i>regexp</i><code>,
+  </code><i>offset</i><code>)</code></td><
+    <td>Match a string against a <a href='#regexp_values'>regular
+    expression</a>. Returns MatchData if the pattern matches, or nil
+    if it doesn't.</td></tr>
 <tr><td><code>pcte</code></td>
     <td>Returns the "percent encoding" of the string
     (for URI components; since 0.1.4)</td></tr>
@@ -893,19 +923,17 @@ all numeric values as follows:</p>
 <p><a href='#codeblock_syntax'>Code blocks</a> may be bound as methods for
 all string values as follows:</p>
-<blockquote><code>@String?=(')
-@String['</code><i>method_name</i><code>]=({</code>
+<blockquote><code>@String.methods('</code><i>method_name</i><code>, {</code>
 <i>code sequence</i> <code>})</code></blockquote>
 <p>[<a href='#contents'>Contents</a>] [<a href='#values_methods'>Values And Methods</a>]</p>
-<h3 id='regexp_values'>Regular Expressions</h3>
+<h3 id='regexp_values'>Regular Expressions And Matches</h3>
 <p>"<a href='http://en.wikipedia.org/wiki/Regular_expression'>Regular
 expressions</a>" ("regex" or "regexp" for short) in LtdTemplate are
-specially enhanced, "magic strings". They behave like regular strings
-unless used in a method call that is able to use them as a regular
-expression.</p>
+generated from <a href='#string_values'>string values</a> using the
+<code>regexp</code> method.</p>
 <p>Regular expressions must be enabled by the calling program. See
 the gem documentation for details.</p>
@@ -919,9 +947,18 @@ the gem documentation for details.</p>
 <tr><td><code>ci, ignorecase</code></td>
     <td>Make pattern case-insensitive</td></tr>
+<tr><td><code>class</code></td>
+     <td>Returns the string "Regexp"</td></tr>
 <tr><td><code>ext, extended</code></td>
      <td>Allow white space and comments in the pattern</td></tr>
+<tr><td><code>match(</code><i>string</i><code>,
+  </code><i>offset</i><code>)</code></td>
+    <td>Match a <a href='#string_values'>string</a> against a regular
+    expression. Returns MatchData if the pattern matches, or nil if it
+    doesn't.</td></tr>
 <tr><td><code>multi, multiline</code></td>
     <td>Makes <code>.</code> match newlines too</td></tr>
@@ -932,6 +969,48 @@ the gem documentation for details.</p>
 <blockquote><code>"Example".replace("[aeiou]".regexp.ci,'_)
 /* => _x_mpl_ */</code></blockquote>
+<p><a href='#codeblock_syntax'>Code blocks</a> may be bound as methods for
+all regular expression values as follows:</p>
+<blockquote><code>@Regexp.methods('</code><i>method_name</i><code>, {</code>
+<i>code sequence</i> <code>})</code></blockquote>
+<p>Regular expression match-result methods:</p>
+<table>
+<tr><th>Method</th><th>Description</th></tr>
+<tr><td><code>[</code><i>index</i><code>]</code></td>
+    <td>Returns the entire (index 0) or specific sub-pattern match.</td></tr>
+<tr><td><code>[</code><i>name</i><code>]</code></td>
+    <td>Returns the named sub-pattern match.</td></tr>
+<tr><td><code>begin(</code><i>n</i><code>)</code></td>
+    <td>Returns the offset of the start of the <i>nth</i> match array
+    in the string (numeric index or named sub-match).</td></tr>
+<tr><td><code>class</code></td>
+    <td>Returns the string "Match".</td></tr>
+<tr><td><code>end(</code><i>n</i><code>)</code></td>
+    <td>Returns the offset of the character immediately following the
+    <i>nth</i> match in the string (numeric index or named
+    sub-match).</td></tr>
+<tr><td><code>length</code>, <code>size</code></td>
+    <td>Returns the size of the match results array.</td></tr>
+<tr><td><code>offset(</code><i>n</i><code>)</code></td>
+    <td>Returns the <code>begin</code> and <code>end</code> values in a
+    two-element array.</td></tr>
+<tr><td><code>type</code></td>
+    <td>Returns the string "match".</td></tr>
+</table>
 <p>[<a href='#contents'>Contents</a>] [<a href='#values_methods'>Values And Methods</a>]</p>
 <h2 id='examples'>(Some More) Examples</h2>
@@ -939,7 +1018,7 @@ the gem documentation for details.</p>
 <p>This example binds a list method to arrays to include commas and "and"
 between elements:</p>
-<blockquote><code>@Array?=(') @Array['list]=({<br>
+<blockquote><code>@Array.methods('list, {<br>
 $.target.join(" and ", ", ", ", ", ", and ") })<br>
 $.*('Ruby).list /* => Ruby */<br>
 $.*('Perl, 'Ruby).list /* => Perl and Ruby */<br>
@@ -950,7 +1029,7 @@ $.*('Perl, 'PHP, 'Python, 'Ruby).list /* => Perl, PHP, Python, and Ruby */
 the English "nth" for the number (e.g. 1st for 1, 2nd for 2, 3rd for 3,
 etc.) and then generates them from -11 to 24:</p>
-<blockquote><code>@Number?=(') @Number['en_nth]=({<br>
+<blockquote><code>@Number.methods('en_nth, {<br>
 $.var(.. 'n, $.target) $.var(.. 'n10, n.abs%(10), 'n100, n.abs%(100))<br>
 n $.if({ n100&gt;=(11)&(n100&lt;=(20)) }, 'th, { n10==(1) }, 'st,<br>
 { n10==(2) }, 'nd, { n10==(3) }, 'rd, 'th) })<br>

data/lib/ltdtemplate.rb CHANGED Viewed

@@ -2,13 +2,37 @@
 #
 # A template system with limitable resource usage.
 #
-# @author Brian Katzung <briank@kappacs.com>, Kappa Computer Solutions, LLC
-# @copyright 2013 Brian Katzung and Kappa Computer Solutions, LLC
+# @author Brian Katzung (briank@kappacs.com), Kappa Computer Solutions, LLC
+# @copyright 2013-2014 Brian Katzung and Kappa Computer Solutions, LLC
 # @license MIT License
+require 'rubyverse'
+require 'sarah'
 class LtdTemplate
-    VERSION = '0.2.4'
+    include Rubyverse
+    # Classes that "extend LtdTemplate::Consumer" are instantiated
+    # with the template as the first parameter by LtdTemplate#factory.
+    module Consumer; end
+    # Instances of classes that "include LtdTemplate::Method_Handler"
+    # handle their own template methods in our Rubyverse and don't need
+    # a proxy object.
+    module Method_Handler; end
+    # Use "params.extend LtdTemplate::Univalue" to mark parameter lists
+    # that may be interpreted as scalar (e.g. a single value and no
+    # ".." operator).
+    module Univalue; end
+    # This exception is raised when a resource limit is exceeded.
+    class ResourceLimitExceeded < RuntimeError; end
+    ##################################################
+    VERSION = '1.0.0'
     TOKEN_MAP = {
 	?. => :dot,		# method separator
@@ -22,251 +46,168 @@ class LtdTemplate
 	?} => :rbrace		# end code block
     }
-    # @!attribute [r] exceeded
-    # @return [Symbol, nil]
-    # The resource whose limit was being exceeded when an
-    # LtdTemplate::ResourceLimitExceeded exception was raised.
-    attr_reader :exceeded
-    # @!attribute [r] factory_singletons
-    # @return [Hash]
-    # A hash of factory singletons (e.g. nil, true, and false values)
-    # for this template.
-    attr_reader :factory_singletons
-    # @!attribute [r] limits
-    # @return [Hash]
-    # A hash of resource limits to enforce during parsing and rendering.
-    attr_reader :limits
-    # @!attribute [r] namespace
-    # @return [LtdTemplate::Value::Namespace, nil]
-    # The current namespace (at the bottom of the rendering namespace stack).
-    attr_reader :namespace
-    # @!attribute [r] options
-    # @return [Hash]
-    # Instance initialization options
-    attr_reader :options
-    # @!attribute [r] usage
-    # @return [Hash]
-    # A hash of resource usage. It is updated after calls to #parse and
-    # #render.
-    attr_reader :usage
-    # @!attribute [r] used
-    # @return [Hash]
-    # A hash of used resources for this template
-    attr_reader :used
     # @@classes contains the default factory classes. These can be overridden
     # globally using the #set_classes class method or per-template using the
     # #set_classes instance method.
+    #
+    # NOTE: Factory types are also used for resource tracking, and therefore
+    # must be unique among resource usage symbols.
     @@classes = {
 	#
-	# These represent storable values. Some may also occur as
-	# literals in code blocks.
+	# These represent storable values.
 	#
-	:array => 'LtdTemplate::Value::Array',
-	:boolean => 'LtdTemplate::Value::Boolean',
-	:explicit_block => 'LtdTemplate::Value::Code_Block',
+	:array => 'Sarah',
+	:array_splat => 'LtdTemplate::Value::Array_Splat',
+	:code_block => 'LtdTemplate::Value::Code_Block',
 	:namespace => 'LtdTemplate::Value::Namespace',
-	:nil => 'LtdTemplate::Value::Nil',
-	:number => 'LtdTemplate::Value::Number',
-	:string => 'LtdTemplate::Value::String',
+	#
+	# These proxies provide template methods for native values.
+	#
+	:array_proxy => 'LtdTemplate::Proxy::Array',
+	:boolean_proxy => 'LtdTemplate::Proxy::Boolean',
+	:match_proxy => 'LtdTemplate::Proxy::Match',
+	:nil_proxy => 'LtdTemplate::Proxy::Nil',
+	:number_proxy => 'LtdTemplate::Proxy::Number',
+	:regexp_proxy => 'LtdTemplate::Proxy::Regexp',
+	:string_proxy => 'LtdTemplate::Proxy::String',
 	#
 	# These only occur as part of code blocks.
 	#
 	:call => 'LtdTemplate::Code::Call',
-	:implied_block => 'LtdTemplate::Code::Code_Block',
+	:code_seq => 'LtdTemplate::Code::Sequence',
 	:parameters => 'LtdTemplate::Code::Parameters',
 	:subscript => 'LtdTemplate::Code::Subscript',
 	:variable => 'LtdTemplate::Code::Variable',
     }
+    # @@proxies contains the default mapping of native Ruby classes to
+    # factory symbols for the corresponding proxy classes.
+    # These can be overridden globally using the #set_proxies class method
+    # or per-template using the #set_proxies instance method.
+    # Unproxied native types will be invisible.
+    @@proxies = {
+	'Array' => :array_proxy,
+	'FalseClass' => :boolean_proxy,
+	'Hash' => :array_proxy,
+	'MatchData' => :match_proxy,
+	'NilClass' => :nil_proxy,
+	'Numeric' => :number_proxy,
+	'Regexp' => :regexp_proxy,
+	'Sarah' => :array_proxy,
+	'String' => :string_proxy,
+	'TrueClass' => :boolean_proxy,
+    }
+    # @!attribute [r] limits
+    # @return [Hash]
+    # A hash of resource limits to enforce during parsing and rendering.
+    attr_reader :limits
+    # @!attribute [r] usage
+    # @return [Hash]
+    # A hash of resource usage. It is updated after calls to #parse and
+    # #render.
+    attr_reader :usage
+    # @!attribute [r] exceeded
+    # @return [Symbol, nil]
+    # The resource whose limit was being exceeded when an
+    # LtdTemplate::ResourceLimitExceeded exception was raised.
+    attr_reader :exceeded
+    # @!attribute [r] options
+    # @return [Hash]
+    # Instance initialization options.
+    attr_reader :options
+    # @!attribute [r] namespace
+    # @return [LtdTemplate::Value::Namespace, nil]
+    # The current namespace (at the bottom of the rendering namespace stack).
+    attr_reader :namespace
+    # @!attribute [r] used
+    # @return [Hash]
+    # The resources already $.use'd for this template
+    attr_reader :used
     # Change default factory classes globally
     #
-    # @param classes [Hash] A hash of factory symbols and corresponding
+    # @param mapping [Hash] A hash of factory symbols and corresponding
     #   classes to be instantiated.
     # @return [Hash] Returns the current class mapping.
-    def self.set_classes (classes)
-	@@classes.merge! classes
+    def self.set_classes (mapping)
+	@@classes.merge! mapping
+    end
+    # Change default proxy types globally
+    #
+    # @param mapping [Hash] A hash of native object classes and corresponding
+    #   factory types for proxy objects to be instantiated.
+    # @return [Hash] Returns the current proxy mapping.
+    def self.set_proxies (mapping)
+	@@proxies.merge! mapping
     end
+    ##################################################
     # Constructor
     #
     # @param options [Hash] Options hash
     # @option options [Proc] :loader Callback for $.use method
     # @option options [Proc] :missing_method Callback for missing methods
+    # @option options [Boolean] :regexp Set to true to enable regular
+    #  expression processing
     def initialize (options = {})
-	@classes, @factory_singletons = {}, {}
+	@classes, @proxies = {}, {}
 	@code, @namespace = nil, nil
-	@limits, @usage = {}, {}
+	@limits, @usage, @used = {}, {}, {}
 	@options = options
-	@used = {}
     end
-    # Parse a template from a string.
-    #
-    # @param template [String] A template string. Templates look
-    #   like <tt>'literal<<template code>>literal...'</tt>.
-    # @return [LtdTemplate]
-    def parse (template)
-	@usage = {}
-	tokens = []
-	literal = true
-	trim_next = false
-	# Template "text<<code>>text<<code>>..." =>
-	# (text, code, text, code, ...)
-	template.split(/<<(?!<)((?:[^<>]|<[^<]|>[^>])*)>>/s).each do |part|
-	    if part.length > 0
-		if literal
-		    part.sub!(/^\s+/s, '') if trim_next
-		    tokens.push [ :ext_string, part ]
-		else
-		    if part[0] == '.'
-			tokens[-1][1].sub!(/\s+$/s, '') if
-			  tokens[0] and tokens[-1][0] == :ext_string
-			part = part[1..-1] if part.length > 1
-		    end
-		    part = part[0..-2] if trim_next = (part[-1] == '.')
-		    tokens += get_tokens part
-		end
-	    else
-		trim_next = false
-	    end
-	    literal = !literal
-	end
-	@code = parse_template tokens
-	self
-    end
+    ##################################################
-    # Override default factory classes for this template instance.
+    # Throw an exception if a resource limit has been exceeded.
     #
-    # @param classes [Hash] A hash of factory symbols and corresponding
-    #   classes to be instantiated.
-    # @return [LtdTemplate]
-    def set_classes (classes)
-	@classes.merge! classes
-	self
+    # @param resource [Symbol] The resource limit to be checked.
+    def check_limit (resource)
+	if @limits[resource] && @usage[resource] &&
+	  @usage[resource] > @limits[resource]
+	    @exceeded = resource
+	    raise LtdTemplate::ResourceLimitExceeded.new(
+	      "Exceeded #{resource} #{@limits[resource]}")
+	end
     end
-    # Generate new code/value objects.
+    # Generate new code, value, or proxy objects.
     #
     # @param type [Symbol] The symbol for the type of object to generate,
-    #   e.g. :number, :string, :implicit_block, etc.
+    #   e.g. :number_proxy, :string_proxy, :code_block, etc.
     # @param args [Array] Type-specific initialization parameters.
     # @return Returns the new code/value object.
     def factory (type, *args)
 	use :factory
-	type = @classes[type] || @@classes[type]
-	if type.is_a? String
-	    file = type.downcase.gsub '::', File::SEPARATOR
-	    require file
-	    eval(type).instance(self, *args)
-	else
-	    type.instance(self, *args)
+	spec = @classes[type] || @@classes[type]
+	case spec
+	when nil
+	    raise ArgumentError, "Unknown template factory type #{type}"
+	when String
+	    # Convert the class name to a class on first use and cache it
+	    require spec.downcase.gsub('::', File::SEPARATOR)
+	    @classes[type] = klass = eval(spec)
+	else klass = spec
 	end
-    end
-    # Shortcut for frequently used template factory :nil
-    def nil; @factory_singletons[:nil] || factory(:nil); end
-    # Render the template.
-    #
-    # The options hash may include :parameters, which may be an array or
-    # hash. These values will form the parameter array "_" in the root
-    # namespace.
-    #
-    # @param options [Hash] Rendering options.
-    # @return [String] The result of rendering the template.
-    def render (options = {})
-	@exceeded = nil		# No limit exceeded yet
-	@namespace = nil	# Reset the namespace stack between runs
-	@usage = {}		# Reset resource usage
-	@used = {}		# No libraries used yet
-	#
-	# Accept template parameters from an array or hash.
-	#
-	parameters = factory :array
-	parameters.set_from_array options[:parameters] if
-	  options[:parameters].is_a? Array
-	parameters.set_from_hash options[:parameters] if
-	  options[:parameters].is_a? Hash
-	#
-	# Create the root namespace and evaluate the template code.
-	#
-	push_namespace 'render', parameters
-	@code ? @code.get_value.to_text : ''
-    end
-    # Push a new namespace onto the namespace stack.
-    #
-    # @param method [String] The (native) method string. This will be
-    #   available as <tt>$.method</tt> within the template.
-    # @param parameters [Array<LtdTemplate::Code>] These are code blocks
-    #   to set the namespace parameters (available as the "_" array in the
-    #   template).
-    # @param opts [Hash] Options hash.
-    # @option opts [LtdTemplate::Value] :target The target of the method
-    #   call. This will be available as <tt>$.target</tt> within the template.
-    def push_namespace (method, parameters = nil, opts = {})
-	use :namespaces
-	use :namespace_depth
-	@namespace = factory :namespace, method, parameters, @namespace
-	@namespace.target = opts[:target] if opts[:target]
-    end
-    # Pop the current namespace from the stack.
-    def pop_namespace
-	if @namespace.parent
-	    @namespace = @namespace.parent
-	    use :namespace_depth, -1
+	use type
+	args.unshift self if klass.is_a? LtdTemplate::Consumer
+	if klass.respond_to? :new then klass.new *args
+	else klass
 	end
     end
-    # Track incremental usage of a resource.
+    # Convert a string into an array of parser tokens.
     #
-    # @param resource [Symbol] The resource being used.
-    # @param amount [Integer] The additional amount of the resource being
-    #   used (or released, if negative).
-    def use (resource, amount = 1)
-	@usage[resource] ||= 0
-	@usage[resource] += amount
-	check_limit resource
-    end
-    # Track peak usage of a resource.
-    #
-    # @param resource [Symbol] The resource being used.
-    # @param amount [Integer] The total amount of the resource currently
-    #   being used.
-    def using (resource, amount)
-	@usage[resource] ||= 0
-	@usage[resource] = amount if amount > @usage[resource]
-	check_limit resource
-    end
-    # Throw an exception if a resource limit has been exceeded.
-    #
-    # @param resource [Symbol] The resource limit to be checked.
-    def check_limit (resource)
-	if @limits[resource] and @usage[resource] and
-	  @usage[resource] > @limits[resource]
-	    @exceeded = resource
-	    raise LtdTemplate::ResourceLimitExceeded
-	end
-    end
-    # Convert a string into an array of parsing tokens.
-    #
-    # @param str [String] The string to split into parsing tokens.
+    # @param str [String] The string to split into parser tokens.
     # @return [Array<Array>]
     def get_tokens (str)
 	tokens = []
@@ -297,11 +238,12 @@ class LtdTemplate
 		tokens.push [ :string, parse_strlit($1) ]
 	    elsif token =~ /^-?\d+(?:\.\d+)?/
 		# Numeric literal
-		tokens.push [ :number, token ]
+		tokens.push [ :number, token =~ /\./ ?
+		  token.to_f : token.to_i ]
 	    elsif TOKEN_MAP[token]
 		# Delimiter
 		tokens.push [ TOKEN_MAP[token] ]
-	    elsif token =~ /^[@^][a-z0-9_]|^[a-z_]|^\$$/i
+	    elsif token =~ /^[@^][a-z0-9_]|^[a-z_]|^[@^\$]$/i
 		# Variable or alphanumeric method name
 		tokens.push [ :name, token ]
 	    else
@@ -313,11 +255,45 @@ class LtdTemplate
 	tokens
     end
-    # This is the top-level token parser.
+    # Don't "spill our guts" upon inspection.
+    def inspect; "#<#{self.class.name}##{self.object_id}>"; end
+    # Parse a template from a string.
     #
-    # @param tokens [Array<Array>] The tokens to be parsed.
-    # @return [LtdTemplate::Code] The implementation code.
-    def parse_template (tokens); parse_block tokens; end
+    # @param template [String] A template string. Templates look
+    #   like <tt>'literal<<template code>>literal...'</tt>.
+    # @return [LtdTemplate]
+    def parse (template)
+	@usage = {}
+	tokens = []
+	literal = true
+	trim_next = false
+	# Template "text<<code>>text<<code>>..." =>
+	# (text, code, text, code, ...)
+	template.split(/<<(?!<)((?:[^<>]|<[^<]|>[^>])*)>>/s).each do |part|
+	    if part.length > 0
+		if literal
+		    part.sub!(/^\s+/s, '') if trim_next
+		    tokens.push [ :ext_string, part ]
+		else
+		    if part[0] == '.'
+			tokens[-1][1].sub!(/\s+$/s, '') if
+			  tokens[0] and tokens[-1][0] == :ext_string
+			part = part[1..-1] if part.length > 1
+		    end
+		    part = part[0..-2] if trim_next = (part[-1] == '.')
+		    tokens += get_tokens part
+		end
+	    else
+		trim_next = false
+	    end
+	    literal = !literal
+	end
+	@code = parse_template tokens
+	self
+    end
     # Parse a code block, stopping at any stop token.
     #
@@ -332,10 +308,8 @@ class LtdTemplate
 	    token = tokens.shift# Consume the current token
 	    case token[0]
-	    when :string, :ext_string	# string literal
-		code.push factory(:string, token[1])
-	    when :number	# numeric literal
-		code.push factory(:number, token[1])
+	    when :string, :ext_string, :number	# string and numeric literals
+		code.push token[1]
 	    when :name		# variable
 		code.push factory(:variable, token[1])
 	    when :lbrack	# variable element subscripts
@@ -361,41 +335,13 @@ class LtdTemplate
 		params = parse_parameters tokens
 		code.push factory(:call, code.pop, 'call', params) if code[0]
 	    when :lbrace	# explicit code block
-		code.push factory(:explicit_block,
+		code.push factory(:code_block,
 		  parse_block(tokens, [ :rbrace ]))
 		tokens.shift if tokens[0]	# Consume }
 	    end
 	end
-	(code.size == 1) ? code[0] : factory(:implied_block, code)
-    end
-    # Parse subscripts after the opening left bracket
-    #
-    # @param tokens [Array<Array>]] The token stream.
-    # @return [Array<LtdTemplate::Code>]
-    def parse_subscripts (tokens)
-	subs = parse_list tokens, [ :rbrack ], [ :lbrack ]
-	tokens.shift		# Consume ]
-	subs
-    end
-    # Parse a positional and/or named parameter list
-    #
-    # @param tokens [Array<Array>] The token stream.
-    # @return [LtdTemplate::Code::Parameters]
-    def parse_parameters (tokens)
-	positional = parse_list tokens, [ :dotdot, :rparen ]
-	if tokens[0] and tokens[0][0] == :dotdot
-	    tokens.shift	# Consume ..
-	    named = parse_list tokens, [ :rparen ]
-	else
-	    named = nil
-	end
-	tokens.shift		# Consume )
-	factory :parameters, positional, named
+	(code.size == 1) ? code[0] : factory(:code_seq, code)
     end
     # Common code for parsing various lists.
@@ -425,6 +371,24 @@ class LtdTemplate
 	list
     end
+    # Parse a positional and/or named parameter list
+    #
+    # @param tokens [Array<Array>] The token stream.
+    # @return [LtdTemplate::Code::Parameters]
+    def parse_parameters (tokens)
+	positional = parse_list tokens, [ :dotdot, :rparen ]
+	if tokens[0] and tokens[0][0] == :dotdot
+	    tokens.shift	# Consume ..
+	    named = parse_list tokens, [ :rparen ]
+	else
+	    named = nil
+	end
+	tokens.shift		# Consume )
+	factory :parameters, positional, named
+    end
     # Parse escape sequences in string literals.
     #
     #  These are the same as in Ruby double-quoted strings:
@@ -456,7 +420,153 @@ class LtdTemplate
 	  end.join ''
     end
+    # Parse subscripts after the opening left bracket
+    #
+    # @param tokens [Array<Array>]] The token stream.
+    # @return [Array<LtdTemplate::Code>]
+    def parse_subscripts (tokens)
+	subs = parse_list tokens, [ :rbrack ], [ :lbrack ]
+	tokens.shift		# Consume ]
+	subs
+    end
+    # This is the top-level token parser.
+    #
+    # @param tokens [Array<Array>] The tokens to be parsed.
+    def parse_template (tokens); parse_block tokens; end
+    # Pop the current namespace from the stack.
+    def pop_namespace
+	if @namespace.parent
+	    @namespace = @namespace.parent
+	    use :namespace_depth, -1
+	end
+    end
+    # Return the factory type symbol for a value's method handler class.
+    #
+    # @param type [Class] The value's class.
+    # @return The factory type symbol for the value's method-handler class.
+    def proxy_type (type)
+	if type
+	    type_name = type.name
+	    if !@proxies.has_key? type_name
+		# No local proxy class for this type; check the global
+		# settings and the proxy type for the superclass.
+		@proxies[type_name] = @@proxies[type_name] ||
+		  proxy_type(type.superclass)
+	    end
+	    @proxies[type_name]
+	else
+	    nil
+	end
+    end
+    # Push a new namespace onto the namespace stack.
+    #
+    # @param method [String] The (native) method string. This will be
+    #   available as <tt>$.method</tt> within the template.
+    # @param parameters [Sarah] The code block parameters (available as
+    #   the "_" array in the template).
+    # @param opts [Hash] Options hash.
+    # @option opts [Object] :target The target of the method
+    #   call. This will be available as <tt>$.target</tt> within the template.
+    def push_namespace (method, parameters = nil, opts = {})
+	use :namespaces
+	use :namespace_depth
+	@namespace = factory :namespace, method, parameters, @namespace
+	@namespace.target = opts[:target] if opts[:target]
+    end
+    # Render the template.
+    #
+    # The options hash may include :parameters, which may be an array or
+    # hash. These values will form the parameter array "_" in the root
+    # namespace.
+    #
+    # @param options [Hash] Rendering options.
+    # @option options [Array|Sarah] :parameters Parameters (copied to
+    #  array "_" in the template)
+    # @option options [Boolean] :cleanup Set to false to disable
+    #  post-rendering cleanup.
+    # @return [String] The result of rendering the template.
+    def render (options = {})
+	#
+	# Reset for each rendering
+	#
+	@exceeded, @usage, @used = nil, {}, {}
+	@namespace = nil
+	#
+	# Create the root namespace and evaluate the template code.
+	#
+	if @code
+	    params = Sarah.new
+	    params.set *options[:parameters] if options[:parameters]
+	    push_namespace 'render', params
+	    rubyversed(@code).evaluate.in_rubyverse(self).tpl_text
+	else ''
+	end
+    ensure
+	self.rubyverse_map.clear unless options[:cleanup] == false
+    end
+    # Return an object to handle template methods for the supplied object.
+    #
+    # Unrecognized object types will be treated as nil.
+    def rubyverse_new (object)
+	if object.is_a? LtdTemplate::Method_Handler
+	    object	# The object handles its own template methods.
+	elsif type = proxy_type(object.class)
+	    factory type, object
+	else rubyversed nil
+	end
+    end
+    # Override the default factory class mapping for this template instance.
+    #
+    # @param mapping [Hash] A hash of factory symbols and corresponding
+    #   classes to be instantiated.
+    # @return [LtdTemplate]
+    def set_classes (mapping)
+	@classes.merge! mapping
+	self
+    end
+    # Override the default proxy types for this template instance.
+    #
+    # @param mapping [Hash] A hash of class names and corresponding
+    #   factory types for proxy objects to be instantiated.
+    # @return [LtdTemplate]
+    def set_proxies (mapping)
+	@proxies.merge! mapping
+	self
+    end
+    # Track incremental usage of a resource.
+    #
+    # @param resource [Symbol] The resource being used.
+    # @param amount [Integer] The additional amount of the resource being
+    #   used (or released, if negative).
+    def use (resource, amount = 1)
+	@usage[resource] ||= 0
+	@usage[resource] += amount
+	check_limit resource
+    end
+    # Track peak usage of a resource.
+    #
+    # @param resource [Symbol] The resource being used.
+    # @param amount [Integer] The total amount of the resource currently
+    #   being used.
+    def using (resource, amount)
+	@usage[resource] ||= 0
+	if amount > @usage[resource]
+	    @usage[resource] = amount
+	    check_limit resource
+	end
+    end
 end
-# This exception is raised when a resource limit is exceeded.
-class LtdTemplate::ResourceLimitExceeded < RuntimeError; end
+# END