ltdtemplate 0.2.4 → 1.0.0

data/lib/ltdtemplate/code/variable.rb

@@ -10,8 +10,7 @@ class LtdTemplate::Code::Variable < LtdTemplate::Code
 
     def initialize (template, name)
 	super template
-	case name[0]
-	when '@', '^'
+	if name.size > 1 && (name[0] == '@' || name[0] == '^')
 	    # @var is in the root namespace
 	    # ^var is in the parent namespace
 	    @modifier = name[0]
@@ -24,6 +23,25 @@ class LtdTemplate::Code::Variable < LtdTemplate::Code
 	end
     end
 
+    #
+    # Evaluate
+    #
+    def evaluate (opts = {})
+	case opts[:method]
+	when '=', '?='
+	    if opts[:method] != '?=' || self.namespace[@name].nil?
+		params = opts[:parameters]
+		params = params[0] if params.is_a? LtdTemplate::Univalue
+		self.namespace[@name] = params
+	    end
+	    nil
+	else
+	    self.namespace[@name] = "" if
+	      opts[:method] == 'methods' && self.namespace[@name].nil?
+	    rubyversed(self.namespace[@name]).evaluate opts
+	end
+    end
+
     #
     # Return the namespace in which this variable currently resides
     # (or would reside, if it doesn't currently exist).
@@ -37,41 +55,6 @@ class LtdTemplate::Code::Variable < LtdTemplate::Code
 	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.nil
-	    else do_set opts
-	    end
-	else target.get_value opts
-	end
-    end
-
 end
+
+# END

data/lib/ltdtemplate/proxy.rb

@@ -0,0 +1,26 @@
+# LtdTemplate::Proxy - Common code for LtdTemplate value proxies
+#
+# @author Brian Katzung (briank@kappacs.com), Kappa Computer Solutions, LLC
+# @copyright 2014 Brian Katzung and Kappa Computer Solutions, LLC
+# @license MIT License
+
+require 'ltdtemplate/value'
+
+class LtdTemplate::Proxy
+
+    include LtdTemplate::Value
+
+    def initialize (template, original)
+	super template
+	@original = original
+    end
+
+    # Return the Rubyverse original object.
+    def rubyverse_original; @original; end
+
+    # Shortcut to rubyversed in the tamplate.
+    def rubyversed (obj); @template.rubyversed obj; end
+
+end
+
+# END

data/lib/ltdtemplate/proxy/array.rb

