rexml 3.2.1 → 3.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8154ea2369b6221818ab5eadd19d65464174dad7d4d1d63ab4b8b31ba475f701
-  data.tar.gz: 36e1512091b57d3724b379d77180ba715bb15e5d988c0f0aa129d78b662ae472
+  metadata.gz: 80a799893d66ff50bf8f93d6278b7243d29f1fcdc9d3e1b34ddbb3d044e288c8
+  data.tar.gz: c78162208507f9aa9dfbb7596d39fc3afbc99d244837b70b96f8477470ce7cc0
 SHA512:
-  metadata.gz: 883b2fbadd2d2967dae6eaf1285f518749cb995c0e8a5fa1ba7c644079e6e3acc49f6df108317b1d97cd03c84e074e0aba78bb259f0b658d27309cce78ba2a94
-  data.tar.gz: a0e1a2e4f7af8bfd6639929a7747d34e529783ffff986b0ae5e5d91b6ba10e5bfc07c2c5f9a387fea9632f1d4dddffcf9a04eabbcca91a2611e4c3dc83e7834b
+  metadata.gz: c0a6d3cd983aff3f4427dfa6e50e06b9720e2b704c55133d99ce9b7e81daeca038a5464341df81ada5322bf16b60c38e40d5301d90a659ed8a2a983db074e132
+  data.tar.gz: e261132e4c5389c0ac9f489f5dda410c4980b75a27166329faf94b316d966ff73e6dc1e79ee131270efbf52209924db193973cf22ea8e9e204039ca8773fa8fa

data/NEWS.md

@@ -1,5 +1,23 @@
 # News
 
+## 3.2.2 - 2019-06-03 {#version-3-2-2}
+
+### Fixes
+
+  * xpath: Fixed a bug for equality and relational expressions.
+    [GitHub#17][Reported by Mirko Budszuhn]
+
+  * xpath: Fixed `boolean()` implementation.
+
+  * xpath: Fixed `local_name()` with nonexistent node.
+
+  * xpath: Fixed `number()` implementation with node set.
+    [GitHub#18][Reported by Mirko Budszuhn]
+
+### Thanks
+
+  * Mirko Budszuhn
+
 ## 3.2.1 - 2019-05-04 {#version-3-2-1}
 
 ### Improvements

data/lib/rexml/functions.rb

@@ -66,11 +66,11 @@ module REXML
     def Functions::id( object )
     end
 
-    # UNTESTED
-    def Functions::local_name( node_set=nil )
-      get_namespace( node_set ) do |node|
+    def Functions::local_name(node_set=nil)
+      get_namespace(node_set) do |node|
         return node.local_name
       end
+      ""
     end
 
     def Functions::namespace_uri( node_set=nil )
@@ -315,18 +315,23 @@ module REXML
       end
     end
 
-    # UNTESTED
-    def Functions::boolean( object=nil )
-      if object.kind_of? String
-        if object =~ /\d+/u
-          return object.to_f != 0
-        else
-          return object.size > 0
-        end
-      elsif object.kind_of? Array
-        object = object.find{|x| x and true}
+    def Functions::boolean(object=@@context[:node])
+      case object
+      when true, false
+        object
+      when Float
+        return false if object.zero?
+        return false if object.nan?
+        true
+      when Numeric
+        not object.zero?
+      when String
+        not object.empty?
+      when Array
+        not object.empty?
+      else
+        object ? true : false
       end
-      return object ? true : false
     end
 
     # UNTESTED
@@ -380,25 +385,23 @@ module REXML
     #
     # an object of a type other than the four basic types is converted to a
     # number in a way that is dependent on that type
-    def Functions::number( object=nil )
-      object = @@context[:node] unless object
+    def Functions::number(object=@@context[:node])
       case object
       when true
         Float(1)
       when false
         Float(0)
       when Array
-        number(string( object ))
+        number(string(object))
       when Numeric
         object.to_f
       else
-        str = string( object )
-        # If XPath ever gets scientific notation...
-        #if str =~ /^\s*-?(\d*\.?\d+|\d+\.)([Ee]\d*)?\s*$/
-        if str =~ /^\s*-?(\d*\.?\d+|\d+\.)\s*$/
-          str.to_f
+        str = string(object)
+        case str.strip
+        when /\A\s*(-?(?:\d+(?:\.\d*)?|\.\d+))\s*\z/
+          $1.to_f
         else
-          (0.0 / 0.0)
+          Float::NAN
         end
       end
     end

data/lib/rexml/rexml.rb

@@ -24,7 +24,7 @@
 module REXML
   COPYRIGHT = "Copyright © 2001-2008 Sean Russell <ser@germane-software.com>"
   DATE = "2008/019"
-  VERSION = "3.2.1"
+  VERSION = "3.2.2"
   REVISION = ""
 
   Copyright = COPYRIGHT

data/lib/rexml/xpath_parser.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: false
+
+require "pp"
+
 require_relative 'namespace'
 require_relative 'xmltokens'
 require_relative 'attribute'
-require_relative 'syncenumerator'
 require_relative 'parsers/xpathparser'
 
 class Object
@@ -47,7 +49,10 @@ module REXML
     include XMLTokens
     LITERAL    = /^'([^']*)'|^"([^"]*)"/u
 
