ltdtemplate 0.2.4 → 1.0.0

data/lib/ltdtemplate/code.rb

@@ -1,103 +1,30 @@
-# LtdTemplate::Code - Base class for LtdTemplate code/value objects
+# LtdTemplate::Code - Base class for LtdTemplate code objects
 #
-# @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
 
-class LtdTemplate; end
+require 'ltdtemplate'
 
 class LtdTemplate::Code
 
-    # @!attribute [r] tpl_methods
-    # @return [Array<LtdTemplate::Value::Code_Block>]
-    # The code blocks bound to non-array values.
-    attr_reader :tpl_methods
-
-    # Return a new factory object instance (or a singleton in some
-    # subclasses, e.g. nil).
-    #
-    # @param args [Array] Class-specific initializer parameters.
-    def self.instance (*args); self.new(*args); end
+    # All derived classes are initialized with the template object and
+    # handle their own template methods.
+    extend LtdTemplate::Consumer
+    include LtdTemplate::Method_Handler
 
     # Initialize the object with a link to the associated template.
     #
     # @param template [LtdTemplate] The associated template object.
-    def initialize (template)
-	@template = template
-	@tpl_methods = {}
-    end
-
-    # Does a non-array value have a particular template method?
-    #
-    # @param key [String] The (native) string for the method.
-    # @return [Boolean]
-    def has_item? (key); @tpl_methods.has_key? key; end
-
-    # Return a non-array value's method code block (if set).
-    #
-    # @param key [String] The (native) string for the method.
-    # @return [LtdTemplate::Value::Code_Block]
-    def get_item (key)
-	(@tpl_methods.has_key? key) ? @tpl_methods[key] : @template.nil
-    end
+    def initialize (template); @template = template; end
 
-    # Set a non-array value's method code block.
-    #
-    # @param key [String] The (native) string for the method.
-    # @param value [LtdTemplate::Value::Code_Block] The code block
-    #   for the method.
-    def set_item (key, value); @tpl_methods[key] = value; end
-
-    # No-op setting a value. (Typically only variables can change their
-    # primary values.)
-    #
-    # @param value The value to set. (Ignored.)
-    # @return [LtdTemplate::Code]
-    def set_value (value); self; end
-
-    # Is this value set? Always true except for unset variables.
-    #
-    # @return [true]
-    def is_set?; true; end
-
-    # Implement "=" (assignment). Note that set_value is a no-op except
-    # for variables and array subscripts.
-    #
-    # @param opts [Hash] A hash of method options.
-    # @option opts [LtdTemplate::Value::Parameters] :parameters The method
-    #   parameters.
-    # @return [LtdTemplate::Value::Nil]
-    def do_set (opts)
-	if params = opts[:parameters]
-	    set_value(params.scalar? ? params.positional[0] : params)
-	end
-	@template.nil
+    def inspect
+	"#<#{self.class.name}##{self.object_id} for #{@template.inspect}>"
     end
 
-    # Try to execute code-block methods bound to the object or object
-    # class. Returns the return value from the code block or t-nil.
-    def do_method (opts, class_name = nil)
-	method = nil
-	if name = opts[:method]
-	    if @tpl_methods.has_key? name
-		method = @tpl_methods[name]
-	    elsif class_name
-		class_var = @template.factory :variable, class_name
-		method = class_var.target.tpl_methods[name] if
-		  class_var.is_set?
-	    end
-	end
-	if method
-	    opts[:target] = self
-	    method.get_value opts
-	elsif mmproc = @template.options[:missing_method]
-	    mmproc.call(@template, self, opts) || @template.nil
-	else
-	    @template.nil
-	end
-    end
+    # Shortcut to rubyversed in the template.
+    def rubyversed (obj); @template.rubyversed(obj); end
 
 end
 
-# This is the parent namespace for value code classes.
-class LtdTemplate::Value; end
+# END

data/lib/ltdtemplate/code/call.rb

