re_duxml 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 996c30dfa1b40d7aa2d27de06d5bb770e4858f23
-  data.tar.gz: 20462c1ca90131bff9c05fbe9826001fd46f0cec
+  metadata.gz: 7c7362dbfed6bd6c78ddbbd9660a55a639e802a6
+  data.tar.gz: c73453fe830475b19e4c34f60724b79abfdb2a59
 SHA512:
-  metadata.gz: 46717577e85998db3f56ca0e26fd87b28f6220908fac32002683190b85d550340d3ca9b324163474f47a9ca5888b9f122fd22ed47af48a5c8abd528a071418e0
-  data.tar.gz: 2a04ed33b59e2209fb77c240d305233547af83973cb85e67c1d44cb9c14a9a96025f54d68b0b0b3f0e18c6ba5cc29d87e7a3dd369079182cc319450a5c9e284c
+  metadata.gz: a4f44cdfc1bd794195f904a99dda9545e04e4ae35da83f8972492193ce8ea98094fe1c9abc188195df25a13324c864d08bd81e62a1c83ee630f6df4a65288678
+  data.tar.gz: d16dec0c48f1f7332781741871cbe90b56d17da1b89783e402c1a941b383c6d02c2b1f92c64e69aa7c62cb484ae8e2b25a983e14af8227eaf3e4277393a12656

data/lib/ast_ext/node.rb

@@ -1,53 +1,53 @@
-# Copyright (c) 2016 Freescale Semiconductor Inc.
-require 'ast'
-
-module AST
-  # redefining in order to allow type itself to be any type e.g. String, Symbol, Fixnum, etc.
-  class Node
-    include AST
-
-    # The `properties` hash is passed to {#assign_properties}.
-    def initialize(type, children=[], properties={})
-      @type, @children = type, children.to_a.freeze
-
-      assign_properties(properties)
-
-      @hash = [@type.object_id, @children, self.class].hash
-
-      freeze
-    end
-
-    # @param logic [Hash] hash of operators allowed in this AST containing each operator's print properties
-    # @return [String] string reconstituted from polish-notation into notation normally required by each operator
-    def print(logic=nil)
-      return type.to_s if children.empty?
-      str = ''
-      op = type.respond_to?(:text) ? type : logic[type.to_s]
-      return str unless op
-      case op.position
-        when :prefix
-          str << op.symbol
-          children.each do |c| str << c.print(logic) end
-        when :postfix
-          children.each do |c| str << c.print(logic) end
-          str << op.symbol
-        when :infix
-          if op.arity > 2
-            str << children.first.print(logic) << op.symbol << children[1].print(logic) << op.pair.to_s << children.last.print
-          else
-            str << (children.first.respond_to?(:print) ? children.first.print(logic) : children.first.to_s) << op.symbol << children.last.print
-          end
-        else # should not happen
-      end
-      str
-    end # to_s
-  end # class Node
-
-  def new_ast(op, *obj)
-    args = obj.collect do |o| o.is_a?(Node) ? o : Node.new(o) end
-    args.unshift self if is_a?(Node)
-    args.unshift Node.new(self) if is_a?(Fixnum)
-    args.unshift Node.new(self) if self.is_a?(Symbolic::Variable)
-    Node.new(op, args)
-  end
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require 'ast'
+
+module AST
+  # redefining in order to allow type itself to be any type e.g. String, Symbol, Fixnum, etc.
+  class Node
+    include AST
+
+    # The `properties` hash is passed to {#assign_properties}.
+    def initialize(type, children=[], properties={})
+      @type, @children = type, children.to_a.freeze
+
+      assign_properties(properties)
+
+      @hash = [@type.object_id, @children, self.class].hash
+
+      freeze
+    end
+
+    # @param logic [Hash] hash of operators allowed in this AST containing each operator's print properties
+    # @return [String] string reconstituted from polish-notation into notation normally required by each operator
+    def print(logic=nil)
+      return type.to_s if children.empty?
+      str = ''
+      op = type.respond_to?(:text) ? type : logic[type.to_s]
+      return str unless op
+      case op.position
+        when :prefix
+          str << op.symbol
+          children.each do |c| str << c.print(logic) end
+        when :postfix
+          children.each do |c| str << c.print(logic) end
+          str << op.symbol
+        when :infix
+          if op.arity > 2
+            str << children.first.print(logic) << op.symbol << children[1].print(logic) << op.pair.symbol << children.last.print
+          else
+            str << (children.first.respond_to?(:print) ? children.first.print(logic) : children.first.symbol) << op.symbol << children.last.print
+          end
+        else # should not happen
+      end
+      str
+    end # to_s
+  end # class Node
+
+  def new_ast(op, *obj)
+    args = obj.collect do |o| o.is_a?(Node) ? o : Node.new(o) end
+    args.unshift self if is_a?(Node)
+    args.unshift Node.new(self) if is_a?(Fixnum)
+    args.unshift Node.new(self) if self.is_a?(Symbolic::Variable)
+    Node.new(op, args)
+  end
 end

