ltdtemplate 0.2.4 → 1.0.0

data/lib/ltdtemplate/value/array_splat.rb

@@ -0,0 +1,34 @@
+# For array/ or array% (similar to Ruby's *array)
+
+require 'ltdtemplate'
+
+module LtdTemplate::Value; end
+
+class LtdTemplate::Value::Array_Splat
+
+    include LtdTemplate::Method_Handler
+
+    attr_reader :named, :positional
+
+    # @param positional [Array] Positional parameters
+    # @param named [Array] Flat array of key, value pairs
+    def initialize (positional, named = nil)
+	@positional, @named = positional, named
+    end
+
+    # Evaluate support array splat methods. Very little is supported,
+    # as these are only intended to be used in parameter and subscript
+    # list expansions.
+    def evaluate (opts = {})
+	case opts[:method]
+	when 'type' then 'array_splat'
+	else nil
+	end
+    end
+
+    # Unlike arrays, these generate no template text.
+    def tpl_text; ''; end
+
+end
+
+# END

data/lib/ltdtemplate/value/code_block.rb

@@ -1,17 +1,19 @@
-# LtdTemplate::Value::Code_Block - Represents an explicit code block in an
-#	LtdTemplate
+# 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.
+# Code blocks are wrappers around code sequences. 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
+# @copyright 2013-2014 Brian Katzung and Kappa Computer Solutions, LLC
 # @license MIT License
 
-require 'ltdtemplate/code'
+require 'ltdtemplate/value'
 
-class LtdTemplate::Value::Code_Block < LtdTemplate::Code
+class LtdTemplate::Value::Code_Block
+
+    include LtdTemplate::Value
 
     attr_reader :code
 
@@ -20,24 +22,26 @@ class LtdTemplate::Value::Code_Block < LtdTemplate::Code
 	@code = code
     end
 
-    def to_boolean; true; end
-    def to_native; self; end
-    def to_text; ''; end
-
-    def get_value (opts = {})
+    # Evaluate supported methods on code blocks. Most methods
+    # are passed to the code block.
+    def evaluate (opts = {})
 	case opts[:method]
 	when nil then self
-	when 'type' then @template.factory :string, 'code'
+	when 'class' then 'Code'
+	when 'type' then 'code'
 	else
 	    @template.push_namespace opts[:method], opts[:parameters],
 	      :target => (opts[:target] || self)
-	    result = @code.get_value
+	    result = rubyversed(@code).evaluate
 	    @template.pop_namespace
 	    result
 	end
     end
 
-    # Type (for :missing_method callback)
-    def type; :code_block; end
+    # In contrast to an implied code block, an uncalled explicit code
+    # block generates no template output.
+    def tpl_text; ''; end
 
 end
+
+# END

data/lib/ltdtemplate/value/namespace.rb

@@ -1,150 +1,148 @@
 # LtdTemplate::Value::Namespace - Represents an LtdTemplate variable namespace
 #
 # @author Brian Katzung <briank@kappacs.com>, Kappa Computer Solutions, LLC
-# @copyright 2013 Brian Katzung and Kappa Computer Solutions, LLC
+# @copyright 2013-2014 Brian Katzung and Kappa Computer Solutions, LLC
 # @license MIT License
 
-require 'ltdtemplate/value/array'
+require 'sarah'
+require 'xkeys'
+require 'ltdtemplate/value'
 
-class LtdTemplate::Value::Namespace < LtdTemplate::Value::Array
+class LtdTemplate::Value::Namespace < Sarah
 
-    attr_reader :method, :parameters, :parent, :root
+    include LtdTemplate::Value
+    include XKeys::Hash
+
+    attr_reader :tpl_method, :parameters, :parent, :root, :template
     attr_accessor :target
 
-    def initialize (template, method, parameters, parent = nil)
+    def initialize (template, tpl_method, parameters, parent = nil)
 	super template
-	@method, @parameters = method, parameters
+	@tpl_method, @parameters = tpl_method, parameters
 	@root = parent ? parent.root : self
 	@parent = parent
 	@target = nil
-	clear
+	clear()
     end
 