@@ -1,8 +1,8 @@
 # LtdTemplate::Code::Call - Represents a method call in an LtdTemplate
 #
-# Author:: Brian Katzung <briank@kappacs.com>, Kappa Computer Solutions, LLC
-# Copyright:: 2013 Brian Katzung and Kappa Computer Solutions, LLC
-# License:: MIT License
+# @author Brian Katzung (briank@kappacs.com), Kappa Computer Solutions, LLC
+# @copyright 2013-2014 Brian Katzung and Kappa Computer Solutions, LLC
+# @license MIT License
 
 require 'ltdtemplate/code'
 
@@ -11,9 +11,10 @@ class LtdTemplate::Code::Call < LtdTemplate::Code
     # Initialize a method call object.
     #
     # @param template [LtdTemplate] The template object
-    # @param target [LtdTemplate::Code] The target object
-    # @param method [String] The method to call
-    # @param parameters [LtdTemplate::Code::Parameters] The call parameters
+    # @param target (Code for) the target to call
+    # @param method [String] The method to invoke
+    # @param parameters [LtdTemplate::Code::Parameters] Code blocks for
+    #  the method parameters
     def initialize (template, target, method, parameters)
 	super template
 	@target, @method, @parameters = target, method, parameters
@@ -23,24 +24,27 @@ class LtdTemplate::Code::Call < LtdTemplate::Code
     #
     # @param opts [Hash] Option hash
     # @option opts [String] :method A method to call on the return value
-    def get_value (opts = {})
+    def evaluate (opts = {})
 	# Increase the call count and call depth.
+	# RESOURCE calls: Total number of method calls
 	@template.use :calls
+	# RESOURCE call_depth: The current method call depth
 	@template.use :call_depth
 
-	result = @target.get_value({ :method => @method,
-	  :parameters => @parameters.get_value })
+	# Invoke the method call that we encode against the target.
+	result = rubyversed(@target).evaluate({ :method => @method,
+	  :parameters => rubyversed(@parameters).evaluate })
 
 	# Decrease the call depth.
 	@template.use :call_depth, -1
 
-	opts[:method] ? result.get_value(opts) : result
-    end
+	# Invoke the method call requested by our invoker against the result.
+	result = rubyversed(result).evaluate({ :method => opts[:method],
+	  :parameters => opts[:parameters] }) if opts[:method]
 
-    # Pass has/get/set_item calls through to result of call;
-    # in some cases it might be the same value each time.
-    def has_item? (key); get_value.has_item? key; end
-    def get_item (key); get_value.get_item key; end
-    def set_item (key, value); get_value.set_item key, value; end
+	result
+    end
 
 end
+
+# END

data/lib/ltdtemplate/code/parameters.rb

@@ -5,15 +5,16 @@
 # License:: MIT License
 
 require 'ltdtemplate/code'
+require 'ltdtemplate/value/array_splat'
+
+module LtdTemplate::Univalue; end
 
 class LtdTemplate::Code::Parameters < LtdTemplate::Code
 
     attr_reader :positional, :named
 
-    #
     # Create a parameter list builder with code to generate positional
     # values and possibly code to generate named values.
-    #
     def initialize (template, positional = [], named = nil)
 	super template
 
@@ -21,48 +22,44 @@ class LtdTemplate::Code::Parameters < LtdTemplate::Code
 	@positional, @named = positional, named
     end
 
-    #
     # Evaluate the code provided for the positional and named parameters
-    # and return a corresponding array t-value.
+    # and return a corresponding Sarah.
     #
-    def get_value (opts = {})
-	named = {}
+    # @return [Sarah]
+    def evaluate (opts = {})
+	params = @template.factory :array
 
 	# Process the positional parameters (pos1, ..., posN)