data/lib/re_duxml/array.rb

@@ -1,38 +1,37 @@
-# Copyright (c) 2016 Freescale Semiconductor Inc.
-require 'con_duxml/instance'
-
-module ConDuxml
-  # XML object array
-  # represents a pattern of copies of a this object's children or referents
-  # differentiates between copies using iterator Parameter
-  module Array
-    include Instance
-
-    # @return [Array[Element]] flattened array of all duplicated Elements
-    def activate
-      # TODO add implicit @iterator param
-      size_expr = size.respond_to?(:to_i) ? size.to_i : size.to_s
-      if size_expr.is_a? Fixnum
-        new_children = []
-        size_expr.times do
-          source_nodes = if nodes.empty? and self[:ref]
-                           [resolve_ref.clone]
-                         else
-                           nodes.collect do |node| node.clone end
-                         end
-          source_nodes.each do |node|
-            new_children << node
-          end
-        end
-        new_children.flatten
-      else
-        [self]
-      end
-    end # def instantiate
-
-    # size can be Fixnum or a Parameter expression
-    def size
-      self[:size]
-    end
-  end # class Array
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require 'con_duxml/instance'
+
+module ConDuxml
+  # XML object array
+  # represents a pattern of copies of a this object's children or referents
+  # differentiates between copies using iterator Parameter
+  module Array
+    include Instance
+
+    # @return [Array[Element]] flattened array of all duplicated Elements
+    def activate
+      size_expr = size.respond_to?(:to_i) ? size.to_i : size.to_s
+      if size_expr.is_a? Fixnum
+        new_children = []
+        size_expr.times do
+          source_nodes = if nodes.empty? and self[:ref]
+                           [resolve_ref.clone]
+                         else
+                           nodes.collect do |node| node.clone end
+                         end
+          source_nodes.each do |node|
+            new_children << node
+          end
+        end
+        new_children.flatten
+      else
+        [self]
+      end
+    end # def instantiate
+
+    # size can be Fixnum or a Parameter expression
+    def size
+      self[:size]
+    end
+  end # class Array
 end # module Dux

data/lib/re_duxml/element/parameterization.rb

@@ -1,18 +1,18 @@
-# Copyright (c) 2016 Freescale Semiconductor Inc.
-require File.expand_path(File.dirname(__FILE__) + '/../../ruby_ext/string')
-
-# methods to extend Dux::Object with methods needed to process parameterized XML content
-module Parameterization
-  # returns true if self[:if] is true or indeterminate (because condition is currently parameterized)
-  # returns false otherwise i.e. this node does not exist in this design build
-  def if?
-    return true unless (if_str = self[:if])
-    if_str.parameterized? || if_str == 'true' ? true : false
-  end
-
-  # changes condition of this object's existence
-  def if=(condition)
-    # check for valid conditional
-    change_attr_value :if, condition
-  end
-end # module Parameterization
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require File.expand_path(File.dirname(__FILE__) + '/../../ruby_ext/string')
+
+# methods to extend Dux::Object with methods needed to process parameterized XML content
+module Parameterization
+  # returns true if self[:if] is true or indeterminate (because condition is currently parameterized)
+  # returns false otherwise i.e. this node does not exist in this design build
+  def if?
+    return true unless (if_str = self[:if])
+    if_str.parameterized? || if_str == 'true' ? true : false
+  end
+
+  # changes condition of this object's existence
+  def if=(condition)
+    # check for valid conditional
+    change_attr_value :if, condition
+  end
+end # module Parameterization

data/lib/re_duxml/element.rb

@@ -1,9 +1,9 @@
-# Copyright (c) 2016 Freescale Semiconductor Inc.
-require_relative 'element/parameterization'
-require 'duxml'
-
-module Duxml
-  class Element
-    include Parameterization
-  end
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require_relative 'element/parameterization'
+require 'duxml'
+
+module Duxml
+  class Element
+    include Parameterization
+  end
 end

data/lib/re_duxml/evaluate/parser.rb

@@ -81,7 +81,8 @@ module ReDuxml
             op_stack << token.value
           when :grouping
             op_prop = token.value
