ltdtemplate 0.2.4 → 1.0.0

metadata

@@ -3,10 +3,10 @@ name: ltdtemplate
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
+  - 1
   - 0
-  - 2
-  - 4
-  version: 0.2.4
+  - 0
+  version: 1.0.0
 platform: ruby
 authors: 
 - Brian Katzung
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-03-15 00:00:00 -05:00
+date: 2014-05-20 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -28,17 +28,21 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/test.rb
 - lib/ltdtemplate/value/code_block.rb
-- lib/ltdtemplate/value/array.rb
-- lib/ltdtemplate/value/nil.rb
-- lib/ltdtemplate/value/boolean.rb
-- lib/ltdtemplate/value/number.rb
 - lib/ltdtemplate/value/namespace.rb
-- lib/ltdtemplate/value/string.rb
+- lib/ltdtemplate/value/array_splat.rb
+- lib/ltdtemplate/proxy.rb
 - lib/ltdtemplate/code.rb
+- lib/ltdtemplate/value.rb
+- lib/ltdtemplate/proxy/match.rb
+- lib/ltdtemplate/proxy/regexp.rb
+- lib/ltdtemplate/proxy/array.rb
+- lib/ltdtemplate/proxy/nil.rb
+- lib/ltdtemplate/proxy/boolean.rb
+- lib/ltdtemplate/proxy/number.rb
+- lib/ltdtemplate/proxy/string.rb
+- lib/ltdtemplate/code/sequence.rb
 - lib/ltdtemplate/code/subscript.rb
-- lib/ltdtemplate/code/code_block.rb
 - lib/ltdtemplate/code/call.rb
 - lib/ltdtemplate/code/parameters.rb
 - lib/ltdtemplate/code/variable.rb
@@ -55,7 +59,6 @@ files:
 - test/05string.rb
 - test/06array.rb
 - test/07each.rb
-- test/03tpl_singletons.rb
 - test/08interpolate.rb
 - test/01instance.rb
 - test/02tpl_literal.rb
@@ -100,7 +103,6 @@ test_files:
 - test/05string.rb
 - test/06array.rb
 - test/07each.rb
-- test/03tpl_singletons.rb
 - test/08interpolate.rb
 - test/01instance.rb
 - test/02tpl_literal.rb

data/lib/ltdtemplate/code/code_block.rb

@@ -1,30 +0,0 @@
-# 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.nil
-	when 1 then values[0]
-	else @template.factory(:array).set_value(values)
-	end
-    end
-
-end

data/lib/ltdtemplate/value/array.rb

@@ -1,210 +0,0 @@
-# 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.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
-	if @sarah.rnd_size == 0 then native = []
-	elsif @sarah.seq_size == 0 then native = {}
-	else native = Sarah.new
-	end
-	@sarah.each { |key, val| native[key] = val.to_native }
-	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 'each', 'each_rnd', 'each_seq' then do_each opts
-	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
-	when '/' then @template.factory :parameters, @sarah.seq, @sarah.rnd
-	when '%' then @template.factory :parameters, [], @sarah.seq
-	else do_method opts, 'Array'
-	end
-    end
-
-    # Type (for :missing_method callback)
-    def type; :array; 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
-
-    #
-    # Loop over each key, value
-    #
-    def do_each (opts)
-	results = @template.factory :array
-	if params = opts[:parameters] and params.positional.size > 0
-	    body = params.positional[0]
-	    if opts[:method] != 'each_rnd'
-		@sarah.seq.each_index do |idx|
-		    @template.use :iterations
-		    body_params = @template.factory :parameters,
-		      [@template.factory(:number, idx), @sarah.seq[idx]]
-		    results.sarah.push body.get_value(:method => 'each_seq',
-		      :parameters => body_params)
-		end
-	    end
-	    if opts[:method] != 'each_seq'
-		@sarah.rnd.each do |key, val|
-		    @template.use :iterations
-		    body_params = @template.factory :parameters,
-		      [map_native_value(key), val]
-		    results.sarah.push body.get_value(:method => 'each_rnd',
-		      :parameters => body_params)
-		end
-	    end
-	end
-	results
-    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.nil
-    end
-
-    def do_push (opts)
-	if params = opts[:parameters] then @sarah.append! params.sarah end
-	@template.nil
-    end
-
-    def do_shift (opts)
-	@sarah.shift || @template.nil
-    end
-
-    def do_unshift (opts)
-	if params = opts[:parameters] then @sarah.insert! params.sarah end
-	@template.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.nil
-    end
-
-end