+    DEBUG = (ENV["REXML_XPATH_PARSER_DEBUG"] == "true")
+
     def initialize(strict: false)
+      @debug = DEBUG
       @parser = REXML::Parsers::XPathParser.new
       @namespaces = nil
       @variables = {}
@@ -135,7 +140,7 @@ module REXML
       when Array # nodeset
         unnode(result)
       else
-        result
+        [result]
       end
     end
 
@@ -162,10 +167,10 @@ module REXML
     # Expr takes a stack of path elements and a set of nodes (either a Parent
     # or an Array and returns an Array of matching nodes
     def expr( path_stack, nodeset, context=nil )
-      # enter(:expr, path_stack, nodeset)
+      enter(:expr, path_stack, nodeset) if @debug
       return nodeset if path_stack.length == 0 || nodeset.length == 0
       while path_stack.length > 0
-        # trace(:while, path_stack, nodeset)
+        trace(:while, path_stack, nodeset) if @debug
         if nodeset.length == 0
           path_stack.clear
           return []
@@ -184,7 +189,7 @@ module REXML
             child(nodeset)
           end
         when :literal
-          # trace(:literal, path_stack, nodeset)
+          trace(:literal, path_stack, nodeset) if @debug
           return path_stack.shift
         when :attribute
           nodeset = step(path_stack, any_type: :attribute) do
@@ -335,26 +340,24 @@ module REXML
           var_name = path_stack.shift
           return [@variables[var_name]]
 
-        # :and, :or, :eq, :neq, :lt, :lteq, :gt, :gteq
-        # TODO: Special case for :or and :and -- not evaluate the right
-        # operand if the left alone determines result (i.e. is true for
-        # :or and false for :and).
-        when :eq, :neq, :lt, :lteq, :gt, :gteq, :or
+        when :eq, :neq, :lt, :lteq, :gt, :gteq
           left = expr( path_stack.shift, nodeset.dup, context )
           right = expr( path_stack.shift, nodeset.dup, context )
           res = equality_relational_compare( left, op, right )
-          # trace(op, left, right, res)
+          trace(op, left, right, res) if @debug
           return res
 
+        when :or
+          left = expr(path_stack.shift, nodeset.dup, context)
+          return true if Functions.boolean(left)
+          right = expr(path_stack.shift, nodeset.dup, context)
+          return Functions.boolean(right)
+
         when :and
-          left = expr( path_stack.shift, nodeset.dup, context )
-          return [] unless left
-          if left.respond_to?(:inject) and !left.inject(false) {|a,b| a | b}
-            return []
-          end
-          right = expr( path_stack.shift, nodeset.dup, context )
-          res = equality_relational_compare( left, op, right )
-          return res
+          left = expr(path_stack.shift, nodeset.dup, context)
+          return false unless Functions.boolean(left)
+          right = expr(path_stack.shift, nodeset.dup, context)
+          return Functions.boolean(right)
 
         when :div, :mod, :mult, :plus, :minus
           left = expr(path_stack.shift, nodeset, context)
@@ -391,45 +394,48 @@ module REXML
         when :function
           func_name = path_stack.shift.tr('-','_')
           arguments = path_stack.shift
