ltdtemplate 0.2.4 → 1.0.0

data/lib/ltdtemplate/proxy/nil.rb

@@ -0,0 +1,27 @@
+# LtdTemplate::Proxy::Nil - Represents nil 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::Nil < LtdTemplate::Proxy
+
+    # Evaluate supported nil object methods.
+    def evaluate (opts = {})
+	case opts[:method]
+	when nil, 'call' then nil
+	when 'class' then 'Nil'
+	when 'type' then 'nil'
+	else super opts
+	end
+    end
+
+    # The template boolean value is false.
+    def tpl_boolean; false; end
+
+    # The template text for nil is the empty string.
+    def tpl_text; ''; end
+
+end

data/lib/ltdtemplate/proxy/number.rb

@@ -0,0 +1,77 @@
+# LtdTemplate::Proxy::Number - Proxy for a number 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::Number < LtdTemplate::Proxy
+
+    # Evaluate supported methods for numeric objects.
+    def evaluate (opts = {})
+	case opts[:method]
+	when nil, 'call' then @original
+	when 'abs', 'ceil', 'floor'
+	    @original.send opts[:method].to_sym
+	when 'class' then 'Number'
+	when 'flt', 'float' then @original.to_f
+	when 'int' then @original.to_i
+	when 'str', 'string' then @original.to_s
+	when 'type' then '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 super opts
+	end
+    end
+
+    def tpl_text; @original.to_s; end
+
+    ##################################################
+
+    # Implement numeric comparison operators
+    def do_compare (opts)
+	if (params = opts[:parameters]) && params.size(:seq) > 0 &&
+	  params[0].is_a?(Numeric)
+	    diff = params[0]
+	else diff = 0
+	end
+	diff = @original - diff
+	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
+
+    # Implement sequential operations (+, *, /, %, &, |, ^)
+    def do_sequential (opts = {}, &block)
+	if params = opts[:parameters]
+	    params.values(:seq).select { |val| val.is_a? Numeric }.
+	      inject(@original, &block)
+	else @original
+	end
+    end
+
+    # Implement "-" method (subtraction/negation)
+    def do_subtract (opts)
+	sum = @original
+	params = opts[:parameters]
+	if !params || params.size(:seq) == 0 then -@original
+	else do_sequential(opts) { |a, b| a - b }
+	end
+    end
+
+end
+
+# END

data/lib/ltdtemplate/proxy/regexp.rb

@@ -0,0 +1,74 @@
+# LtdTemplate::Proxy::Regexp - Proxy for Regexp objects in an LtdTemplates
+#
+# @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::Regexp < LtdTemplate::Proxy
+
+    # Evaluate supported methods on Regexp (regular expression) objects.
+    def evaluate (opts = {})
+	# These methods are supported regardless of whether regexp
+	# is enabled.
+	case opts[:method]
+	when nil, 'call'
+	    if @template.options[:regexp] then return @original
+	    else return nil
+	    end
+	when 'class' then return 'Regexp'
+	when 'str', 'string'
+	    return @original.to_s.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
+	when 'type' then return 'regexp'
+	end
+
+	# These methods are disabled unless regexp is enabled.
+	if @template.options[:regexp]
+	    case opts[:method]
+	    when 'ci', 'ignorecase'
+		if (@original.options & ::Regexp::IGNORECASE) != 0
+		    return @original
+		else return ::Regexp.new(@original.source,
+		  @original.options | ::Regexp::IGNORECASE)
+		end
+	    when 'ext', 'extended'
+		if (@original.options & ::Regexp::EXTENDED) != 0
+		    return @original
+		else return ::Regexp.new(@original.source,
+		  @original.options | ::Regexp::EXTENDED)
+		end
+	    when 'match' then return do_match opts
+	    when 'multi', 'multiline'
+		if (@original.options & ::Regexp::MULTILINE) != 0
+		    return @original
+		else return ::Regexp.new(@original.source,
+		  @original.options | ::Regexp::MULTILINE)
+		end
+	    end
+	end
+
+	super opts
+    end
+
+    def tpl_text; ''; end
+
+    ##################################################
+
+    def do_match (opts)
+	if (params = opts[:parameters]) && params.size(:seq) > 0 &&
+	  params[0].is_a?(::String)
+	    # Track array size generated??
+	    @original.match(*params[0..1].values)
+	else nil
+	end
+    end
+
+end
+
+# END