@@ -0,0 +1,258 @@
+# LtdTemplate::Proxy::Array - Proxy for arrays, hashes, and Sarahs
+#	in an LtdTemplate
+#
+# @author Brian Katzung <briank@kappacs.com>, Kappa Computer Solutions, LLC
+# @copyright 2013-2014 Brian Katzung and Kappa Computer Solutions, LLC
+# @license MIT License
+
+require 'sarah'
+require 'xkeys'
+require 'ltdtemplate/proxy'
+require 'ltdtemplate/value/array_splat'
+
+class LtdTemplate::Proxy::Array < LtdTemplate::Proxy
+
+    # Proxy methods to access the underlying data structure.
+    # These must be #include'd before XKeys::Hash for proper
+    # method resolution.
+    Module.new do
+	def [] (*args); @original.[] *args; end
+	def []= (*args); @original.[]= *args; end
+	def fetch (*args); @original.fetch *args; end
+	def push (*args); @original.push *args; end
+    end.tap { |mod| include mod }
+    include XKeys::Hash
+
+    # Evaluate supported array methods.
+    def evaluate (opts = {})
+	# Methods supported for all proxied types.
+	case opts[:method]
+	when nil, 'call' then return @original
+	when 'class' then return 'Array'
+	when 'each', 'each_rnd', 'each_seq' then return do_each opts
+	when 'rnd_size' then return self.named.size
+	when 'seq_size' then return self.positional.size
+	when 'size' then return @original.size
+	when 'type' then return 'array'
+	when '/' 
+	  return @template.factory(:array_splat, self.positional,
+	    self.named.to_a.flatten(1)).tap do |splat|
+	    size = splat.positional.size + splat.named.size
+	    # RESOURCE array_growth: Increases in array sizes
+	    @template.use :array_growth, size
+	    # RESOURCE array_size: Size of largest modified array
+	    @template.using :array_size, size
+	    end
+	when '%' 
+	  return @template.factory(:array_splat, [],
+	    self.positional).tap do |splat|
+	    @template.use :array_growth, splat.named.size
+	    @template.using :array_size, splat.named.size
+	    end
+	end
+
+	# Methods supported by Array and Sarah objects.
+	case @original
+	when ::Array, Sarah
+	    case opts[:method]
+	    when 'join' then return do_join opts
+	    when 'pop', '->' then return do_pop opts
+	    when 'push', '+>' then return do_push opts
+	    when 'shift', '<-' then return do_shift opts
+	    when 'unshift', '<+' then return do_unshift opts
+	    end
+	end
+
+	super opts
+    end
+
+    # Meter usage when modifying the array.
+    #
+    # @param node [Array,Hash,Sarah] The array being updated.
+    # @param key [Object] The index/key being added/updated.
+    def meter (node, key)
+	case node
+	when ::Array
+	    if key == :[] then growth = 1	# (push)
+	    elsif key > node.size then growth = key - node.size
+	    else growth = 0			# existing index
+	    end
+	when Hash, Sarah
+	    growth = node.has_key?(key) ? 0 : 1
+	end
+	@template.use :array_growth, growth if growth > 0
+	@template.using :array_size, node.size + growth
+    end
+
+    # Access named (random-access) parts of the data structure.
+    def named
+	case @original
+	when Hash then @original
+	when Sarah
+	    # RESOURCE array: Total number of arrays created
+	    @template.use :array
+	    size = @original.size :nsq
+	    @template.use :array_growth, size
+	    @template.using :array_size, size
+	    @original.to_h :nsq
+	else {}
+	end
+    end
+
+    # Access positional (sequential) parts of the data structure.
+    def positional
+	case @original
+	when ::Array then @original
+	when Sarah
+	    @template.use :array
+	    size = @original.size :seq
+	    @template.use :array_growth, size
+	    @template.using :array_size, size
+	    @original.values :seq
+	else []
+	end
+    end
+
+    # Reflect original respond_to? :push, etc. for XKeys.
+    def respond_to? (method)
+	case method
+	when :[], :[]=, :fetch, :push then @original.respond_to? method
+	else super method
+	end
+    end
+
+    # The template text value is the concatenation of sequential text values.
+    def tpl_text
+	self.positional.map { |val| rubyversed(val).tpl_text }.join ''
+    end
+
+    # Return a new array (Sarah) for auto-vivification.
+    def xkeys_new (k2, info, opts)
+	meter info[:node], info[:key1]
+	@template.factory :array
+    end
+
+    # Check array growth on final assignment
+    def xkeys_on_final (node, key, value)
+	meter node, key
+    end
+
+    ############################################################
+
+    # Loop over each key, value
+    def do_each (opts)
+	results = @template.factory :array
+	if params = opts[:parameters] and params.size(:seq) > 0
+	    body = params[0]
+	    if opts[:method] != 'each_rnd'
+		(seq = self.positional).each_index do |idx|
+		    @template.use :iterations
+		    each_params = @template.factory(:array).
+		      push idx, self[idx]
+		    results.push body.evaluate(:method => 'each_seq',
+		      :parameters => each_params)
+		    @template.using :array_size, results.size
+		end
+	    end
+	    if opts[:method] != 'each_seq'
+		(rnd = self.named).each do |key, val|
+		    @template.use :iterations
+		    each_params = @template.factory(:array).
+		      push key, val
+		    results.push body.evaluate(:method => 'each_rnd',
+		      :parameters => each_params)
+		    @template.using :array_size, results.size
+		end
+	    end
+	end
+	results
+    end
+
+    # Combine sequential array element values into a string
+    def do_join (opts)
+	two = first = middle = last = ''
+	if params = opts[:parameters]
+	    if params.size(:seq) > 3
+		two, first, middle, last = params[0..3].values
+	    elsif params.size(:seq) > 0
+		two = first = middle = last = params[0]
+	    end
+	end
+
+	text = self.positional.map { |val| rubyversed(val).tpl_text }
+	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.tap do |str|
+	    # RESOURCE string_total: Combined length of computed strings
+	    @template.use :string_total, str.size
+	    # RESOURCE string_length: Length of longest modified string
+	    @template.using :string_length, str.size
+	end
+    end
+
+    # Pop a value off the right end of the array.
+    def do_pop (opts)
+	if @original.respond_to? :pop
+	    @template.use :array_growth, -1
+	    @original.pop
+	else nil
+	end
+    end
+
+    # Push values onto the right end of the array.
+    def do_push (opts)
+	if params = opts[:parameters]
+	    case @original
+	    when ::Array
+		@template.use :array_growth, params.size(:seq)
+		@original.push *params.values(:seq)
+	    when Sarah
+		# Assume worst-case growth, then "push"
+		@template.use :array_growth, params.size
+		adjust = @original.size + params.size
+		@original.append! params
+
+		# Adjust actual growth if needed
+		adjust = @original.size - adjust
+		@template.use :array_growth, adjust if adjust < 0
+	    end
+	    @template.using :array_size, @original.size
+	end
+	nil
+    end
+
+    # Shift a value off the left end of the array.
+    def do_shift (opts)
+	if @original.respond_to? :shift
+	    @template.use :array_growth, -1
+	    @original.shift
+	else nil
+	end
+    end
+
+    # Unshift values onto the left end of the array.
+    def do_unshift (opts)
+	if params = opts[:parameters]
+	    case @original
+	    when ::Array
+		@template.use :array_growth, params.size(:seq)
+		@original.unshift *params.values(:seq)
+	    when Sarah
+		@template.use :array_growth, params.size
+		adjust = @original.size + params.size
+		@original.insert! params
+		adjust = @original.size - adjust
+		@template.use :array_growth, adjust if adjust < 0
+	    end
+	    @template.using :array_size, @original.size
+	end
+	nil
+    end
+
+end
+
+# END

