ReDuxml 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3c46a9c2cb2e9736c7e650a7ac4a709adcbafaec
+  data.tar.gz: ff9641aec41459ce78fa9290b392762f0c5a0f6d
+SHA512:
+  metadata.gz: 993f3702741994531bb37a9a453576eec93002d0054ebbfd23be4569b6dc89e52abddbf2bc8cece85e0544cfc501ab3442d4d7579c15de21559b96e1600cd045
+  data.tar.gz: 6f8ac1fa8e955a2a15c4b3c621131f9556e1a4c49458144f2079fc77447a72f5f5d30106123b6b122ce615dc149af84e71d4f87652f2fc443820a2b3a59c369f

data/lib/ast_ext/node.rb

@@ -0,0 +1,51 @@
+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]
+      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_dux.rb

@@ -0,0 +1,119 @@
+require File.expand_path(File.dirname(__FILE__) + '/ruby_ext/macro')
+require File.expand_path(File.dirname(__FILE__) + '/re_dux/evaluate')
+require File.expand_path(File.dirname(__FILE__) + '/re_dux/element')
+
+module ReDuxml
+  include Duxml
+
+  class ResolverClass < ::Ox::Sax
+    COND_ATTR_NAME = 'if'
+    REF_ATTR_NAME = 'ref'
+
+    @dead = false
+    @cursor_stack
+
+    attr_reader :e, :dead, :cursor_stack
+
+    # @param doc [Ox::Document] document that is being constructed as XML is parsed
+    # @param _observer [Object] object that will observe this document's content
+    def initialize(logic)
+      @cursor_stack = []
+      @e = ReDuxml::Evaluator.new(logic)
+    end
+
+    def cursor
+      @cursor_stack.last
+    end
+
+    def start_element(name)
+      new_el = Duxml::Element.new(name, line, column)
+      cursor << new_el unless cursor.nil?
+      @cursor_stack << new_el
+    end
+
+    def attr(name, val)
+      cursor[name] = val
+    end
+
+    def text(str)
+      cursor << str
+    end
+
+    def end_element(name)
+      case
+        when cursor.if?
+          cursor.remove_attribute(COND_ATTR_NAME)
+        when cursor.respond_to?(:instantiate)
+          # target = cursor.instantiate # target likely plural
+          @cursor_stack[-2].replace(cursor, target)
+        when cursor.ref?
+          # target = resolve_ref
+          @cursor_stack[-2].replace(cursor, target)
+          cursor.remove_attribute(REF_ATTR_NAME)
+        else
+          @cursor_stack[-2].remove(cursor)
+          return
+      end
+      @cursor_stack.pop
+    end
+  end
+
+  # generates new doc from current doc, resolving parameter values and instantiating Instance objects, and pruning filtered objonents.
+  def resolve(path=nil)
+    io = File.open path
+    saxer = ResolverClass.new(Duxml::Doc.new)
+    Ox.sax_parse(saxer, io, {convert_special: true, symbolize: false})
+    saxer.cursor
+  end
+
+  private
+
+  # 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
+
+  # takes given potentially parameterized string, applies given param_hash's values, then resolves parameter expressions
+  # returning resolved result
+  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)
+    replacement_str = reply.parameterized? ? reply : reply.demacro
+    macro_string = Macro.new(question)
+    content_str.gsub(macro_string, replacement_str)
+  end
+
+  # finds macro expression within given string
+  # e.g. find_expr 'asdf @(param) asdf' => 'param'
+  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
+
+  # returns first ancestor that is NOT an Instance
+  def find_non_inst_ancestor(node)
+    cur = node.parent
+    return if cur.nil?
+    if cur.respond_to?(:params) && cur.simple_class != 'design'
+      find_non_inst_ancestor cur
+    else
+      cur
+    end
+  end
+end # module Dux

data/lib/re_dux/element.rb

@@ -0,0 +1,8 @@
+require_relative 'element/parameterization'
+require 'duxml'
+
+module Duxml
+  class Element
+    include Parameterization
+  end
+end

data/lib/re_dux/element/parameterization.rb

@@ -0,0 +1,17 @@
+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 = xml[: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_dux/evaluate.rb

@@ -0,0 +1,74 @@
+require_relative 'evaluate/parser'
+
+module ReDuxml
+  class Evaluator
+    include Math
+    include ReDuxml
+    include Symbolic
+
+    COMPARATORS = %w()
+
+    @param_hash
+    @parser
+
+    attr_reader :param_hash, :parser
+
+    def initialize(logic=nil)
+      @parser = Parser.new(logic || '../../xml/logic.xml')
+      @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
+      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_dux/evaluate/lexer.rb

@@ -0,0 +1,106 @@
+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_dux/evaluate/operator.rb

@@ -0,0 +1,96 @@
+module Operator
+  include Reportable
+  # @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_dux/evaluate/parser.rb

@@ -0,0 +1,143 @@
+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_dux/parameters.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/../symbolic_ext/variable')
+
+module Duxml
+  module Parameter; end
+
+  # represents a parameter that can be used in any element's attribute values or text content
+  # and is replaced with its value when validating an XML design
+  class ParameterClass < ::Symbolic::Variable
+    # Parameter can be initialized from XML Element or Ruby args
+    # @param args[0] [String] must be name of Parameter
+    # @param args[1] [String|Fixnum|Float|Boolean] can be starting value of Parameter
+    # @param args[2] [String] can be description text of Parameter
+    def initialize(name, value=nil)
+      @name, @value = name, value
+    end
+  end # class Parameter
+
+  module Parameter
+    # @param val [String|Fixnum|Float|Boolean] changes value of Parameter and reports change
+    def value=(val)
+      if val != self[:value]
+        old_val = self[:value]
+        self[:value] = val
+        report :change_attribute, {old_value: old_val, new_value: val, attr_name: 'value'}
+      end
+    end # def value=
+  end
+end # module Dux

data/lib/ruby_ext/boolean.rb

@@ -0,0 +1,37 @@
+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,5 @@
+require_relative '../ast_ext/node'
+
+class Fixnum
+  include AST
+end

data/lib/ruby_ext/macro.rb

@@ -0,0 +1,50 @@
+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
+
+  # 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 = is_macro?(str) ? str : "#{MACRO_SYMBOL}#{DELIMITERS.first}#{str}#{DELIMITERS.last}"
+  end
+
+  # checks a string to see if it's a valid macro expression without leading or trailing non-expression or delimiter text
+  def is_macro?(str)
+    str[0,2] == MACRO_SYMBOL+DELIMITERS.first && str[-1] == DELIMITERS.last && str.balanced_parens?
+  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,8 @@
+require 'duxml'
+
+class Regexp
+  # @return [Regexp] single and double quoted strings
+  def self.string
+    /['"][^'"]*['"]/
+  end
+end

data/lib/ruby_ext/string.rb

@@ -0,0 +1,12 @@
+# 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,15 @@
+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,25 @@
+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,60 @@
+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

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: ReDuxml
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Peter Kong
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: duxml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !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_dux/element/parameterization.rb
+- lib/re_dux/element.rb
+- lib/re_dux/evaluate/lexer.rb
+- lib/re_dux/evaluate/operator.rb
+- lib/re_dux/evaluate/parser.rb
+- lib/re_dux/evaluate.rb
+- lib/re_dux/parameters.rb
+- lib/re_dux.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
+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: []