data/lib/ltdtemplate/proxy/string.rb

@@ -0,0 +1,196 @@
+# LtdTemplate::Proxy::String - Proxies a string 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'
+require 'sarah'
+
+class LtdTemplate::Proxy::String < LtdTemplate::Proxy
+
+    # Evaluate supported methods for strings.
+    def evaluate (opts = {})
+	case opts[:method]
+	when nil, 'call', 'str', 'string' then @original
+	when 'capcase' then meter @original.capitalize
+	when 'class' then 'String'
+	when 'downcase' then meter @original.downcase
+	when 'flt', 'float' then @original.to_f
+	when 'html'
+	    require 'htmlentities'
+	    meter(HTMLEntities.new(:html4).encode(@original, :basic,
+	      :named, :decimal))
+	when 'idx', 'index', 'ridx', 'rindex' then do_index opts
+	when 'int' then @original.to_i
+	when 'join' then do_join opts
+	when 'len', 'length' then @original.length
+	when 'match' then do_match opts
+	when 'pcte'
+	  meter(@original.gsub(/[^a-z0-9]/i) { |c| sprintf "%%%2x", c.ord })
+	when 'regexp'
+	    if @template.options[:regexp] then ::Regexp.new @original
+	    else nil
+	    end
+	when 'rep', 'rep1', 'replace', 'replace1' then do_replace opts
+	when 'rng', 'range', 'slc', 'slice' then do_range_slice opts
+	when 'split' then do_split opts
+	when 'type' then 'string'
+	when 'upcase' then meter @original.upcase
+	when '+' then do_add opts
+	when '*' then do_multiply opts
+	when '<', '<=', '==', '!=', '>=', '>' then do_compare opts
+	else super opts
+	end
+    end
+
+    # Meter string resource usage
+    def meter (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
+	str
+    end
+
+    def tpl_text; @original; end
+
+    ##################################################
+
+    # "Add" (concatenate) strings
+    def do_add (opts)
+	combined = @original
+	if params = opts[:parameters]
+	    params.each(:seq) do |key, val|
+		val = rubyversed(val).tpl_text
+		@template.using :string_length, (combined.length + val.length)
+		combined += val
+	    end
+	end
+	meter combined
+    end
+
+    # Match a regular expression
+    def do_match (opts)
+	if (params = opts[:parameters]) && params.size(:seq) > 0 &&
+	  params[0].is_a?(::Regexp)
+	    params[0].in_rubyverse(@template).evaluate :method => 'match',
+	      :parameters => Sarah[ @original, *params[1..-1].values ]
+	else nil
+	end
+    end
+
+    # "Multiply" (repeat) strings
+    def do_multiply (opts)
+	str = ''
+	if (params = opts[:parameters]) && params.size(:seq) > 0
+	    times = params[0]
+	    if times.is_a? Integer
+		str = @original
+		if times < 0
+		    str = str.reverse
+		    times = -times
+		end
+		@template.use :string_total, (str.length * times)
+		@template.using :string_length, (str.length * times)
+		str = str * times
+	    end
+	end
+	meter str
+    end
+
+    # Implement string comparison operators
+    def do_compare (opts)
+	if (params = opts[:parameters]) && (params.size(:seq) > 0)
+	    diff = rubyversed(params[0]).tpl_text
+	else
+	    diff = ''
+	end
+
+	diff = @original <=> diff
+	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 = opts[:parameters]
+	if params && params.size(:seq) > 0
+	    substr = rubyversed(params[0]).tpl_text
+	end
+	offset = params[1] if params && params.size(:seq) > 1
+	case opts[:method][0]
+	when 'r'
+	    offset = -1 unless offset.is_a? Integer
+	    @original.rindex(substr, offset) || -1
+	else
+	    offset = 0 unless offset.is_a? Integer
+	    @original.index(substr, offset) || -1
+	end
+    end
+
+    # String join
+    # str.join(list)
+    def do_join (opts)
+	params = opts[:parameters]
+    	if params && params.size(:seq) > 0
+	    meter(params.values(:seq).map { |val| rubyversed(val).tpl_text }.
+	      join(@original))
+	else ''
+	end
+    end
+
+    # Range and slice:
+    # str.range([begin[, end]])
+    # str.slice([begin[, length]])
+    def do_range_slice (opts)
+	op1, op2 = 0, -1
+	params = opts[:parameters]
+	op1 = params[0] if params && params.size(:seq) > 0
+	op2 = params[1] if params && params.size(:seq) > 1
+	if opts[:method][0] == 'r' || op2 < 0
+	    str = @original[op1..op2]
+	else str = @original[op1, op2]
+	end
+	meter(str || '')
+    end
+
+    # Replace and replace one
+    # str.replace(pattern, replacement)
+    # str.replace1(pattern, replacement)
+    def do_replace (opts)
+	if (params = opts[:parameters]) && params.size(:seq) > 1
+	    pat, repl = params[0..1]
+	    if opts[:method][-1] == '1'
+		# replace one
+		meter @original.sub(pat, repl)
+	    else
+		# replace all
+		meter @original.gsub(pat, repl)
+	    end
+	else @original
+	end
+    end
+
+    # Split
+    # str.split(pattern[, limit])
+    def do_split (opts)
+	if opts[:parameters]
+	    params = opts[:parameters][0..1].values
+	else params = []
+	end
+	@original.split(*params).tap { |ary| ary.each { |str| meter str } }
+    end
+
+end
+
+# END

data/lib/ltdtemplate/value.rb

@@ -0,0 +1,94 @@
+# LtdTemplate::Value - Common code for LtdTemplate value objects
+#
+# @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'
+
+module LtdTemplate::Value
+
+    class Code_Block; end
+
+    # Classes that include this module are their own method handlers
+    # and take the template as an initialization parameter.
+    include LtdTemplate::Method_Handler
+    def self.included (base); base.extend LtdTemplate::Consumer; end
+
+    # @!attribute [r] runtime_methods
+    # @return [Array<LtdTemplate::Value::Code_Block>]
+    # This object's run-time methods.
+    attr_reader :runtime_methods
+
+    # Initialize the object with a link to the associated template.
+    #
+    # @param template [LtdTemplate] The associated template object.
+    def initialize (template)
+	@template = template
+	@runtime_methods = {}
+    end
+
+    # Common operations for all values
+    def evaluate (opts = {})
+	case opts[:method]
+	when 'methods' then do_methods opts
+	else do_run_method opts
+	end
+    end
+
+    # Avoid "spilling our guts" when inspected
+    def inspect
+	"#<#{self.class.name}##{self.object_id} for #{@template.inspect}>"
+    end
+
+    # Shortcut to rubyversed in the template.
+    def rubyversed (obj); @template.rubyversed(obj); end
+
+    # Default boolean value is true
+    def tpl_boolean; true; end
+
+    ##################################################
+
+    # Set or get run-time methods.
+    #
+    # @param opts [Hash] A hash of method options.
+    # @return [nil]
+    def do_methods (opts)
+	if params = opts[:parameters]
+	    params.values(:seq).each_slice(2) do |pair|
+		return @runtime_methods[pair[0]] if pair.size == 1
+		if pair[1].nil? then @runtime_methods.delete pair[0]
+		else @runtime_methods[pair[0]] = pair[1]
+		end
+	    end
+	end
+	nil
+    end
+
+    # Try to execute run-time methods bound to the object or object
+    # class. Returns the return value from the code block or nil.
+    #
+    # @param opts [Hash] A hash of method options.
+    def do_run_method (opts)
+	method = nil
+	if name = opts[:method]
+	    method = @runtime_methods[name]
+	    class_name = self.evaluate :method => 'class'
+	    if !method && class_name
+		class_var = @template.factory(:variable, class_name).evaluate
+		method = rubyversed(class_var).runtime_methods[name] if class_var
+	    end
+	end
+	if method.is_a? LtdTemplate::Value::Code_Block
+	    opts[:target] = self
+	    rubyversed(method).evaluate opts
+	elsif !method.nil? then method
+	elsif mmproc = @template.options[:missing_method]
+	    mmproc.call(@template, self, opts)
+	else nil
+	end
+    end
+
+end
+
+# END