ltdtemplate 0.1.0

data/lib/ltdtemplate/code/call.rb

@@ -0,0 +1,46 @@
+# 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
+
+require 'ltdtemplate/code'
+
+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
+    def initialize (template, target, method, parameters)
+	super template
+	@target, @method, @parameters = target, method, parameters
+    end
+
+    # Return the result of executing the call.
+    #
+    # @param opts [Hash] Option hash
+    # @option opts [String] :method A method to call on the return value
+    def get_value (opts = {})
+	# Increase the call count and call depth.
+	@template.use :calls
+	@template.use :call_depth
+
+	result = @target.get_value({ :method => @method,
+	  :parameters => @parameters.get_value })
+
+	# Decrease the call depth.
+	@template.use :call_depth, -1
+
+	opts[:method] ? result.get_value(opts) : result
+    end
+
+    # 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
+
+end

data/lib/ltdtemplate/code/code_block.rb

@@ -0,0 +1,30 @@
+# LtdTemplate::Code::Code_Block - Represents a code block (a list of
+#	code steps) in an LtdTemplate
+#
+# Implied code blocks 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 Brian Katzung and Kappa Computer Solutions, LLC
+# License:: MIT License
+
+require 'ltdtemplate/code'
+
+class LtdTemplate::Code::Code_Block < LtdTemplate::Code
+
+    def initialize (template, code)
+	super template
+	@code = code
+    end
+
+    def get_value (opts = {})
+	values = @code.map { |part| part.get_value }.flatten
+	case values.size
+	when 0 then @template.factory :nil
+	when 1 then values[0]
+	else @template.factory(:array).set_value(values)
+	end
+    end
+
+end

data/lib/ltdtemplate/code/parameters.rb

@@ -0,0 +1,40 @@
+# LtdTemplate::Code::Parameters - Represents call parameters 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
+
+require 'ltdtemplate/code'
+
+class LtdTemplate::Code::Parameters < LtdTemplate::Code
+
+    #
+    # 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
+
+	# Save the code blocks for positional and named parameters.
+	@positional, @named = positional, named
+    end
+
+    #
+    # Evaluate the code provided for the positional and named parameters
+    # and return a corresponding array t-value.
+    #
+    def get_value (opts = {})
+	positional = @positional.map { |val| val.get_value }
+	named = {}
+	if @named
+	    @named.each_slice(2) do |key, val|
+		named[key.get_value.to_native] = val.get_value
+	    end
+	    scalar = false
+	else
+	    scalar = positional.size == 1
+	end
+	@template.factory(:array).set_value(positional, named, scalar)
+    end
+
+end

data/lib/ltdtemplate/code/subscript.rb

@@ -0,0 +1,81 @@
+# 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
+
+require 'ltdtemplate/code'
+
+class LtdTemplate::Code::Subscript < LtdTemplate::Code
+
+    def initialize (template, base, subscripts)
+	super template
+	@base, @subscripts = base, subscripts
+    end
+
+    #
+    # Return native subscripts calculated from the supplied code blocks.
+    #
+    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
+	end
+	nsubs
+    end
+
+    #
+    # Return the target value, variable[sub1, ..., subN]
+    #
+    def target (usage = false)
+	current = @base.get_value
+	native_subs(usage).each { |subs| current = current.get_item subs }
+	current
+    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
+
+    #
+    # Set the target's value.
+    #
+    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
+	end
+	self
+    end
+
+    def get_value (opts = {})
+	case opts[:method]
+	when '=' then do_set opts	# see LtdTemplate::Code
+	else target.get_value opts
+	end
+    end
+
+end

data/lib/ltdtemplate/code/variable.rb

@@ -0,0 +1,77 @@
+# LtdTemplate::Code::Variable - Represents a variable 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
+
+require 'ltdtemplate/code'
+
+class LtdTemplate::Code::Variable < LtdTemplate::Code
+
+    def initialize (template, name)
+	super template
+	case name[0]
+	when '@', '^'
+	    # @var is in the root namespace
+	    # ^var is in the parent namespace
+	    @modifier = name[0]
+	    @name = name[1..-1]
+	    @name = @name.to_i if @name =~ /^(?:0|[1-9]\d*)$/
+	else
+	    # Standard bottom-to-top namespace search variable
+	    @modifier = nil
+	    @name = name
+	end
+    end
+
+    #
+    # Return the namespace in which this variable currently resides
+    # (or would reside, if it doesn't currently exist).
+    #
+    def namespace
+	case @modifier
+	when '@' then base = @template.namespace.root
+	when '^' then base = @template.namespace.parent || @template.namespace
+	else base = @template.namespace
+	end
+	base.find_item(@name) || base
+    end
+
+    #
+    # Return the namespace item for this variable.
+    #
+    def target; namespace.get_item(@name); end
+
+    #
+    # Implement the subscripting interface.
+    #
+    def has_item? (key); target.has_item? key; end
+    def get_item (key); target.get_item key; end
+    def set_item (key, value); target.set_item key, value; end
+
+    #
+    # Try to set the value.
+    #
+    def set_value (value)
+	namespace.set_item(@name, value)
+    end
+
+    #
+    # Is this variable set?
+    # Among other possible uses, this is needed for determining when to
+    # auto-vivicate array subscripts.
+    #
+    def is_set?; namespace.has_item? @name; end
+
+    def get_value (opts = {})
+	case opts[:method]
+	when '=' then do_set opts	# see LtdTemplate::Code
+	when '?='
+	    if is_set? then @template.factory :nil
+	    else do_set opts
+	    end
+	else target.get_value opts
+	end
+    end
+
+end