-	positional = @positional.map do |code|
-	    val = code.get_value
-	    if val.is_a? LtdTemplate::Code::Parameters
-		if val.named.is_a? Hash
-		    # Named parameters from array/
-		    val.named.each { |key, val| named[key] = val }
-		elsif val.named.is_a? Array
-		    # Named parameters from array%
-		    val.named.each_slice(2) do |key, val|
-			named[key.get_value.to_native] = val if val
-		    end
+	@positional.each do |code|
+	    value = rubyversed(code).evaluate
+	    if value.is_a? LtdTemplate::Value::Array_Splat
+		# Merge parameters from array/ or array%
+		# RESOURCE array_growth: Increases in array sizes
+		@template.use :array_growth, value.positional.size
+		params.concat value.positional
+		if value.named
+		    @template.use :array_growth, value.named.size / 2
+		    params.set_pairs *value.named
 		end
-		val.positional # Positional parameters from array/
-	    else val
+	    else params.push value
 	    end
-	end.flatten
+	end
 
 	# Process the named parameters (.. key1, val1, ..., keyN, valN)
 	if @named
-	    if @named.is_a? Hash then named.merge! @named
-	    else
-		@named.each_slice(2) do |key, val|
-		    named[key.get_value.to_native] = val.get_value if val
-		end
+	    @named.each_slice(2) do |k_code, v_code|
+		params[rubyversed(k_code).evaluate] =
+		  rubyversed(v_code).evaluate if v_code
 	    end
-	    scalar = false
-	else
-	    scalar = (positional.size == 1) && named.empty?
 	end
 
-	array = @template.factory(:array).set_value(positional, named, scalar)
+	# Is this a candidate for scalar assignment?
+	params.extend LtdTemplate::Univalue if
+	  !@named && params.size(:seq) == 1
 
-	# Parameters may get called if chained, e.g. array/.type
-	opts[:method] ? array.get_value(opts) : array
+	params
     end
 
 end
+
+# END

data/lib/ltdtemplate/code/sequence.rb

@@ -0,0 +1,39 @@
+# LtdTemplate::Code::Sequence - Represents a code sequence (a list of
+#	code steps) in an LtdTemplate
+#
+# Code sequences do not accept parameters or generate new namespaces.
+# They are used for things like call parameters and subscript expressions.
+# See also: LtdTemplate::Value::Code_Block.
+#
+# @author Brian Katzung <briank@kappacs.com>, Kappa Computer Solutions, LLC
+# @copyright 2013-2014 Brian Katzung and Kappa Computer Solutions, LLC
+# @license MIT License
+
+require 'ltdtemplate/code'
+
+class LtdTemplate::Code::Sequence < LtdTemplate::Code
+
+    def initialize (template, code)
+	super template
+	@code = code
+    end
+
+    # Evaluate the code sequence.
+    def evaluate (opts = {})
+	values = @code.map do |code|
+	    # RESOURCE code_steps: Total number of code steps executed
+	    @template.use :code_steps
+	    rubyversed(code).evaluate
+	end
+	case values.size
+	when 0 then nil
+	when 1 then values[0]
+	else values.map { |val| rubyversed(val).tpl_text }.join('').
+	  tap { |res| @template.using :string_length, res.length }
+	  # RESOURCE string_length: Length of longest modified string
+	end
+    end
+
+end
+
+# END

data/lib/ltdtemplate/code/subscript.rb

@@ -1,11 +1,12 @@
 # LtdTemplate::Code::Subscript - Represents an array subscript in
 #	an LtdTemplate
 #
-# Author:: Brian Katzung <briank@kappacs.com>, Kappa Computer Solutions, LLC
-# Copyright:: 2013 Brian Katzung and Kappa Computer Solutions, LLC
-# License:: MIT License
+# @author Brian Katzung <briank@kappacs.com>, Kappa Computer Solutions, LLC
+# @copyright 2013-2014 Brian Katzung and Kappa Computer Solutions, LLC
+# @license MIT License
 
 require 'ltdtemplate/code'
+require 'ltdtemplate/value/array_splat'
 
 class LtdTemplate::Code::Subscript < LtdTemplate::Code
 