-    def to_native
-	if @sarah.rnd_size == 3 then native = []
-	elsif @sarah.seq_size == 0 then native = {}
-	else native = Sarah.new
-	end
-	@sarah.each do |key, value|
-	    # Exclude some permanent namespace attributes
-	    native[key] = value.to_native unless key =~ /^[_@$]$/
-	end
-	native
-    end
-
-    #
     # Clear values except for permanent namespace attributes.
-    #
     def clear
 	super
-	@sarah.rnd['_'] = @parameters
-	@sarah.rnd['@'] = @root
-	@sarah.rnd['^'] = @parent if @parent
-	@sarah.rnd['$'] = self
+	self['_'] = @parameters
+	self['@'] = @root
+	self['^'] = @parent if @parent
+	self['$'] = self
 	self
     end
 
-    #
+    # Evaluate supported methods on namespaces.
+    def evaluate (opts = {})
+	case opts[:method]
+	when nil, 'call' then self
+	when 'array', '*' # anonymous array
+	    opts[:parameters] ? opts[:parameters] : @template.factory(:array)
+	when 'class' then 'Namespace'
+	when 'false' then false
+	when 'if' then do_if opts
+	when 'loop' then do_loop opts
+	when 'method' then @tpl_method
+	when 'nil' then nil
+	when 'target' then @target
+	when 'true' then true
+	when 'type' then 'namespace'
+	when 'use' then do_use opts
+	when 'var' then do_add_names opts
+	else super opts
+	end
+    end
+
     # Search for the specified item in the current namespace or above.
-    #
     def find_item (name)
 	namespace = self
 	while namespace
-	    break if namespace.has_item? name
+	    break if namespace.has_key? name
 	    namespace = namespace.parent
 	end
 	namespace
     end
 
-    #
-    # Template string-value for method
-    #
-    def method_string
-	@method_string ||= @template.factory :string, @method
-    end
+    # Namespaces do not generate template output.
+    def tpl_text; ''; end
 
-    def get_value (opts = {})
-	case opts[:method]
-	when 'array', '*' # anonymous array
-	    opts[:parameters] ? opts[:parameters] :
-	      @template.factory(:parameters)
-	when 'false' then @template.factory :boolean, false
-	when 'if' then do_if opts
-	when 'loop' then do_loop opts
-	when 'method' then method_string
-	when 'nil' then @template.nil
-	when 'target' then @target || @template.nil
-	when 'true' then @template.factory :boolean, true
-	when 'use' then do_use opts
-	when 'var' then do_add_names opts
-	else super
-	end
-    end
+    # Auto-vivicate arrays in namespaces.
+    def xkeys_new (*args); @template.factory :array; end
 
-    # Type (for :missing_method callback)
-    def type; :namespace; end
+    ###################################################
 
-    # Add new namespace names with nil or specific values
-    #
+    # Add new namespace names with nil or specific values.
+    # $.var(name1, ..., nameN .. key1, val1, ..., keyN, valN)
     def do_add_names (opts)
-	params = opts[:parameters]
-	if params.positional.size
-	    tnil = @template.nil
-	    params.positional.each { |item| set_item(item.to_native, tnil) }
-	end
-	if params.named.size
-	    params.named.each { |item, val| set_item(item, val) }
+	if params = opts[:parameters]
+	    params.each(:seq) { |idx, val| self[val] = nil }
+	    params.each(:nsq) { |key, val| self[key] = val }
 	end
-	@template.nil
+	nil
     end
 
     # Implement conditionals
+    # $.if(\{test1}, \{result1}, ..., \{testN}, \{resultN}, \{else_value})
     def do_if (opts)
 	if params = opts[:parameters]
-	    params.positional.each_slice(2) do |e1, e2|
-		e1 = e1.get_value :method => 'call'
+	    params.values(:seq).each_slice(2) do |pair|
+		e1 = rubyversed(pair[0]).evaluate :method => 'call'
 
 		#
 		# Return the "else" value, e1, in the absence of
 		# a condition/result value pair.
 		#
-		return e1 unless e2
+		return e1 if pair.size == 1
 
 		# Return the e2 result if e1 evaluates to true
-		return e2.get_value(:method => 'call') if e1.to_boolean
+		if rubyversed(e1).tpl_boolean
+		    return rubyversed(pair[1]).evaluate :method => 'call'
+		end
 	    end
 	end
-	@template.nil
+	nil
     end
 
