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

ltdtemplate 0.2.4 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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