ltdtemplate 0.1.0

data/lib/ltdtemplate/value/namespace.rb

@@ -0,0 +1,135 @@
+# 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
+# @license MIT License
+
+require 'ltdtemplate/value/array'
+
+class LtdTemplate::Value::Namespace < LtdTemplate::Value::Array
+
+    attr_reader :method, :parameters, :parent, :root
+    attr_accessor :target
+
+    def initialize (template, method, parameters, parent = nil)
+	super template
+	@method, @parameters = method, parameters
+	@root = parent ? parent.root : self
+	@parent = parent
+	@target = nil
+	clear
+    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
+    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
+	    namespace = namespace.parent
+	end
+	namespace
+    end
+
+    #
+    # Template string-value for method
+    #
+    def method_string
+	@method_string ||= @template.factory :string, @method
+    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.factory :nil
+	when 'target' then @target || @template.factory(: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
+
+    # Add new namespace names with nil or specific values
+    #
+    def do_add_names (opts)
+	params = opts[:parameters]
+	if params.positional.size
+	    tnil = @template.factory :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) }
+	end
+	@template.factory :nil
+    end
+
+    # Implement conditionals
+    def do_if (opts)
+	if params = opts[:parameters]
+	    params.positional.each_slice(2) do |e1, e2|
+		e1 = e1.get_value :method => 'call'
+
+		#
+		# Return the "else" value, e1, in the absence of
+		# a condition/result value pair.
+		#
+		return e1 unless e2
+
+		# Return the e2 result if e1 evaluates to true
+		return e2.get_value(:method => 'call') if e1.to_boolean
+	    end
+	end
+	@template.factory :nil
+    end
+
+    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
+		@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
+	    end
+	end
+	results
+    end
+
+    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 !tpl.used[name]
+		tpl.use :use
+		tpl.used[name] = true
+		result = loader.call(tpl, name)
+		tpl.parse_template(tpl.get_tokens result).get_value if
+		  result.kind_of? String
+	    end
+	end
+	tpl.factory :nil
+    end
+
+end

data/lib/ltdtemplate/value/nil.rb

@@ -0,0 +1,27 @@
+# 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
+
+    def to_boolean; false; end
+    def to_native; ''; end
+    def to_text; ''; end
+
+end

data/lib/ltdtemplate/value/number.rb

@@ -0,0 +1,93 @@
+# 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
+
+    # 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

data/lib/ltdtemplate/value/string.rb

@@ -0,0 +1,121 @@
+# LtdTemplate::Value::String - Represents a string 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::String < LtdTemplate::Code
+
+    def initialize (template, value)
+	super template
+	template.use :string_total, value.length
+	@value = value
+    end
+
+    def to_boolean; true; end
+    def to_native; @value; end
+    def to_text; @value; end
+
+    def get_value (opts = {})
+	case opts[:method]
+	when nil, 'call', 'str', 'string' then self
+	when 'class' then @template.factory :string, 'String'
+	when 'flt', 'float' then @template.factory :number, @value.to_f
+	when 'int' then @template.factory :number, @value.to_i
+	when 'len', 'length' then @template.factory :number, @value.length
+	when 'rng', 'range', 'slc', 'slice' then do_range_slice opts
+	when 'type' then @template.factory :string, 'string'
+	when '+' then do_add opts
+	when '*' then do_multiply opts
+	when 'idx', 'index', 'ridx', 'rindex' then do_index opts
+	when '<', '<=', '==', '!=', '>=', '>' then do_compare opts
+	else do_method opts, 'String'
+	end
+    end
+
+    def do_add (opts)
+	combined = @value
+	if params = opts[:parameters]
+	    params.positional.each do |tval|
+		part = tval.to_text
+		@template.using :string_length, (combined.length + part.length)
+		combined += part
+	    end
+	end
+	@template.factory :string, combined
+    end
+
+    def do_multiply (opts)
+	str = ''
+	params = params.positional if params = opts[:parameters]
+	if params and params.size > 0
+	    times = params[0].to_native
+	    if times.is_a? Integer
+		str = @value
+		if times < 0
+		    str = str.reverse
+		    times = -times
+		end
+		@template.using :string_length, (str.length * times)
+		str = str * times
+	    end
+	end
+	@template.factory :string, str
+    end
+
+    # Implement string comparison operators
+    def do_compare (opts)
+	if params = opts[:parameters] and params.positional.size > 0
+	    diff = params.positional[0].to_text
+	else
+	    diff = ''
+	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
+
+    # Index and rindex
+    # str.index(substring[, offset])
+    # str.rindex(substring[, offset]
+    def do_index (opts)
+	substr, offset = '', nil
+	params = params.positional if params = opts[:parameters]
+	substr = params[0].get_value.to_text if params and params.size > 0
+	offset = params[1].get_value.to_native if params and params.size > 1
+	case opts[:method][0]
+	when 'r'
+	    offset = -1 unless offset.is_a? Integer
+	    @template.factory :number, (@value.rindex(substr, offset) || -1)
+	else
+	    offset = 0 unless offset.is_a? Integer
+	    @template.factory :number, (@value.index(substr, offset) || -1)
+	end
+    end
+
+    # Range and slice:
+    # str.range([begin[, end]])
+    # str.slice([begin[, length]])
+    def do_range_slice (opts)
+	op1, op2 = 0, -1
+	params = params.positional if params = opts[:parameters]
+	op1 = params[0].get_value.to_native if params and params.size > 0
+	op2 = params[1].get_value.to_native if params and params.size > 1
+	if opts[:method][0] == 'r' or op2 < 0
+	    str = @value[op1..op2]
+	else
+	    str = @value[op1, op2]
+	end
+	@template.factory :string, (str || '')
+    end
+
+end