+    # Implement loops
+    # $.loop(\{pre_test}, \{body})
+    # $.loop(\{pre_test}, \{body}, \{post_test})
     def do_loop (opts)
 	results = @template.factory :array
-	if params = opts[:parameters] and params.positional.size > 1
-	    params = params.positional
-	    while params[0].get_value(:method => 'call').to_boolean
+	if (params = opts[:parameters]) && params.size(:seq) > 1
+	    while rubyversed(params[0]).evaluate(:method => 'call').
+	      in_rubyverse(@template).tpl_boolean
+		# RESOURCE iterations: Total loop iterations
 		@template.use :iterations
-		results.sarah.push params[1].get_value(:method => 'call')
-		break if params[2] and
-		  !params[2].get_value(:method => 'call').to_boolean
+		results.push rubyversed(params[1]).evaluate :method => 'call'
+		break if params.size(:seq) > 2 && !rubyversed(params[2]).
+		  evaluate(:method => 'call').in_rubyverse(@template).
+		  tpl_boolean
 	    end
 	end
 	results
     end
 
+    # Load external resources
     def do_use (opts)
 	tpl = @template
-	if loader = tpl.options[:loader] and
-	  params = opts[:parameters] and params.positional.size > 0
-	    name = params.positional[0].get_value.to_text
+	if (loader = tpl.options[:loader]) && (params = opts[:parameters]) &&
+	  params.size(:seq) > 0
+	    name = params[0]
 	    if !tpl.used[name]
+		# RESOURCE use: Total $.use invocations
 		tpl.use :use
 		tpl.used[name] = true
 		result = loader.call(tpl, name)
-		tpl.parse_template(tpl.get_tokens result).get_value if
+		tpl.parse_template(tpl.get_tokens result).evaluate if
 		  result.kind_of? String
 	    end
 	end
-	tpl.nil
+	nil
     end
 
 end
+
+# END

data/ltdtemplate.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name         = "ltdtemplate"
-  s.version      = "0.2.4"
-  s.date         = "2014-03-15"
+  s.version      = "1.0.0"
+  s.date         = "2014-05-20"
   s.authors      = ["Brian Katzung"]
   s.email        = ["briank@kappacs.com"]
   s.homepage     = "http://rubygems.org/gems/ltdtemplate"

data/test/04number.rb

@@ -7,13 +7,6 @@ class TestLtdTemplate_04 < MiniTest::Unit::TestCase
 	@tpl = LtdTemplate.new
     end
 
-    def test_imethods
-	num = @tpl.factory :number
-	[
-	    :get_value, :to_boolean, :to_native, :to_text
-	].each { |method| assert_respond_to num, method }
-    end
-
     def test_basic
 	@tpl.parse '<<1>>'
 	assert_equal("1", @tpl.render, "literal")

data/test/05string.rb

@@ -7,13 +7,6 @@ class TestLtdTemplate_05 < MiniTest::Unit::TestCase
 	@tpl = LtdTemplate.new
     end
 
-    def test_imethods
-	num = @tpl.factory :string, ''
-	[
-	    :get_value, :to_boolean, :to_native, :to_text
-	].each { |method| assert_respond_to num, method }
-    end
-
     def test_basic
 	@tpl.parse '<<"str">>'
 	assert_equal("str", @tpl.render, "literal")

data/test/06array.rb

@@ -7,15 +7,6 @@ class TestLtdTemplate_06 < MiniTest::Unit::TestCase
 	@tpl = LtdTemplate.new
     end
 
-    def test_imethods
-	ary = @tpl.factory :array
-	[
-	    :clear, :get_item, :get_value, :has_item?, :named, :positional,
-	    :scalar?, :set_from_array, :set_from_hash, :set_item, :set_value,
-	    :to_boolean, :to_native, :to_text
-	].each { |method| assert_respond_to ary, method }
-    end
-
     def test_create
 	@tpl.parse '<<a=a.type" "a.size>>'
 	assert_equal 'array 0', @tpl.render

data/test/07each.rb