data/lib/ltdtemplate/code.rb

@@ -0,0 +1,102 @@
+class LtdTemplate; end
+
+# LtdTemplate::Code - Base class for LtdTemplate code/value objects
+#
+# @author Brian Katzung <briank@kappacs.com>, Kappa Computer Solutions, LLC
+# @copyright 2013 Brian Katzung and Kappa Computer Solutions, LLC
+# @license MIT License
+
+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
+
+    # 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.factory(:nil)
+    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.factory :nil
+    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
+	else
+	    @template.factory :nil
+	end
+    end
+
+end
+
+# This is the parent namespace for value code classes.
+class LtdTemplate::Value; end

data/lib/ltdtemplate/value/array.rb

@@ -0,0 +1,168 @@
+# LtdTemplate::Value::Array - Represents a combination array/hash value
+#	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
+
+require 'ltdtemplate/code'
+require 'sarah'
+
+class LtdTemplate::Value::Array < LtdTemplate::Code
+
+    attr_reader :sarah
+
+    def initialize (template)
+	super template
+	@sarah = Sarah.new
+	@scalar = false
+	@template.use :arrays
+    end
+
+    #
+    # Access positional (sequential) or named (random-access)
+    # parts of the array
+    #
+    def positional; @sarah.seq; end
+    def named; @sarah.rnd; end
+
+    #
+    # Implement the subscripting interface. Note that the most recent
+    # value is always used. (1 .. 0, 2, 0, 3)[0] is 3.
+    # Items set within (or at the end of) the positional range at the
+    # time will be positional. Otherwise, they will be named.
+    #
+    # Keys must be Ruby-native values; values must be template code
+    # or values.
+    #
+    def has_item? (key); @sarah.has_key? key; end
+    def get_item (key)
+	@sarah.has_key?(key) ? @sarah[key] : @template.factory(:nil)
+    end
+    def set_item (key, value)
+	@sarah[key] = value
+	@template.using :array_size, @sarah.size
+    end
+
+    def to_boolean; true; end
+    def to_native; @sarah.seq.map { |val| val.to_native }; end
+    def to_text; @sarah.seq.map { |val| val.to_text }.join ''; end
+
+    def get_value (opts = {})
+	case opts[:method]
+	when nil, 'call' then self
+	when 'class' then @template.factory :string, 'Array'
+	when 'join' then do_join opts
+	when 'pop', '->' then do_pop opts
+	when 'push', '+>' then do_push opts
+	when 'rnd_size' then @template.factory :number, @sarah.rnd_size
+	when 'seq_size' then @template.factory :number, @sarah.seq_size
+	when 'shift', '<-' then do_shift opts
+	when 'size' then @template.factory :number, @sarah.size
+	when 'type' then @template.factory :string, 'array'
+	when 'unshift', '<+' then do_unshift opts
+	else do_method opts, 'Array'
+	end
+    end
+
+    #
+    # Scalar assignment is used instead of array assignment if the
+    # parameter list contains exactly one positional parameter and
+    # the ".." operator was not used.
+    #
+    def scalar?; @scalar and @sarah.seq_size == 1; end
+
+    #
+    # Clear all current positional and named values
+    #
+    def clear
+	@sarah.clear
+	@scalar = false
+	self
+    end
+
+    #
+    # Set positional and possibly named values. Keys must be ruby-native
+    # values; values must be template code or values.
+    #
+    def set_value (positional, named = {}, scalar = false)
+	clear
+	@sarah.merge! positional, named
+	@scalar = scalar
+	self
+    end
+
+    #
+    # Set (recursively) from a native array.
+    #
+    def set_from_array (data)
+	clear
+	data.each_index { |i| set_item i, map_native_value(data[i]) }
+	self
+    end
+
+    #
+    # Set (recursively) from a native hash.
+    #
+    def set_from_hash (data)
+	clear
+	data.each { |key, val| set_item key, map_native_value(val) }
+	self
+    end
+
+    #
+    # Combine array element values into a string
+    #
+    def do_join (opts)
+	two = first = middle = last = ''
+	if params = opts[:parameters]
+	    params = params.positional
+	    if params.size > 3
+		two, first, middle, last =
+		  params[0..3].map { |val| val.get_value.to_text }
+	    elsif params.size > 0
+		two = first = middle = last = params[0].get_value.to_text
+	    end
+	end
+
+	text = @sarah.seq.map { |val| val.get_value.to_text }
+	@template.factory :string, case text.size
+	when 0 then ''
+	when 1 then text[0]
+	when 2 then "#{text[0]}#{two}#{text[1]}"
+	else "#{text[0]}#{first}" + text[1..-2].join(middle) +
+	  "#{last}#{text[-1]}"
+	end
+    end
+
+    def do_pop (opts)
+	@sarah.pop || @template.factory(:nil)
+    end
+
+    def do_push (opts)
+	if params = opts[:parameters] then @sarah.append! params.sarah end
+	@template.factory :nil
+    end
+
+    def do_shift (opts)
+	@sarah.shift || @template.factory(:nil)
+    end
+
+    def do_unshift (opts)
+	if params = opts[:parameters] then @sarah.insert! params.sarah end
+	@template.factory :nil
+    end
+
+    protected
+
+    def map_native_value (value)
+	return @template.factory :number, value if value.is_a? Numeric
+	return @template.factory :string, value if value.is_a? String
+	return @template.factory(:array).set_from_array value if
+	  value.is_a? Array
+	return @template.factory(:array).set_from_hash value if
+	  value.is_a? Hash
+	@template.factory :nil
+    end
+
+end