-            case op_prop.to_s
+            op_str = op_prop.respond_to?(:nodes) ? op_prop.symbol : op_prop.to_s
+            case op_str
               when '('
                 if input.any? && input.first.type == :grouping && input.first.value.to_s == '('
                   input.shift
@@ -90,7 +91,7 @@ module ReDuxml
                   op_stack << op_prop
                 end
               when ')'
-                while op_stack.any? && op_stack.last.symbol != op_prop.pair.to_s
+                while op_stack.any? && op_stack.last.symbol != op_prop.pair.symbol
                   consume(arities.pop || op_stack.last.arity)
                 end
                 lparen = op_stack.pop

data/lib/re_duxml/evaluate.rb

@@ -1,78 +1,79 @@
-# Copyright (c) 2016 Freescale Semiconductor Inc.
-require_relative 'evaluate/parser'
-require_relative '../../lib/ruby_ext/macro'
-
-module ReDuxml
-  class Evaluator
-    LOGIC_FILE = File.expand_path(File.dirname(__FILE__) + '/../../xml/logic.xml')
-    include Math
-    include ReDuxml
-    include Symbolic
-
-    @param_hash
-    @parser
-
-    attr_reader :param_hash, :parser
-
-    def initialize(logic=nil)
-      @parser = Parser.new(logic || LOGIC_FILE)
-      @param_hash = {}
-    end
-
-    def to_s
-      "#<Evaluator: param_hash: '#{param_hash.to_s}' parser_logic: '#{parser}'>"
-    end
-
-    def evaluate(_expr, _param_hash={})
-      @param_hash = _param_hash
-      expr = resolve_params _expr
-      return expr if expr.parameterized?
-      return expr if Regexp.identifier.match(expr).to_s == expr
-      return expr.to_i if expr.to_i.to_s == expr
-      result = reduce parser.parse expr
-      case
-        when result.respond_to?(:imaginary), result.class == TrueClass, result.class == FalseClass then result
-        when result.respond_to?(:print) then result.print(parser.logic)
-        else result.to_s
-      end
-    end
-
-    private
-
-    def resolve_params(_expr)
-      expr = _expr.dup
-      param_hash.each do |param, val| expr.gsub!(param, val) end
-      expr
-    end
-
-    include Symbolic
-
-    def reduce(_ast)
-      ast = _ast.type.respond_to?(:symbol) ? _ast : new_ast(parser.logic[_ast.type.to_s], _ast.children.dup)
-      if ast.children.any?
-        operator = ast.type
-        args = ast.children.collect do |c|
-          new_child = c.children.any? ? reduce(c) : c.type
-          if new_child.is_a?(Node) && new_child.type.is_a?(Symbol)
-            new_ast(parser.logic[new_child.type.to_s], *new_child.children.dup)
-          else
-            new_child
-          end
-        end.flatten
-        begin
-        result = case operator.position
-                   when :prefix
-                     method(operator.ruby).call(*args)
-                   else
-                     args.first.send(operator.ruby, *args[1..-1])
-                 end
-        result.nil? ? ast : result
-        rescue
-          ast
-        end
-      else
-        ast
-      end
-    end # def reduce(ast)
-  end # class Evaluator
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require_relative 'evaluate/parser'
+require_relative '../../lib/ruby_ext/macro'
+
+module ReDuxml
+  class Evaluator
+    LOGIC_FILE = File.expand_path(File.dirname(__FILE__) + '/../../xml/logic.xml')
+    include Math
+    include ReDuxml
+    include Symbolic
+
+    @param_hash
+    @parser
+
+    attr_reader :param_hash, :parser
+
+    def initialize(logic=nil)
+      @parser = Parser.new(logic || LOGIC_FILE)
+      @param_hash = {}
+    end
+
+    def to_s
+      "#<Evaluator: param_hash: '#{param_hash.to_s}' parser_logic: '#{parser}'>"
+    end
+
+    def evaluate(_expr, _param_hash={})
+      @param_hash = _param_hash
+      expr = resolve_params _expr
+      return expr if expr.parameterized?
+      return expr if Regexp.identifier.match(expr).to_s == expr
+      return expr.to_i if expr.to_i.to_s == expr
+      result = reduce parser.parse expr
+      case
+        when result.respond_to?(:imaginary), result.class == TrueClass, result.class == FalseClass then result
+        when result.respond_to?(:name) then result.name
+        when result.respond_to?(:to_sexp) then result.print(parser.logic)
+        else result.to_s
+      end
+    end
+
+    private
+
+    def resolve_params(_expr)
+      expr = _expr.dup
+      param_hash.each do |param, val| expr.gsub!(param, val) end
+      expr
+    end
+
+    include Symbolic
+
+    def reduce(_ast)
+      ast = _ast.type.respond_to?(:symbol) ? _ast : new_ast(parser.logic[_ast.type.to_s], _ast.children.dup)
+      if ast.children.any?
+        operator = ast.type
+        args = ast.children.collect do |c|
+          new_child = c.children.any? ? reduce(c) : c.type
+          if new_child.is_a?(Node) && new_child.type.is_a?(Symbol)
+            new_ast(parser.logic[new_child.type.to_s], *new_child.children.dup)
+          else
+            new_child
+          end
+        end.flatten
+        begin
+        result = case operator.position
+                   when :prefix
+                     method(operator.ruby).call(*args)
+                   else
+                     args.first.send(operator.ruby, *args[1..-1])
+                 end
+        result.nil? ? ast : result
+        rescue
+          ast
+        end
+      else
+        ast
+      end
+    end # def reduce(ast)
+  end # class Evaluator
 end # module ReDux