@@ -10,7 +10,7 @@ class TestLtdTemplate_07 < MiniTest::Unit::TestCase
     def test_each
 	@tpl.parse <<'TPL'
 <<a=(1,2,3..'four,4,'five,5,'six,6,7,7)
-a.each({ $.*($.method,$_[0].type,$_[0],$_[1]).join(",") }).join(";")
+a.each({ $.*($.method,_[0].type,_[0],_[1]).join(",") }).join(";")
 .>>
 TPL
 	expected = {}
@@ -31,7 +31,7 @@ TPL
     def test_each_rnd
 	@tpl.parse <<'TPL'
 <<a=(1,2,3..'four,4,'five,5,'six,6,7,7)
-a.each_rnd({ $.*($.method,$_[0].type,$_[0],$_[1]).join(",") }).join(";")
+a.each_rnd({ $.*($.method,_[0].type,_[0],_[1]).join(",") }).join(";")
 .>>
 TPL
 	expected = {}
@@ -49,7 +49,7 @@ TPL
     def test_each_seq
 	@tpl.parse <<'TPL'
 <<a=(1,2,3..'four,4,'five,5,'six,6,7,7)
-a.each_seq({ $.*($.method,$_[0].type,$_[0],$_[1]).join(",") }).join(";")
+a.each_seq({ $.*($.method,_[0].type,_[0],_[1]).join(",") }).join(";")
 .>>
 TPL
 	expected = {}

data/test/08interpolate.rb

@@ -27,7 +27,7 @@ class TestLtdTemplate_08 < MiniTest::Unit::TestCase
 c=('c, 'c, 'x, 'c, 'y, 'c) d=(1, a/, 4, b/, 7, c%, 8 .. 'd, 'd, 'y, 'd) >>
 TPL
 	@tpl.render
-	d = @tpl.namespace.get_item(?d).to_native
+	d = @tpl.namespace[?d]
 	assert_equal [1, 2, 3, 4, 5, 6, 7, 8], d.seq, "d (sequential)"
 	assert_equal({ ?a => ?a, ?b => ?b, ?c => ?c, ?d => ?d,
 	  ?x => ?c, ?y => ?d }, d.rnd, "d (random-access)")

data/test/10missing_meth.rb

@@ -5,7 +5,7 @@ class TestLtdTemplate_10 < MiniTest::Unit::TestCase
 
     def test_missing_meth1
 	miss_meth = Proc.new do |tpl, obj, opt|
-	    tpl.factory :string, "#{obj.type}.#{opt[:method]};"
+	    "#{obj.evaluate :method => 'type'}.#{opt[:method]};"
 	end
 	tpl = LtdTemplate.new :missing_method => miss_meth
 	tpl.parse "<<$.*.abc 1.def '.ghi>>"

data/test/11classes.rb

@@ -1,17 +1,17 @@
 require 'minitest/autorun'
 require 'ltdtemplate'
-require 'ltdtemplate/value/nil'
+require 'ltdtemplate/proxy/nil'
 
 class TestLtdTemplate_11 < MiniTest::Unit::TestCase
 
     def test_classes1
-	LtdTemplate.set_classes :nil => Nil1
+	LtdTemplate.set_classes :nil_proxy => Nil1
 	tpl = LtdTemplate.new
 	tpl.parse '<<$.nil.type>>'
 	assert_equal 'nil1', tpl.render, 'nil type after class class change'
 
 	tpl = LtdTemplate.new
-	tpl.set_classes :nil => Nil2
+	tpl.set_classes :nil_proxy => Nil2
 	tpl.parse '<<$.nil.type>>'
 	assert_equal 'nil2', tpl.render, 'nil type after instance class change'
 
@@ -22,22 +22,22 @@ class TestLtdTemplate_11 < MiniTest::Unit::TestCase
 
 end
 
-class Nil1 < LtdTemplate::Value::Nil
+class Nil1 < LtdTemplate::Proxy::Nil
 
-    def get_value (opts = {})
+    def evaluate (opts = {})
 	case opts[:method]
-	when 'type' then @template.factory :string, 'nil1'
+	when 'type' then 'nil1'
 	else super
 	end
     end
 
 end
 
-class Nil2 < LtdTemplate::Value::Nil
+class Nil2 < LtdTemplate::Proxy::Nil
 
-    def get_value (opts = {})
+    def evaluate (opts = {})
 	case opts[:method]
-	when 'type' then @template.factory :string, 'nil2'
+	when 'type' then 'nil2'
 	else super
 	end
     end