data/lib/ltdtemplate/value/boolean.rb

@@ -1,82 +0,0 @@
-# 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
-
-    # Type (for :missing_method callback)
-    def type; :boolean; 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/nil.rb

@@ -1,30 +0,0 @@
-# LtdTemplate::Value::Nil - Represents nil 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::Nil < LtdTemplate::Code
-
-    # Use one shared instance per template.
-    def self.instance (template, *args)
-	template.factory_singletons[:nil] ||= self.new(template, *args)
-    end
-
-    def get_value (opts = {})
-	case opts[:method]
-	when 'type' then @template.factory :string, 'nil'
-	else do_method opts
-	end
-    end
-
-    # Type (for :missing_method callback)
-    def type; :nil; end
-
-    def to_boolean; false; end
-    def to_native; ''; end
-    def to_text; ''; end
-
-end

data/lib/ltdtemplate/value/number.rb

@@ -1,96 +0,0 @@
-# LtdTemplate::Value::Number - Represents a number 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::Number < LtdTemplate::Code
-
-    def initialize (template, value = 0)
-	super template
-	case value
-	when Numeric then @value = value
-	when String then @value = (value =~ /\./) ? value.to_f : value.to_i
-	end
-    end
-
-    def to_boolean; true; end
-    def to_native; @value; end
-    def to_text; @value.to_s; end
-
-    def get_value (opts = {})
-	case opts[:method]
-	when nil, 'call' then self
-	when 'abs' then (@value >= 0) ? self :
-	  @template.factory(:number, -@value)
-	when 'ceil' then @template.factory :number, @value.ceil
-	when 'class' then @template.factory :string, 'Number'
-	when 'floor' then @template.factory :number, @value.floor
-	when 'flt', 'float' then @template.factory :number, @value.to_f
-	when 'int' then @template.factory :number, @value.to_i
-	when 'str', 'string' then @template.factory :number, @value.to_s
-	when 'type' then @template.factory :string, 'number'
-	when '+' then do_sequential(opts) { |a, b| a + b }
-	when '-' then do_subtract opts
-	when '*' then do_sequential(opts) { |a, b| a * b }
-	when '/' then do_sequential(opts) { |a, b| a / b }
-	when '%' then do_sequential(opts) { |a, b| a % b }
-	when '&' then do_sequential(opts) { |a, b| a & b }
-	when '|' then do_sequential(opts) { |a, b| a | b }
-	when '^' then do_sequential(opts) { |a, b| a ^ b }
-	when '<', '<=', '==', '!=', '>=', '>' then do_compare opts
-	else do_method opts, 'Number'
-	end
-    end
-
-    # Type (for :missing_method callback)
-    def type; :number; end
-
-    # Implement sequential operations (+, *, /, %, &, |, ^)
-    def do_sequential (opts = {}, &block)
-	if params = opts[:parameters]
-	    @template.factory(:number,
-	      params.positional.map { |tval| tval.to_native }.
-	      select { |nval| nval.is_a? Numeric }.
-	      inject(@value, &block))
-	else
-	    @value
-	end
-    end
-
-    # Implement "-" method (subtraction/negation)
-    def do_subtract (opts)
-	sum = @value
-	params = params.positional if params = opts[:parameters]
-	if !params or params.size == 0
-	    sum = -sum
-	else
-	    params.each do |tval|
-		nval = tval.to_native
-		sum -= nval if nval.is_a? Numeric
-	    end
-	end
-	@template.factory :number, sum
-    end
-
-    # Implement numeric comparison operators
-    def do_compare (opts)
-	diff = 0
-	if params = opts[:parameters] and params.positional.size > 0
-	    diff = params.positional[0].to_native
-	    diff = 0 unless diff.is_a? Numeric
-	end
-	diff = @value - diff
-	@template.factory :boolean, case opts[:method]
-	when '<' then diff < 0
-	when '<=' then diff <= 0
-	when '==' then diff == 0
-	when '!=' then diff != 0
-	when '>=' then diff >= 0
-	when '>' then diff > 0
-	end
-    end
-
-end