-          subcontext = context ? nil : { :size => nodeset.size }
-
-          res = []
-          cont = context
-          nodeset.each_with_index do |node, i|
-            if subcontext
-              if node.is_a?(XPathNode)
-                subcontext[:node]  = node.raw_node
-                subcontext[:index] = node.position
-              else
-                subcontext[:node]  = node
-                subcontext[:index] = i
-              end
-              cont = subcontext
-            end
-            arg_clone = arguments.dclone
-            args = arg_clone.collect do |arg|
-              result = expr( arg, [node], cont )
-              result = unnode(result) if result.is_a?(Array)
-              result
+
+          if nodeset.size != 1
+            message = "[BUG] Node set size must be 1 for function call: "
+            message += "<#{func_name}>: <#{nodeset.inspect}>: "
+            message += "<#{arguments.inspect}>"
+            raise message
+          end
+
+          node = nodeset.first
+          if context
+            target_context = context
+          else
+            target_context = {:size => nodeset.size}
+            if node.is_a?(XPathNode)
+              target_context[:node]  = node.raw_node
+              target_context[:index] = node.position
+            else
+              target_context[:node]  = node
+              target_context[:index] = 1
             end
-            Functions.context = cont
-            res << Functions.send( func_name, *args )
           end
-          return res
+          args = arguments.dclone.collect do |arg|
+            result = expr(arg, nodeset, target_context)
+            result = unnode(result) if result.is_a?(Array)
+            result
+          end
+          Functions.context = target_context
+          return Functions.send(func_name, *args)
 
         else
           raise "[BUG] Unexpected path: <#{op.inspect}>: <#{path_stack.inspect}>"
         end
       end # while
       return nodeset
-    # ensure
-    #   leave(:expr, path_stack, nodeset)
+    ensure
+      leave(:expr, path_stack, nodeset) if @debug
     end
 
     def step(path_stack, any_type: :element, order: :forward)
       nodesets = yield
       begin
-        # enter(:step, path_stack, nodesets)
+        enter(:step, path_stack, nodesets) if @debug
         nodesets = node_test(path_stack, nodesets, any_type: any_type)
         while path_stack[0] == :predicate
           path_stack.shift # :predicate
@@ -457,13 +463,13 @@ module REXML
           new_nodeset << XPathNode.new(node, position: new_nodeset.size + 1)
         end
         new_nodeset
-      # ensure
-      #   leave(:step, path_stack, new_nodeset)
+      ensure
+        leave(:step, path_stack, new_nodeset) if @debug
       end
     end
 
     def node_test(path_stack, nodesets, any_type: :element)
-      # enter(:node_test, path_stack, nodesets)
+      enter(:node_test, path_stack, nodesets) if @debug
       operator = path_stack.shift
       case operator
       when :qname
@@ -563,8 +569,8 @@ module REXML
         raise message
       end
       new_nodesets
-    # ensure
-    #   leave(:node_test, path_stack, new_nodesets)
+    ensure
+      leave(:node_test, path_stack, new_nodesets) if @debug
     end
 
     def filter_nodeset(nodeset)
@@ -577,7 +583,7 @@ module REXML
     end
 
     def evaluate_predicate(expression, nodesets)
-      # enter(:predicate, expression, nodesets)
+      enter(:predicate, expression, nodesets) if @debug
       new_nodesets = nodesets.collect do |nodeset|
         new_nodeset = []
         subcontext = { :size => nodeset.size }
@@ -590,7 +596,7 @@ module REXML
             subcontext[:index] = index + 1
           end
           result = expr(expression.dclone, [node], subcontext)
-          # trace(:predicate_evaluate, expression, node, subcontext, result)
+          trace(:predicate_evaluate, expression, node, subcontext, result) if @debug
           result = result[0] if result.kind_of? Array and result.length == 1
           if result.kind_of? Numeric
             if result == node.position
@@ -611,13 +617,15 @@ module REXML
         new_nodeset
       end
       new_nodesets
-    # ensure
-    #   leave(:predicate, new_nodesets)
+    ensure
+      leave(:predicate, new_nodesets) if @debug
     end
 
     def trace(*args)
       indent = "  " * @nest
-      puts("#{indent}#{args.inspect}")
+      PP.pp(args, "").each_line do |line|
+        puts("#{indent}#{line}")
+      end
     end
 
     def enter(tag, *args)