data/lib/ltdtemplate/value/boolean.rb

@@ -0,0 +1,79 @@
+# LtdTemplate::Value::Boolean - Represents true/false 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
+
+require 'ltdtemplate/code'
+
+class LtdTemplate::Value::Boolean < LtdTemplate::Code
+
+    # Use one shared true value and one shared false value per template.
+    def self.instance (template, bool)
+	template.factory_singletons[bool ? :bool_true : :bool_false] ||=
+	  self.new(template, bool)
+    end
+
+    def initialize (template, bool)
+	super template
+	@bool = bool
+    end
+
+    def to_boolean; @bool; end
+    def to_native; @bool; end
+    def to_text; ''; end
+
+    def get_value (opts = {})
+	case opts[:method]
+	when nil, 'call' then self
+	when 'class' then @template.factory :string, 'Boolean'
+	when 'str', 'string' then @template.factory :string,
+	  (@bool ? 'true' : 'false')
+	when 'type' then @template.factory :string, 'boolean'
+	when '+', '|', 'or' then do_or opts
+	when '*', '&', 'and' then do_and opts
+	when '!', 'not' then do_not opts
+	else do_method opts, 'Boolean'
+	end
+    end
+
+    # Implement +/| (or):
+    # bool|(bool1, ..., boolN)
+    # True if ANY boolean is true. Evaluates {} blocks until true.
+    def do_or (opts)
+	if not @bool and params = opts[:parameters]
+	    params.positional.each do |tval|
+		return @template.factory :boolean, true if
+		  tval.get_value(:method => 'call').to_boolean
+	    end
+	end
+	self
+    end
+
+    # Implement */& (and):
+    # bool&(bool1, ..., boolN)
+    # True if ALL booleans are true. Evaluates {} blocks until false.
+    def do_and (opts)
+	if @bool and params = opts[:parameters]
+	    params.positional.each do |tval|
+		return @template.factory :boolean, false unless
+		  tval.get_value(:method => 'call').to_boolean
+	    end
+	end
+	self
+    end
+
+    # Implement ! (not):
+    # bool!(bool1, ..., boolN)
+    # True if ALL booleans are false. Evaluates {} blocks until true.
+    def do_not (opts)
+	if !@bool and params = opts[:parameters]
+	    params.positional.each do |tval|
+		return @template.factory :boolean, false if
+		  tval.get_value(:method => 'call').to_boolean
+	    end
+	end
+	@template.factory :boolean, !@bool
+    end
+
+end

data/lib/ltdtemplate/value/code_block.rb

@@ -0,0 +1,40 @@
+# LtdTemplate::Value::Code_Block - Represents an explicit code block in an
+#	LtdTemplate
+#
+# Explicit code blocks are wrappers around implied code blocks. They are
+# essentially anonymous functions; they accept optional parameters and
+# create a new namespace for the duration of each execution.
+#
+# @author Brian Katzung <briank@kappacs.com>, Kappa Computer Solutions, LLC
+# @copyright 2013 Brian Katzung and Kappa Computer Solutions, LLC
+# @license MIT License
+
+require 'ltdtemplate/code'
+
+class LtdTemplate::Value::Code_Block < LtdTemplate::Code
+
+    attr_reader :code
+
+    def initialize (template, code)
+	super template
+	@code = code
+    end
+
+    def to_boolean; true; end
+    def to_native; self; end
+    def to_text; ''; end
+
+    def get_value (opts = {})
+	case opts[:method]
+	when nil then self
+	when 'type' then @template.factory :string, 'code'
+	else
+	    @template.push_namespace opts[:method], opts[:parameters],
+	      :target => (opts[:target] || self)
+	    result = @code.get_value
+	    @template.pop_namespace
+	    result
+	end
+    end
+
+end