re_duxml 0.1.0

checksums.yaml

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

data/lib/ast_ext/node.rb

@@ -0,0 +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
+end

data/lib/re_duxml/array.rb

@@ -0,0 +1,38 @@
+# 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
+end # module Dux

data/lib/re_duxml/element/parameterization.rb

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

data/lib/re_duxml/element.rb

@@ -0,0 +1,9 @@
+# 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/lexer.rb

@@ -0,0 +1,107 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require_relative '../../ruby_ext/regexp'
+require_relative '../../../lib/symbolic_ext/symbolic'
+
+module Lexer
+  @string_hash
+  @input
+  @tokens
+  attr_reader :string_hash
+  attr_accessor :input, :tokens
+
+  TOKEN_TYPES = {
+      string:   /STRING[\d]+/,
+      function: /log|exp|sqrt/,
+      bool:     /true|false/,
+      param:    Regexp.identifier,
+      num:      /\d+/,
+      grouping: /[\(\):,]/
+  }
+
+  Struct.new('Token', :type, :value)
+
+  def lex(expr)
+    @input = tag_strings(expr).split(/\b/).reverse.collect do |s| s.strip end
+    @tokens = []
+    while (sub_str = input.pop) do
+      type = get_type sub_str
+      value = formatted_value(sub_str, type)
+      tokens << (@last_token = Struct::Token.new(type, value)) unless value.nil?
+    end
+    @last_token = nil
+    tokens
+  end # def lex(expr)
+
+  private
+
+  attr_reader :last_token
+
+  def formatted_value(sub_str, type)
+    formatted_str = untag_strings subst_minus(sub_str)
+    case type
+      when :operator, :grouping
+        split_or_keep formatted_str
+      when :param then get_var(formatted_str)
+      when :num then formatted_str.to_i
+      when :bool then formatted_str == 'true'
+      else
+        formatted_str
+    end
+  end
+
+  def get_var(str)
+    if(var_token = tokens.find do |t| t.value.to_s == str end)
+      var_token.value
+    else
+      Symbolic.send(:var, name: str)
+    end
+  end
+
+  def split_or_keep(str)
+    if str.size > 1 && logic[str].nil?
+      str.split(//).reverse.each do |c| input << c unless c.strip.empty? end
+      nil
+    else
+      logic[str]
+    end
+  end
+
+  def get_type(sub_str)
+    TOKEN_TYPES.each do |type, regexp|
+      return type if regexp.match(sub_str).to_s == sub_str
+    end
+    :operator
+  end
+
+  def subst_minus(_str)
+    str = _str.dup
+    if str == '-'
+      unless last_token.nil? || last_token.type == 'operator' || %w(\( , :).include?(last_token.value)
+        str = "\u2013"
+        str.encode('utf-8')
+      end
+    end
+    str
+  end
+
+  #
+  def untag_strings(_expr)
+    expr = _expr.dup
+    string_hash.each do |k, v| expr.gsub!(k, v) end
+    expr
+  end
+
+  #strings can contain whitespaces and characters the parser may miscategorize as operators, etc.
+  # so they are replaced with unique keys in a module attribute hash for retrieval when doing string operations
+  # and returning final result
+  def tag_strings(expr)
+    tagged_str = expr.dup
+    @string_hash = {}
+    expr.scan(Regexp.string) do |s|
+      k = "STRING#{s.object_id}"
+      tagged_str[s] = k
+      @string_hash[k] = s
+    end
+    tagged_str
+  end
+end # module Lexer

data/lib/re_duxml/evaluate/operator.rb

@@ -0,0 +1,96 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+module Operator
+  # @return [Boolean]
+  def grouping?
+    nodes.find do |n|
+      return true if n.name == 'pair'
+    end
+    false
+  end
+
+  def parent=(logic)
+    @logic = logic
+  end
+
+  # @return [Boolean]
+  def right_associative?
+    nodes.find do |n|
+      return n.text == 'true' if n.name == 'right_associative'
+    end
+    false
+  end
+
+  # @return [String] name of ruby method corresponding to this operator
+  def ruby
+    nodes.find do |n|
+      return n.text if n.name == 'ruby'
+    end
+    symbol
+  end
+
+  # @return [String] literal for operator e.g. '+'
+  def symbol
+    return nil unless self.respond_to?(:nodes)
+    nodes.find do |n|
+      return n.text if n.name == 'symbol'
+    end
+    raise Exception
+  end
+
+  # @return [Symbol] :prefix, :infix (default), or :postfix
+  def position
+    nodes.find do |n|
+      return n.text.to_sym if n.name == 'position'
+    end
+    :infix
+  end
+
+  def reverse
+    nodes.find do |n|
+      return @logic[n.text] if n.name == 'reverse'
+    end
+    nil
+  end
+
+  def pair
+    return nil unless grouping?
+    nodes.find do |n|
+      return @logic[n.text] if n.name == 'pair'
+    end
+    raise Exception
+  end
+
+  def inverse
+    nodes.find do |n|
+      return @logic[n.text] if n.name == 'inverse'
+    end
+    nil
+  end
+
+  def to_s
+    symbol
+  end
+
+  def print
+    nodes.find do |n|
+      return n.text if n.name == 'print'
+    end
+    symbol
+  end
+
+  # @return [Regexp] expression to find operator in string
+  def regexp
+    nodes.find do |n|
+      return Regexp.new(n.text) if %w(regexp symbol ).include?(n.name)
+    end
+    # TODO exception here?
+  end
+
+  # @return [Fixnum] number of arguments required
+  def arity
+    nodes.find do |n|
+      return n.text.to_i if n.name == 'arity'
+    end
+    2
+  end
+end

data/lib/re_duxml/evaluate/parser.rb

@@ -0,0 +1,144 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require 'duxml'
+require_relative 'operator'
+require_relative 'lexer'
+
+module ReDuxml
+  class Parser
+    # hash of unique strings found in the parsed expression for substitution before (@see Lexer#lex) and
+    # after parsing to allow parser to handle strings that may contain white spaces, operators, etc.
+    @string_hash
+
+    # array of Struct::Tokens from lexer
+    @input
+
+    # array of AST nodes produced by parser; can be popped to subordinate to higher precedence operation nodes
+    @output
+
+    # array of operator definitions (not classes!) in XML form, extended by module Operator
+    @op_stack
+
+    # hash of operator symbol strings to Operator object that contains properties and methods to access them
+    @logic
+
+    # stack to track argument count for operators requiring more than 2
+    @arities
+
+    attr_reader :string_hash, :logic
+    attr_accessor :input, :output, :op_stack, :arities
+
+    include Duxml
+    include Lexer
+
+    def to_s
+      doc.logic.name
+    end
+
+    def initialize(_logic)
+      if _logic
+        load _logic
+        @logic = {}
+        doc.logic.Operator.each do |op|
+          op.parent = @logic
+          @logic[op.symbol] = op
+        end
+      end
+      raise Exception if logic.nil?
+    end
+
+    # TODO attribute code to Dentaku
+    def parse(expr)
+      @input = lex(expr)
+      @output = []
+      @op_stack = []
+      @arities = []
+
+      return nil if input.empty?
+
+      while(token = input.shift)
+        case token.type
+          when :num, :bool, :string, :param
+            output.push AST::Node.new(token.value)
+          when :operator
+            op_prop = token.value
+            arities << op_prop.arity-1 if op_prop.symbol == '?'
+            if op_prop.right_associative?
+              while op_stack.last && op_prop.precedence < op_stack.last.precedence
+                if !op_stack.last.grouping?
+                  consume
+                else
+                  break
+                end
+              end
+            else
+              while op_stack.last && op_prop.precedence <= op_stack.last.precedence && !op_stack.last.grouping?
+                consume
+              end
+            end
+            op_stack << op_prop
+          when :function
+            arities << 0
+            op_stack << token.value
+          when :grouping
+            op_prop = token.value
+            case op_prop.to_s
+              when '('
+                if input.any? && input.first.type == :grouping && input.first.value.to_s == '('
+                  input.shift
+                  consume(0)
+                else
+                  op_stack << op_prop
+                end
+              when ')'
+                while op_stack.any? && op_stack.last.symbol != op_prop.pair.to_s
+                  consume(arities.pop || op_stack.last.arity)
+                end
+                lparen = op_stack.pop
+                fail ParseError, "Unbalanced parenthesis" unless lparen && lparen.grouping?
+
+                if op_stack.last && op_stack.last.position == 'prefix'
+                  consume(arities.pop)
+                end
+              when ','
+                arities[-1] += 1
+                while op_stack.any? && op_stack.last.symbol != '('
+                  consume
+                end
+              when ':'
+                while op_stack.any? && op_stack.last.symbol != '?'
+                  consume(arities.pop)
+                end
+                arities[-1] += 1
+                op_stack << op_prop
+              else
+                fail ParseError, "Unknown grouping token #{ token.value }"
+            end # case token.value ... when :grouping
+          else
+            fail ParseError, "Not implemented for tokens of type #{ token.type }"
+        end # case token.type
+      end # while (token = input.shift)
+
+      while op_stack.any?
+        consume
+      end
+
+      unless output.count == 1
+        fail ParseError, "Invalid statement"
+      end
+
+      output.first
+    end # def parse(expr)
+
+    private
+
+    def consume(count=2)
+      op_stack.pop if op_stack.last.symbol == ':'
+      operator = op_stack.pop
+      output.push AST::Node.new(operator, get_args(operator.arity || count))
+    end
+
+    def get_args(count)
+      Array.new(count) { output.pop }.reverse.compact
+    end
+  end # class Parser
+end # module ReDuxml

data/lib/re_duxml/evaluate.rb

@@ -0,0 +1,78 @@
+# 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
+end # module ReDux

data/lib/re_duxml.rb

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

data/lib/ruby_ext/boolean.rb

@@ -0,0 +1,38 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require_relative '../../lib/ast_ext/node'
+
+class TrueClass
+  def ternary(a, b)
+    a
+  end
+
+  def and(obj)
+    obj
+  end
+
+  def or(obj)
+    true
+  end
+
+  def not
+    false
+  end
+end
+
+class FalseClass
+  def ternary(a, b)
+    b
+  end
+
+  def and(obj)
+    false
+  end
+
+  def or(obj)
+    obj
+  end
+
+  def not
+    true
+  end
+end

data/lib/ruby_ext/fixnum.rb

@@ -0,0 +1,6 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require_relative '../ast_ext/node'
+
+class Fixnum
+  include AST
+end

data/lib/ruby_ext/macro.rb

@@ -0,0 +1,51 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require_relative 'string'
+
+# string wrapped in parameter expression macro symbol and delimiters,
+# indicating content is to be parsed and resolved when building and validating XML design
+class Macro
+  include Enumerable
+  include Comparable
+
+  # is '@' by default
+  MACRO_SYMBOL = '@'
+  # are parentheses by default e.g. '()'
+  DELIMITERS = %w{( )}
+
+  @macro_string
+
+  # string including MACRO_SYMBOL and DELIMITERS
+  attr_accessor :macro_string
+
+  # checks a string to see if it's a valid macro expression without leading or trailing non-expression or delimiter text
+  def self.is_macro?(str)
+    str[0,2] == MACRO_SYMBOL+DELIMITERS.first && str[-1] == DELIMITERS.last && str.balanced_parens?
+  end
+
+  # takes given string and wraps in MACRO_SYMBOL and DELIMITERS if not already wrapped
+  # e.g. str => 'asdf'
+  #      Macro.new str => '@(asdf)'
+  def initialize(str)
+    @macro_string = Macro.is_macro?(str) ? str : "#{MACRO_SYMBOL}#{DELIMITERS.first}#{str}#{DELIMITERS.last}"
+  end
+
+  # compares #demacro'd @macro_string to obj
+  def <=>(obj)
+    demacro <=> obj
+  end
+
+  # just yields each character of #demacro'd @macro_string
+  def each(&block)
+    demacro.split(//).each do |char| yield char end
+  end
+
+  # returns string without MACRO_SYMBOL and DELIMITERS
+  def demacro
+    macro_string[2..-2]
+  end
+
+  # returns nil if not, and match data for any parameter names found
+  def parameterized?
+    macro_string.match Regexp.identifier
+  end
+end # class Macro

data/lib/ruby_ext/regexp.rb

@@ -0,0 +1,7 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+class Regexp
+  # @return [Regexp] single and double quoted strings
+  def self.string
+    /['"][^'"]*['"]/
+  end
+end

data/lib/ruby_ext/string.rb

@@ -0,0 +1,15 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require 'duxml'
+
+# extending String with #parameterized? and #balanced_parens? only to assist macro.rb
+class String
+  # returns whether or not contents include any Macro strings i.e. Parameter expressions
+  def parameterized?
+    self.include?('@(')
+  end
+
+  # returns whether number of open parentheses and close parentheses match
+  def balanced_parens?
+    self.match(/\(/).size == self.match(/\)/).size
+  end
+end # class String

data/lib/symbolic_ext/coerced.rb

@@ -0,0 +1,16 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require_relative 'variable'
+
+module Symbolic
+  class Coerced
+    include AST
+
+    def %(numeric)
+      numeric.new_ast(:%, @symbolic)
+    end
+
+    def **(numeric)
+      numeric.new_ast(:**, @symbolic)
+    end
+  end
+end

data/lib/symbolic_ext/symbolic.rb

@@ -0,0 +1,26 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require_relative 'coerced'
+
+module Symbolic
+  include AST
+
+  def %(var)
+    return 0 if self.object_id == var.object_id
+    return self % var if self.is_a?(Numeric) && var.is_a?(Numeric)
+    new_ast :%, var
+  end
+
+  def -@(var)
+    return -var unless var.is_a?(Node)
+    return -var.type if var.type.is_a?(Numeric)
+    reversed = var.type.reverse
+    reversed ? new_ast(reversed, *var.children.dup) : new_ast(:-@, [var])
+  end
+
+  def not(var)
+    return nil if var.is_a?(Symbolic::Variable)
+    return !var unless var.is_a?(Node)
+    inverted = var.type.inverse
+    inverted ? new_ast(inverted, *var.children.dup) : new_ast(:!, [var])
+  end
+end

data/lib/symbolic_ext/variable.rb

@@ -0,0 +1,61 @@
+# Copyright (c) 2016 Freescale Semiconductor Inc.
+require 'symbolic'
+require_relative '../ruby_ext/fixnum'
+require_relative '../ruby_ext/boolean'
+
+module Symbolic
+  class Variable
+    include AST
+
+    def and(obj)
+      return self if obj.equal?(true) || obj.equal?(self)
+      return false if obj.equal?(false)
+      nil
+    end
+
+    def or(obj)
+      return self if obj.equal?(false) || obj.equal?(self)
+      return true if obj.equal?(true)
+      nil
+    end
+
+    def <(obj)
+      eql?(obj) ? false : nil
+    end
+
+    def >(obj)
+      eql?(obj) ? false : nil
+    end
+
+    def !=(obj)
+      if obj.is_a?(Variable) || obj.is_a?(Numeric)
+        return object_id == obj.object_id ? false : nil
+      end
+
+      return !self if obj.equal?(true)
+      return self if obj.equal?(false)
+      return false if obj.equal?(self)
+      nil
+    end
+
+    def ==(obj)
+      if obj.is_a?(Variable) || obj.is_a?(Numeric)
+        result = object_id == obj.object_id ? true : nil
+        return result
+      end
+
+      return !self if obj.equal?(false)
+      return self if obj.equal?(true)
+      return true if obj.equal?(self)
+      nil
+    end
+
+    def >=(obj)
+      object_id == obj.object_id ? true : nil
+    end
+
+    def <=(obj)
+      object_id == obj.object_id ? true : nil
+    end
+  end # class Variable
+end # module Symbolic

data/xml/logic.xml

@@ -0,0 +1,153 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<logic>
+  <!-- indexing -->
+  <operator id="op_square" precedence="90" logic="string">
+    <regexp>\[</regexp>
+    <symbol>[</symbol>
+    <pair>]</pair>
+  </operator>
+  <operator id="cl_square" precedence="90" logic="string">
+    <regexp>\]</regexp>
+    <symbol>]</symbol>
+    <position>postfix</position>
+    <pair>[</pair>
+    <arity>1</arity>
+  </operator>
+
+  <!-- grouping -->
+  <operator id="op_parens" precedence="100" logic="global">
+    <regexp>\(</regexp>
+    <symbol>(</symbol>
+    <position>prefix</position>
+    <pair>)</pair>
+    <arity>1</arity>
+  </operator>
+  <operator id="cl_parens" precedence="100" logic="global">
+    <regexp>\)</regexp>
+    <symbol>)</symbol>
+    <position>postfix</position>
+    <pair>(</pair>
+    <arity>1</arity>
+  </operator>
+
+  <!-- combinators -->
+  <operator id="interro" logic="global" precedence="0">
+    <regexp>\?</regexp>
+    <symbol>?</symbol>
+    <right_associative>true</right_associative>
+    <ruby>ternary</ruby>
+    <arity>3</arity>
+    <pair>:</pair>
+  </operator>
+  <operator id="colon" logic="global" precedence="0">
+    <symbol>:</symbol>
+    <pair>?</pair>
+  </operator>
+  <operator id="and" logic="boolean" precedence="10">
+    <regexp>&amp;{2}</regexp>
+    <symbol>&amp;&amp;</symbol>
+    <ruby>and</ruby>
+    <identity>true</identity>
+  </operator>
+  <operator id="or" logic="boolean" precedence="10">
+    <regexp>\|{2}</regexp>
+    <symbol>||</symbol>
+    <ruby>or</ruby>
+    <identity>false</identity>
+  </operator>
+  <operator id="not" logic="boolean" precedence="11">
+    <position>prefix</position>
+    <regexp>(!)(?=\w|!)</regexp>
+    <ruby>not</ruby>
+    <symbol>!</symbol>
+    <arity>1</arity>
+    <identity>monad</identity>
+    <right_associative>true</right_associative>
+    <inverse>!</inverse>
+  </operator>
+
+  <!-- comparators -->
+  <operator id="eq" logic="arithmetic string" precedence="30">
+    <symbol>==</symbol>
+    <reverse>==</reverse>
+    <inverse>!=</inverse>
+  </operator>
+  <operator id="lt" logic="arithmetic string" precedence="35">
+    <symbol>&lt;</symbol>
+    <reverse>&gt;</reverse>
+    <inverse>&gt;=</inverse>
+  </operator>
+  <operator id="gt" logic="arithmetic string" precedence="35">
+    <symbol>></symbol>
+    <reverse>&lt;</reverse>
+    <inverse>&lt;=</inverse>
+  </operator>
+  <operator id="le" logic="arithmetic string" precedence="35">
+    <symbol>&lt;=</symbol>
+    <reverse>&gt;=</reverse>
+    <inverse>&gt;</inverse>
+  </operator>
+  <operator id="ge" logic="arithmetic string" precedence="35">
+    <symbol>>=</symbol>
+    <reverse>&lt;=</reverse>
+    <inverse>&lt;</inverse>
+  </operator>
+  <operator id="ne" logic="arithmetic string" precedence="30">
+    <symbol>!=</symbol>
+    <reverse>!=</reverse>
+    <inverse>==</inverse>
+  </operator>
+
+  <!-- arithmetic -->
+  <operator id="add" precedence="55" logic="arithmetic string">
+    <regexp>\+</regexp>
+    <symbol>+</symbol>
+    <identity>0</identity>
+    <inverse>&#8211;</inverse>
+  </operator>
+  <operator id="sub" precedence="55" logic="arithmetic">
+    <symbol>&#8211;</symbol>
+    <ruby>-</ruby>
+    <identity>0</identity>
+    <inverse>+</inverse>
+  </operator>
+  <operator id="neg" precedence="65" logic="arithmetic">
+    <position>prefix</position>
+    <symbol>-</symbol>
+    <ruby>-@</ruby>
+    <arity>1</arity>
+    <right_associative>true</right_associative>
+    <identity>0</identity>
+    <inverse>-</inverse>
+  </operator>
+  <operator id="mul" precedence="60" logic="arithmetic">
+    <regexp>\*</regexp>
+    <symbol>*</symbol>
+    <print>×</print>
+    <identity>1</identity>
+    <inverse>/</inverse>
+  </operator>
+  <operator id="div" precedence="60" logic="arithmetic">
+    <regexp>\/</regexp>
+    <symbol>/</symbol>
+    <print>÷</print>
+    <identity>1</identity>
+    <inverse>*</inverse>
+  </operator>
+  <operator id="mod" precedence="60" logic="arithmetic">
+    <symbol>%</symbol>
+  </operator>
+  <operator id="exp" precedence="70" logic="arithmetic">
+    <regexp>\*{2}</regexp>
+    <symbol>**</symbol>
+    <ruby>**</ruby>
+    <print>^</print>
+    <identity>1</identity>
+    <inverse>log</inverse>
+  </operator>
+  <operator id="log" precedence="70" logic="arithmetic">
+    <symbol>log</symbol>
+    <position>prefix</position>
+    <inverse>^</inverse>
+  </operator>
+</logic>

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: re_duxml
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Peter Kong
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: con_duxml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: symbolic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+description: 
+email:
+- peter.kong@nxp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ast_ext/node.rb
+- lib/re_duxml/array.rb
+- lib/re_duxml/element/parameterization.rb
+- lib/re_duxml/element.rb
+- lib/re_duxml/evaluate/lexer.rb
+- lib/re_duxml/evaluate/operator.rb
+- lib/re_duxml/evaluate/parser.rb
+- lib/re_duxml/evaluate.rb
+- lib/re_duxml.rb
+- lib/ruby_ext/boolean.rb
+- lib/ruby_ext/fixnum.rb
+- lib/ruby_ext/macro.rb
+- lib/ruby_ext/regexp.rb
+- lib/ruby_ext/string.rb
+- lib/symbolic_ext/coerced.rb
+- lib/symbolic_ext/symbolic.rb
+- lib/symbolic_ext/variable.rb
+- xml/logic.xml
+homepage: http://www.github.com/re_duxml
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.8.11
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14.1
+signing_key: 
+specification_version: 4
+summary: Reusable Dynamic Universal XML
+test_files: []