@@ -798,31 +806,28 @@ module REXML
       end
     end
 
-    def equality_relational_compare( set1, op, set2 )
+    def equality_relational_compare(set1, op, set2)
       set1 = unnode(set1) if set1.is_a?(Array)
       set2 = unnode(set2) if set2.is_a?(Array)
+
       if set1.kind_of? Array and set2.kind_of? Array
-        if set1.size == 0 or set2.size == 0
-          nd = set1.size==0 ? set2 : set1
-          rv = nd.collect { |il| compare( il, op, nil ) }
-          return rv
-        else
-          res = []
-          SyncEnumerator.new( set1, set2 ).each { |i1, i2|
-            i1 = norm( i1 )
-            i2 = norm( i2 )
-            res << compare( i1, op, i2 )
-          }
-          return res
+        # If both objects to be compared are node-sets, then the
+        # comparison will be true if and only if there is a node in the
+        # first node-set and a node in the second node-set such that the
+        # result of performing the comparison on the string-values of
+        # the two nodes is true.
+        set1.product(set2).any? do |node1, node2|
+          node_string1 = Functions.string(node1)
+          node_string2 = Functions.string(node2)
+          compare(node_string1, op, node_string2)
         end
-      end
-      # If one is nodeset and other is number, compare number to each item
-      # in nodeset s.t. number op number(string(item))
-      # If one is nodeset and other is string, compare string to each item
-      # in nodeset s.t. string op string(item)
-      # If one is nodeset and other is boolean, compare boolean to each item
-      # in nodeset s.t. boolean op boolean(item)
-      if set1.kind_of? Array or set2.kind_of? Array
+      elsif set1.kind_of? Array or set2.kind_of? Array
+        # If one is nodeset and other is number, compare number to each item
+        # in nodeset s.t. number op number(string(item))
+        # If one is nodeset and other is string, compare string to each item
+        # in nodeset s.t. string op string(item)
+        # If one is nodeset and other is boolean, compare boolean to each item
+        # in nodeset s.t. boolean op boolean(item)
         if set1.kind_of? Array
           a = set1
           b = set2
@@ -833,15 +838,23 @@ module REXML
 
         case b
         when true, false
-          return unnode(a) {|v| compare( Functions::boolean(v), op, b ) }
+          each_unnode(a).any? do |unnoded|
+            compare(Functions.boolean(unnoded), op, b)
+          end
         when Numeric
-          return unnode(a) {|v| compare( Functions::number(v), op, b )}
-        when /^\d+(\.\d+)?$/
-          b = Functions::number( b )
-          return unnode(a) {|v| compare( Functions::number(v), op, b )}
+          each_unnode(a).any? do |unnoded|
+            compare(Functions.number(unnoded), op, b)
+          end
+        when /\A\d+(\.\d+)?\z/
+          b = Functions.number(b)
+          each_unnode(a).any? do |unnoded|
+            compare(Functions.number(unnoded), op, b)
+          end
         else
-          b = Functions::string( b )
-          return unnode(a) { |v| compare( Functions::string(v), op, b ) }
+          b = Functions::string(b)
+          each_unnode(a).any? do |unnoded|
+            compare(Functions::string(unnoded), op, b)
+          end
         end
       else
         # If neither is nodeset,
@@ -851,34 +864,52 @@ module REXML
         #     Else, convert to string
         #   Else
         #     Convert both to numbers and compare
-        set1 = unnode(set1) if set1.is_a?(Array)
-        set2 = unnode(set2) if set2.is_a?(Array)
-        s1 = Functions.string(set1)
-        s2 = Functions.string(set2)
-        if s1 == 'true' or s1 == 'false' or s2 == 'true' or s2 == 'false'
-          set1 = Functions::boolean( set1 )
-          set2 = Functions::boolean( set2 )
+        compare(set1, op, set2)
+      end
+    end
+
+    def value_type(value)
+      case value
+      when true, false
+        :boolean
+      when Numeric
+        :number
+      when String
+        :string
+      else
+        raise "[BUG] Unexpected value type: <#{value.inspect}>"
+      end
+    end
+
+    def normalize_compare_values(a, operator, b)
+      a_type = value_type(a)
+      b_type = value_type(b)
+      case operator
+      when :eq, :neq
+        if a_type == :boolean or b_type == :boolean
+          a = Functions.boolean(a) unless a_type == :boolean
+          b = Functions.boolean(b) unless b_type == :boolean
+        elsif a_type == :number or b_type == :number
+          a = Functions.number(a) unless a_type == :number
+          b = Functions.number(b) unless b_type == :number
         else