data/lib/re_duxml.rb

@@ -1,99 +1,104 @@
-# Copyright (c) 2016 Freescale Semiconductor Inc.
-require File.expand_path(File.dirname(__FILE__) + '/ruby_ext/macro')
-require File.expand_path(File.dirname(__FILE__) + '/re_duxml/evaluate')
-require File.expand_path(File.dirname(__FILE__) + '/re_duxml/element')
-require 'con_duxml'
-
-module ReDuxml
-  include ConDuxml
-
-  # @param doc_or_node [Doc, String] XML to load; can be Doc, String path or String XML; also XML Element when recursing
-  # @return [Doc] instantiated XML with parameters resolved with given values
-  def resolve(doc_or_node, parent_params={})
-    if doc_or_node.is_a?(Element)
-      resolved_node = doc_or_node.stub
-      this_params = get_params(doc_or_node, parent_params)
-      new_children = doc_or_node.nodes.collect do |child|
-        if child.respond_to?(:nodes)
-          new_child = child.clone
-          new_child.attributes.each do |attr, val|
-            new_child[attr] = resolve_str(val, this_params)
-          end
-          if new_child.if?
-            new_child[:if] = nil
-            child_params = get_params(new_child, this_params)
-            new_child.activate.collect do |inst|
-              resolve(inst, child_params)
-            end
-          end
-        else
-          resolve_str(child, this_params)
-        end
-      end.flatten.compact
-      resolved_node << new_children
-    else
-      @e ||= Evaluator.new
-      @src_doc = get_doc doc_or_node
-      @doc = Doc.new << resolve(src_doc.root, parent_params)
-    end
-  end
-
-  attr_reader :e, :src_doc
-  private
-
-
-  def get_params(node, param_hash)
-    if node.nodes.any? and !node.text? and node.nodes[0].name == 'duxml:parameters'
-      local_params = {}
-      params = node[0].nodes.clone
-      params.each do |param|
-        new_val = resolve_str(param[:value], param_hash)
-        node[0].delete param unless new_val.parameterized?
-        local_params[param[:name]] = new_val
-      end
-      node.delete node[0] unless node[0].nodes.any?
-      param_hash.merge local_params
-    else
-      param_hash
-    end
-  end
-
-  # finds index of close parentheses corresponding to first open parentheses found in given str
-  def find_close_parens_index(str)
-    levels = 0
-    index = 0
-    str.each_char do |char|
-      case char
-        when '(' then
-          levels += 1
-        when ')' then
-          levels -= 1
-        else
-      end
-      return index if levels == 0
-      index += 1
-    end
-    raise Exception, "cannot find end of parameter expression!"
-  end
-
-  # @param content_str [String] string that may contain parameterized expressions e.g. "a @(var0+var1) string @(var2)"
-  # @param param_hash [Hash] keys are parameter names, values are parameter values e.g. {var0: 'param', var1: 'eter'}
-  # @return [String] content_str with parameter values substituted and algebraically reduced if any unknown parameters remain e.g. 'a parameter string @(var2)'
-  def resolve_str(content_str, param_hash)
-    question = find_expr content_str
-    return content_str if question.nil?
-    reply = Macro.new e.evaluate(question, param_hash).to_s
-    replacement_str = reply.parameterized? ? reply.macro_string : reply.demacro
-    macro_string = Macro.new(question).macro_string
-    content_str.gsub(macro_string, replacement_str)
-  end
-
-  # @param str [String] string that may contain parameter expression e.g. 'asdf @(param + 2) asdf'
-  # @return [String] macro string e.g. 'asdf @(param + 2) asdf' => 'param + 2'
-  def find_expr(str)
-    expr_start_index = str.index('@(')
-    return nil if expr_start_index.nil?
-    expr_end_index = find_close_parens_index str[expr_start_index+1..-1]
-    str[expr_start_index+2, expr_end_index-1]
-  end
-end # module Dux
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require File.expand_path(File.dirname(__FILE__) + '/ruby_ext/macro')
+require File.expand_path(File.dirname(__FILE__) + '/re_duxml/evaluate')
+require File.expand_path(File.dirname(__FILE__) + '/re_duxml/element')
+require File.expand_path(File.dirname(__FILE__) + '/re_duxml/array')
+require 'con_duxml'
+
+module ReDuxml
+  include ConDuxml
+
+  # @param doc_or_node [Doc, String] XML to load; can be Doc, String path or String XML; also XML Element when recursing
+  # @return [Doc] instantiated XML with parameters resolved with given values
+  def resolve(doc_or_node, parent_params={})
+    if doc_or_node.is_a?(Element)
+      resolved_node = doc_or_node.stub
+      resolved_node.attributes.each do |attr, val|
+        resolved_node[attr] = resolve_str(val, parent_params)
+      end
+      this_params = get_params(doc_or_node, parent_params)
+      new_children = doc_or_node.nodes.collect do |child|
+        if child.respond_to?(:nodes)
+          new_child = child.clone
+          new_child[:if] = resolve_str(new_child[:if], this_params) if new_child[:if]
+          if new_child.if?
+            new_child[:if] = nil
+            child_params = get_params(new_child, this_params)
+            new_instances = new_child.activate
+            i = -1
+            new_instances.collect do |inst|
+              i += 1
+              resolve(inst, child_params.merge({'iterator' => i.to_s}))
+            end
+          end
+        else
+          resolve_str(child, this_params)
+        end
+      end.flatten.compact
+      resolved_node << new_children
+    else
+      @e ||= Evaluator.new
+      @src_doc = get_doc doc_or_node
+      @doc = Doc.new << resolve(src_doc.root, parent_params)
+    end
+  end
+
+  attr_reader :e, :src_doc
+  private
+
+
+  def get_params(node, param_hash)
+    if node.nodes.any? and !node.text? and node.nodes[0].name == 'duxml:parameters'
+      local_params = {}
+      params = node[0].nodes.clone
+      params.each do |param|
+        new_val = resolve_str(param[:value], param_hash)
+        node[0].delete param unless new_val.parameterized?
+        local_params[param[:name]] = new_val
+      end
+      node.delete node[0] unless node[0].nodes.any?
+      param_hash.merge local_params
+    else
+      param_hash
+    end
+  end
+
+  # finds index of close parentheses corresponding to first open parentheses found in given str
+  def find_close_parens_index(str)
+    levels = 0
+    index = 0
+    str.each_char do |char|
+      case char
+        when '(' then
+          levels += 1
+        when ')' then
+          levels -= 1
+        else
+      end
+      return index if levels == 0
+      index += 1
+    end
+    raise Exception, "cannot find end of parameter expression!"
+  end
+
+  # @param content_str [String] string that may contain parameterized expressions e.g. "a @(var0+var1) string @(var2)"
+  # @param param_hash [Hash] keys are parameter names, values are parameter values e.g. {var0: 'param', var1: 'eter'}
+  # @return [String] content_str with parameter values substituted and algebraically reduced if any unknown parameters remain e.g. 'a parameter string @(var2)'
+  def resolve_str(content_str, param_hash)
+    question = find_expr content_str
+    return content_str if question.nil?
+    reply = Macro.new e.evaluate(question, param_hash).to_s
+    replacement_str = reply.parameterized? ? reply.macro_string : reply.demacro
+    macro_string = Macro.new(question).macro_string
+    content_str.gsub(macro_string, replacement_str)
+  end
+
+  # @param str [String] string that may contain parameter expression e.g. 'asdf @(param + 2) asdf'
+  # @return [String] macro string e.g. 'asdf @(param + 2) asdf' => 'param + 2'
+  def find_expr(str)
+    expr_start_index = str.index('@(')
+    return nil if expr_start_index.nil?
+    expr_end_index = find_close_parens_index str[expr_start_index+1..-1]
+    str[expr_start_index+2, expr_end_index-1]
+  end
+end # module Dux