@@ -15,67 +16,73 @@ class LtdTemplate::Code::Subscript < LtdTemplate::Code
     end
 
     #
-    # Return native subscripts calculated from the supplied code blocks.
+    # Evaluate the target's value.
     #
-    def native_subs (usage = false)
-	nsubs = @subscripts ?
-	  @subscripts.map { |sub| sub.get_value.to_native }.flatten : []
-	num_subs = nsubs.size
-	if usage and num_subs > 0
-	    @template.using :subscript_depth, num_subs
-	    @template.use :subscripts, num_subs
+    def evaluate (opts = {})
+	case opts[:method]
+	when '=', '?=' then do_set opts # Support array assignment
+	else rubyversed(target(true)).evaluate opts
 	end
-	nsubs
     end
 
     #
-    # Return the target value, variable[sub1, ..., subN]
+    # Return subscripts calculated from the supplied code blocks.
     #
-    def target (usage = false)
-	current = @base.get_value
-	native_subs(usage).each { |subs| current = current.get_item subs }
-	current
-    end
+    def evaluate_subscripts (meter = false)
+	subscripts = []
+	@subscripts.each do |code|
+	    subscript = rubyversed(code).evaluate
+	    case subscript
+	    when LtdTemplate::Value::Array_Splat
+		if meter && (size = subscript.positional.size) > 1
+		    # RESOURCE subscripts: Total number of subscripts
+		    # RESOURCE subscript_depth: Deepest subscript depth
+		    @template.use :subscripts, size - 1
+		    @template.using :subscript_depth, size
+		end
+		subscripts.concat subscript.positional
+	    when Numeric, String then subscripts << subscript
+	    end
+	end
 
-    #
-    # Implement the subscript interface for the target.
-    #
-    def has_item? (key); target.has_item? key; end
-    def get_item (key); target.get_item key; end
-    def set_item (key, value); target(true).set_item key, value; end
+	if meter
+	    @template.use :subscripts, @subscripts.size
+	    @template.using :subscript_depth, subscripts.size
+	end
+
+	subscripts
+    end
 
     #
-    # Set the target's value.
+    # Return the target value, variable[sub1, ..., subN]
     #
-    def set_value (value)
-	subs = native_subs true
-	if subs.size == 0
-	    # If there are no subscripts, just use the base.
-	    @base.set_value value
-	else
-	    #
-	    # Traverse all but the last subscript, trying to autovivicate
-	    # new arrays as we go. This will silently fail if there is an
-	    # existing non-array value somewhere.
-	    #
-	    current = @base
-	    current.set_value @template.factory :array unless current.is_set?
-	    subs[0..-2].each do |sub|
-		if !current.has_item? sub
-		    current.set_item sub, @template.factory(:array)
-		end
-		current = current.get_item sub
-	    end
-	    current.set_item subs[-1], value
+    def target (meter = false)
+	subscripts = evaluate_subscripts meter
+	if subscripts.empty? then rubyversed(@base).evaluate
+	else rubyversed(@base).evaluate.in_rubyverse(@template)[*subscripts, {}]
 	end
-	self
     end
 
-    def get_value (opts = {})
-	case opts[:method]
-	when '=' then do_set opts	# see LtdTemplate::Code
-	else target.get_value opts
+    ##################################################
+
+    # Implement = and ?=
+    def do_set (opts)
+	subscripts = evaluate_subscripts true
+	if subscripts.empty?
+	    # Treat expression[] as expression
+	    rubyversed(@base).evaluate opts
+	elsif opts[:method] != '?=' ||
+	  rubyversed(@base).evaluate.in_rubyverse(@template)[*subscripts,
+	  {}].nil?
+	    # Assign if unconditional or unset
+	    params = opts[:parameters]
+	    params = params[0] if params.is_a? LtdTemplate::Univalue
+	    rubyversed(@base).evaluate.in_rubyverse(@template)[*subscripts,
+	      {}] = params
 	end
+	nil
     end
 
 end
+
+# END