-          if op == :eq or op == :neq
-            if s1 =~ /^\d+(\.\d+)?$/ or s2 =~ /^\d+(\.\d+)?$/
-              set1 = Functions::number( s1 )
-              set2 = Functions::number( s2 )
-            else
-              set1 = Functions::string( set1 )
-              set2 = Functions::string( set2 )
-            end
-          else
-            set1 = Functions::number( set1 )
-            set2 = Functions::number( set2 )
-          end
+          a = Functions.string(a) unless a_type == :string
+          b = Functions.string(b) unless b_type == :string
         end
-        return compare( set1, op, set2 )
+      when :lt, :lteq, :gt, :gteq
+        a = Functions.number(a) unless a_type == :number
+        b = Functions.number(b) unless b_type == :number
+      else
+        message = "[BUG] Unexpected compare operator: " +
+          "<#{operator.inspect}>: <#{a.inspect}>: <#{b.inspect}>"
+        raise message
       end
-      return false
+      [a, b]
     end
 
-    def compare a, op, b
-      case op
+    def compare(a, operator, b)
+      a, b = normalize_compare_values(a, operator, b)
+      case operator
       when :eq
         a == b
       when :neq
@@ -891,22 +922,27 @@ module REXML
         a > b
       when :gteq
         a >= b
-      when :and
-        a and b
-      when :or
-        a or b
       else
-        false
+        message = "[BUG] Unexpected compare operator: " +
+          "<#{operator.inspect}>: <#{a.inspect}>: <#{b.inspect}>"
+        raise message
       end
     end
 
-    def unnode(nodeset)
-      nodeset.collect do |node|
+    def each_unnode(nodeset)
+      return to_enum(__method__, nodeset) unless block_given?
+      nodeset.each do |node|
         if node.is_a?(XPathNode)
           unnoded = node.raw_node
         else
           unnoded = node
         end
+        yield(unnoded)
+      end
+    end
+
+    def unnode(nodeset)
+      each_unnode(nodeset).collect do |unnoded|
         unnoded = yield(unnoded) if block_given?
         unnoded
       end

data/rexml.gemspec

@@ -64,7 +64,6 @@ Gem::Specification.new do |spec|
     "lib/rexml/security.rb",
     "lib/rexml/source.rb",
     "lib/rexml/streamlistener.rb",
-    "lib/rexml/syncenumerator.rb",
     "lib/rexml/text.rb",
     "lib/rexml/undefinednamespaceexception.rb",
     "lib/rexml/validation/relaxng.rb",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rexml
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.2.2
 platform: ruby
 authors:
 - Kouhei Sutou
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-04 00:00:00.000000000 Z
+date: 2019-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -92,7 +92,6 @@ files:
 - lib/rexml/security.rb
 - lib/rexml/source.rb
 - lib/rexml/streamlistener.rb
-- lib/rexml/syncenumerator.rb
 - lib/rexml/text.rb
 - lib/rexml/undefinednamespaceexception.rb
 - lib/rexml/validation/relaxng.rb

data/lib/rexml/syncenumerator.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: false
-module REXML
-  class SyncEnumerator
-    include Enumerable
-
-    # Creates a new SyncEnumerator which enumerates rows of given
-    # Enumerable objects.
-    def initialize(*enums)
-      @gens = enums
-      @length = @gens.collect {|x| x.size }.max
-    end
-
-    # Returns the number of enumerated Enumerable objects, i.e. the size
-    # of each row.
-    def size
-      @gens.size
-    end
-
-    # Returns the number of enumerated Enumerable objects, i.e. the size
-    # of each row.
-    def length
-      @gens.length
-    end
-
-    # Enumerates rows of the Enumerable objects.
-    def each
-      @length.times {|i|
-        yield @gens.collect {|x| x[i]}
-      }
-      self
-    end
-  end
-end