data/lib/ltdtemplate/proxy/boolean.rb

@@ -0,0 +1,74 @@
+# LtdTemplate::Proxy::Boolean - Represents true/false in an LtdTemplate
+#
+# @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/proxy'
+
+class LtdTemplate::Proxy::Boolean < LtdTemplate::Proxy
+
+    # Evaluate supported methods on boolean objects.
+    def evaluate (opts = {})
+	case opts[:method]
+	when nil, 'call' then @original
+	when 'class' then 'Boolean'
+	when 'str', 'string' then @original ? 'true' : 'false'
+	when 'type' then 'boolean'
+	when '+', '|', 'or' then do_or opts
+	when '*', '&', 'and' then do_and opts
+	when '!', 'not' then do_not opts
+	else super opts
+	end
+    end
+
+    # The template boolean value is the same as the original boolean value.
+    def tpl_boolean; @original; end
+
+    # Booleans have no textual value in templates.
+    def tpl_text; ''; end
+
+    ##################################################
+
+    # Implement +/| (or):
+    # bool|(bool1, ..., boolN)
+    # True if ANY boolean is true. Evaluates {} blocks until true.
+    def do_or (opts)
+	if !@original && (params = opts[:parameters])
+	    params.each(:seq) do |idx, expr|
+		return true if rubyversed(expr).evaluate(:method => 'call').
+		  in_rubyverse(@template).tpl_boolean
+	    end
+	end
+	@original
+    end
+
+    # Implement */& (and):
+    # bool&(bool1, ..., boolN)
+    # True if ALL booleans are true. Evaluates {} blocks until false.
+    def do_and (opts)
+	if @original && (params = opts[:parameters])
+	    params.each(:seq) do |idx, expr|
+		return false unless rubyversed(expr).
+		  evaluate(:method => 'call').in_rubyverse(@template).
+		  tpl_boolean
+	    end
+	end
+	@original
+    end
+
+    # Implement ! (not):
+    # bool!(bool1, ..., boolN)
+    # True if ALL booleans are false. Evaluates {} blocks until true.
+    def do_not (opts)
+	if !@original && (params = opts[:parameters])
+	    params.each(:seq) do |idx, expr|
+		return false if rubyversed(expr).
+		  evaluate(:method => 'call').in_rubyverse(@template).
+		  to_boolean
+	    end
+	end
+	!@original
+    end
+
+end

data/lib/ltdtemplate/proxy/match.rb

@@ -0,0 +1,40 @@
+# LtdTemplate::Proxy::Match - Proxies a regexp match in an LtdTemplate
+#
+# @author Brian Katzung <briank@kappacs.com>, Kappa Computer Solutions, LLC
+# @copyright 2014 Brian Katzung and Kappa Computer Solutions, LLC
+# @license MIT License
+
+require 'ltdtemplate/proxy'
+
+class LtdTemplate::Proxy::Match < LtdTemplate::Proxy
+
+    # Access array-like results
+    def [] (*args); @original[*args]; end
+
+    # Evaluate supported methods for regexp matches.
+    def evaluate (opts = {})
+	case opts[:method]
+	when nil, 'call' then @original
+	when 'begin', 'end', 'offset' then do_offset opts
+	when 'class' then 'Match'
+	when 'length', 'size' then @original.size
+	when 'type' then 'match'
+	end
+    end
+
+    # Renders as empty string in a template.
+    def tpl_text; ''; end
+
+    ##################################################
+
+    def do_offset (opts)
+	if (params = opts[:parameters]) && params.size(:seq) > 0 &&
+	  params[0].is_a?(::Numeric)
+	    @original.send opts[:method].to_sym, params[0]
+	else nil
+	end
+    end
+
+end
+
+# END