rexml 3.3.7 → 3.4.2

data/lib/rexml/parsers/xpathparser.rb

@@ -215,7 +215,7 @@ module REXML
         else
           path << yield( parsed )
         end
-        return path.squeeze(" ")
+        path.squeeze(" ")
       end
       # For backward compatibility
       alias_method :preciate_to_string, :predicate_to_path
@@ -252,7 +252,7 @@ module REXML
             path = path[1..-1]
           end
         end
-        return RelativeLocationPath( path, parsed ) if path.size > 0
+        RelativeLocationPath( path, parsed ) if path.size > 0
       end
 
       #RelativeLocationPath
@@ -388,7 +388,7 @@ module REXML
         else
           path = original_path
         end
-        return path
+        path
       end
 
       # Filters the supplied nodeset on the predicate(s)
@@ -600,7 +600,7 @@ module REXML
         end
         rest = LocationPath(rest, n) if rest =~ /\A[\/\.\@\[\w*]/
         parsed.concat(n)
-        return rest
+        rest
       end
 
       #| FilterExpr Predicate

data/lib/rexml/quickpath.rb

@@ -41,7 +41,7 @@ module REXML
       else
         results = filter([element], path)
       end
-      return results
+      results
     end
 
     # Given an array of nodes it filters the array based on the path. The
@@ -51,18 +51,18 @@ module REXML
       return elements if path.nil? or path == '' or elements.size == 0
       case path
       when /^\/\//u                                                                                     # Descendant
-        return axe( elements, "descendant-or-self", $' )
+        axe( elements, "descendant-or-self", $' )
       when /^\/?\b(\w[-\w]*)\b::/u                                                      # Axe
-        return axe( elements, $1, $' )
+        axe( elements, $1, $' )
       when /^\/(?=\b([:!\w][-\.\w]*:)?[-!\*\.\w]*\b([^:(]|$)|\*)/u      # Child
         rest = $'
         results = []
         elements.each do |element|
           results |= filter( element.to_a, rest )
         end
-        return results
+        results
       when /^\/?(\w[-\w]*)\(/u                                                  # / Function
-        return function( elements, $1, $' )
+        function( elements, $1, $' )
       when Namespace::NAMESPLIT         # Element name
         name = $2
         ns = $1
@@ -73,21 +73,21 @@ module REXML
              (element.name == name and
               element.namespace == Functions.namespace_context[ns])))
         end
-        return filter( elements, rest )
+        filter( elements, rest )
       when /^\/\[/u
         matches = []
         elements.each do |element|
           matches |= predicate( element.to_a, path[1..-1] ) if element.kind_of? Element
         end
-        return matches
+        matches
       when /^\[/u                                                                                               # Predicate
-        return predicate( elements, path )
+        predicate( elements, path )
       when /^\/?\.\.\./u                                                                                # Ancestor
-        return axe( elements, "ancestor", $' )
+        axe( elements, "ancestor", $' )
       when /^\/?\.\./u                                                                                  # Parent
-        return filter( elements.collect{|e|e.parent}, $' )
+        filter( elements.collect{|e|e.parent}, $' )
       when /^\/?\./u                                                                                            # Self
-        return filter( elements, $' )
+        filter( elements, $' )
       when /^\*/u                                                                                                       # Any
         results = []
         elements.each do |element|
@@ -98,9 +98,10 @@ module REXML
           #     results |= filter( children, $' )
           #end
         end
-        return results
+        results
+      else
+        []
       end
-      return []
     end
 
     def QuickPath::axe( elements, axe_name, rest )
@@ -138,7 +139,7 @@ module REXML
         matches = filter(elements.collect{|element|
           element.previous_sibling}.uniq, rest )
       end
-      return matches.uniq
+      matches.uniq
     end
 
     OPERAND_ = '((?=(?:(?!and|or).)*[^\s<>=])[^\s<>=]+)'
@@ -200,15 +201,15 @@ module REXML
           results << element
         end
       end
-      return filter( results, rest )
+      filter( results, rest )
     end
 
     def QuickPath::attribute( name )
-      return Functions.node.attributes[name] if Functions.node.kind_of? Element
+      Functions.node.attributes[name] if Functions.node.kind_of? Element
     end
 
     def QuickPath::name()
-      return Functions.node.name if Functions.node.kind_of? Element
+      Functions.node.name if Functions.node.kind_of? Element
     end
 
     def QuickPath::method_missing( id, *args )
@@ -234,7 +235,7 @@ module REXML
           results << element if Functions.pair[0] == res
         end
       end
-      return results
+      results
     end
 
     def QuickPath::parse_args( element, string )

data/lib/rexml/rexml.rb

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

data/lib/rexml/security.rb

@@ -10,7 +10,7 @@ module REXML
 
     # Get the entity expansion limit. By default the limit is set to 10000.
     def self.entity_expansion_limit
-      return @@entity_expansion_limit
+      @@entity_expansion_limit
     end
 
     @@entity_expansion_text_limit = 10_240
@@ -22,7 +22,7 @@ module REXML
 
     # Get the entity expansion limit. By default the limit is set to 10240.
     def self.entity_expansion_text_limit
-      return @@entity_expansion_text_limit
+      @@entity_expansion_text_limit
     end
   end
 end

data/lib/rexml/source.rb

@@ -1,6 +1,7 @@
 # coding: US-ASCII
 # frozen_string_literal: false
 
+require "stringio"
 require "strscan"
 
 require_relative 'encoding'
@@ -18,6 +19,16 @@ module REXML
           pattern = /#{Regexp.escape(pattern)}/ if pattern.is_a?(String)
           super(pattern)
         end
+
+        def match?(pattern)
+          pattern = /#{Regexp.escape(pattern)}/ if pattern.is_a?(String)
+          super(pattern)
+        end
+
+        def skip(pattern)
+          pattern = /#{Regexp.escape(pattern)}/ if pattern.is_a?(String)
+          super(pattern)
+        end
       end
     end
     using StringScannerCheckScanString
@@ -35,7 +46,6 @@ module REXML
           arg.respond_to? :eof?
         IOSource.new(arg)
       elsif arg.respond_to? :to_str
-        require 'stringio'
         IOSource.new(StringIO.new(arg))
       elsif arg.kind_of? Source
         arg
@@ -55,11 +65,18 @@ module REXML
     attr_reader :encoding
 
     module Private
+      SPACES_PATTERN = /\s+/um
       SCANNER_RESET_SIZE = 100000
       PRE_DEFINED_TERM_PATTERNS = {}
-      pre_defined_terms = ["'", '"', "<"]
-      pre_defined_terms.each do |term|
-        PRE_DEFINED_TERM_PATTERNS[term] = /#{Regexp.escape(term)}/
+      pre_defined_terms = ["'", '"', "<", "]]>", "?>"]
+      if StringScanner::Version < "3.1.1"
+        pre_defined_terms.each do |term|
+          PRE_DEFINED_TERM_PATTERNS[term] = /#{Regexp.escape(term)}/
+        end
+      else
+        pre_defined_terms.each do |term|
+          PRE_DEFINED_TERM_PATTERNS[term] = term
+        end
       end
     end
     private_constant :Private
@@ -77,6 +94,7 @@ module REXML
         detect_encoding
       end
       @line = 0
+      @encoded_terms = {}
     end
 
     # The current buffer (what we're going to read next)
@@ -125,6 +143,18 @@ module REXML
       end
     end
 
+    def match?(pattern, cons=false)
+      if cons
+        !@scanner.skip(pattern).nil?
+      else
+        !@scanner.match?(pattern).nil?
+      end
+    end
+
+    def skip_spaces
+      @scanner.skip(Private::SPACES_PATTERN) ? true : false
+    end
+
     def position
       @scanner.pos
     end
@@ -133,6 +163,14 @@ module REXML
       @scanner.pos = pos
     end
 
+    def peek_byte
+      @scanner.peek_byte
+    end
+
+    def scan_byte
+      @scanner.scan_byte
+    end
+
     # @return true if the Source is exhausted
     def empty?
       @scanner.eos?
@@ -227,7 +265,7 @@ module REXML
 
     def read_until(term)
       pattern = Private::PRE_DEFINED_TERM_PATTERNS[term] || /#{Regexp.escape(term)}/
-      term = encode(term)
+      term = @encoded_terms[term] ||= encode(term)
       until str = @scanner.scan_until(pattern)
         break if @source.nil?
         break if @source.eof?
@@ -266,6 +304,23 @@ module REXML
       md.nil? ? nil : @scanner
     end
 
+    def match?( pattern, cons=false )
+      # To avoid performance issue, we need to increase bytes to read per scan
+      min_bytes = 1
+      while true
+        if cons
+          n_matched_bytes = @scanner.skip(pattern)
+        else
+          n_matched_bytes = @scanner.match?(pattern)
+        end
+        return true if n_matched_bytes
+        return false if pattern.is_a?(String)
+        return false if @source.nil?
+        return false unless read(nil, min_bytes)
+        min_bytes *= 2
+      end
+    end
+
     def empty?
       super and ( @source.nil? || @source.eof? )
     end
@@ -285,7 +340,7 @@ module REXML
         rescue
         end
         @er_source.seek(pos)
-      rescue IOError
+      rescue IOError, SystemCallError
         pos = -1
         line = -1
       end
@@ -294,14 +349,19 @@ module REXML
 
     private
     def readline(term = nil)
-      str = @source.readline(term || @line_break)
       if @pending_buffer
+        begin
+          str = @source.readline(term || @line_break)
+        rescue IOError
+        end
         if str.nil?
           str = @pending_buffer
         else
           str = @pending_buffer + str
         end
         @pending_buffer = nil
+      else
+        str = @source.readline(term || @line_break)
       end
       return nil if str.nil?
 

data/lib/rexml/text.rb

@@ -29,31 +29,16 @@ module REXML
       (0x10000..0x10FFFF)
     ]
 
-    if String.method_defined? :encode
-      VALID_XML_CHARS = Regexp.new('^['+
-        VALID_CHAR.map { |item|
-          case item
-          when Integer
-            [item].pack('U').force_encoding('utf-8')
-          when Range
-            [item.first, '-'.ord, item.last].pack('UUU').force_encoding('utf-8')
-          end
-        }.join +
-      ']*$')
-    else
-      VALID_XML_CHARS = /^(
-           [\x09\x0A\x0D\x20-\x7E]            # ASCII
-         | [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
-         |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
-         | [\xE1-\xEC\xEE][\x80-\xBF]{2}      # straight 3-byte
-         |  \xEF[\x80-\xBE]{2}                #
-         |  \xEF\xBF[\x80-\xBD]               # excluding U+fffe and U+ffff
-         |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
-         |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
-         | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
-         |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
-       )*$/nx;
-    end
+    VALID_XML_CHARS = Regexp.new('^['+
+      VALID_CHAR.map { |item|
+        case item
+        when Integer
+          [item].pack('U').force_encoding('utf-8')
+        when Range
+          [item.first, '-'.ord, item.last].pack('UUU').force_encoding('utf-8')
+        end
+      }.join +
+    ']*$')
 
     # Constructor
     # +arg+ if a String, the content is set to the String.  If a Text,
@@ -119,34 +104,24 @@ module REXML
       @entity_filter = entity_filter if entity_filter
       clear_cache
 
-      Text.check(@string, illegal, doctype) if @raw
+      Text.check(@string, illegal) if @raw
     end
 
     def parent= parent
       super(parent)
-      Text.check(@string, NEEDS_A_SECOND_CHECK, doctype) if @raw and @parent
+      Text.check(@string, NEEDS_A_SECOND_CHECK) if @raw and @parent
     end
 
     # check for illegal characters
-    def Text.check string, pattern, doctype
+    def Text.check string, pattern, doctype = nil
 
       # illegal anywhere
       if !string.match?(VALID_XML_CHARS)
-        if String.method_defined? :encode
-          string.chars.each do |c|
-            case c.ord
-            when *VALID_CHAR
-            else
-              raise "Illegal character #{c.inspect} in raw string #{string.inspect}"
-            end
-          end
-        else
-          string.scan(/[\x00-\x7F]|[\x80-\xBF][\xC0-\xF0]*|[\xC0-\xF0]/n) do |c|
-            case c.unpack('U')
-            when *VALID_CHAR
-            else
-              raise "Illegal character #{c.inspect} in raw string #{string.inspect}"
-            end
+        string.chars.each do |c|
+          case c.ord
+          when *VALID_CHAR
+          else
+            raise "Illegal character #{c.inspect} in raw string #{string.inspect}"
           end
         end
       end
@@ -202,7 +177,7 @@ module REXML
 
 
     def clone
-      return Text.new(self, true)
+      Text.new(self, true)
     end
 
 
@@ -225,10 +200,7 @@ module REXML
     end
 
     def doctype
-      if @parent
-        doc = @parent.document
-        doc.doctype if doc
-      end
+      @parent&.document&.doctype
     end
 
     REFERENCE = /#{Entity::REFERENCE}/
@@ -289,30 +261,32 @@ module REXML
       # Recursively wrap string at width.
       return string if string.length <= width
       place = string.rindex(' ', width) # Position in string with last ' ' before cutoff
-      if addnewline then
-        return "\n" + string[0,place] + "\n" + wrap(string[place+1..-1], width)
+      if addnewline
+        "\n" + string[0,place] + "\n" + wrap(string[place+1..-1], width)
       else
-        return string[0,place] + "\n" + wrap(string[place+1..-1], width)
+        string[0,place] + "\n" + wrap(string[place+1..-1], width)
       end
     end
 
     def indent_text(string, level=1, style="\t", indentfirstline=true)
+      Kernel.warn("#{self.class.name}#indent_text is deprecated. See REXML::Formatters", uplevel: 1)
       return string if level < 0
-      new_string = ''
+
+      new_string = +''
       string.each_line { |line|
         indent_string = style * level
         new_line = (indent_string + line).sub(/[\s]+$/,'')
         new_string << new_line
       }
       new_string.strip! unless indentfirstline
-      return new_string
+      new_string
     end
 
     # == DEPRECATED
     # See REXML::Formatters
     #
     def write( writer, indent=-1, transitive=false, ie_hack=false )
-      Kernel.warn("#{self.class.name}.write is deprecated.  See REXML::Formatters", uplevel: 1)
+      Kernel.warn("#{self.class.name}#write is deprecated.  See REXML::Formatters", uplevel: 1)
       formatter = if indent > -1
           REXML::Formatters::Pretty.new( indent )
         else
@@ -324,9 +298,7 @@ module REXML
     # FIXME
     # This probably won't work properly
     def xpath
-      path = @parent.xpath
-      path += "/text()"
-      return path
+      @parent.xpath + "/text()"
     end
 
     # Writes out text, substituting special characters beforehand.

data/lib/rexml/validation/relaxng.rb

@@ -157,16 +157,16 @@ module REXML
         if ( @events[@current].matches?(event) )
           @current += 1
           if @events[@current].nil?
-            return @previous.pop
+            @previous.pop
           elsif @events[@current].kind_of? State
             @current += 1
             @events[@current-1].previous = self
-            return @events[@current-1]
+            @events[@current-1]
           else
-            return self
+            self
           end
         else
-          return nil
+          nil
         end
       end
 
@@ -186,7 +186,7 @@ module REXML
       end
 
       def expected
-        return [@events[@current]]
+        [@events[@current]]
       end
 
       def <<( event )
@@ -244,7 +244,7 @@ module REXML
             evt = :end_attribute
           end
         end
-        return Event.new( evt, arg )
+        Event.new( evt, arg )
       end
     end
 
@@ -262,9 +262,10 @@ module REXML
           rv = super
           return rv if rv
           @prior = @previous.pop
-          return @prior.next( event )
+          @prior.next( event )
+        else
+          super
         end
-        super
       end
 
       def matches?(event)
@@ -274,7 +275,7 @@ module REXML
 
       def expected
         return [ @prior.expected, @events[0] ].flatten if @current == 0
-        return [@events[@current]]
+        [@events[@current]]
       end
     end
 
@@ -286,24 +287,24 @@ module REXML
           @current += 1
           if @events[@current].nil?
             @current = 0
-            return self
+            self
           elsif @events[@current].kind_of? State
             @current += 1
             @events[@current-1].previous = self
-            return @events[@current-1]
+            @events[@current-1]
           else
-            return self
+            self
           end
         else
           @prior = @previous.pop
           return @prior.next( event ) if @current == 0
-          return nil
+          nil
         end
       end
 
       def expected
         return [ @prior.expected, @events[0] ].flatten if @current == 0
-        return [@events[@current]]
+        [@events[@current]]
       end
     end
 
@@ -326,17 +327,17 @@ module REXML
           @ord += 1
           if @events[@current].nil?
             @current = 0
-            return self
+            self
           elsif @events[@current].kind_of? State
             @current += 1
             @events[@current-1].previous = self
-            return @events[@current-1]
+            @events[@current-1]
           else
-            return self
+            self
           end
         else
           return @previous.pop.next( event ) if @current == 0 and @ord > 0
-          return nil
+          nil
         end
       end
 
@@ -347,9 +348,9 @@ module REXML
 
       def expected
         if @current == 0 and @ord > 0
-          return [@previous[-1].expected, @events[0]].flatten
+          [@previous[-1].expected, @events[0]].flatten
         else
-          return [@events[@current]]
+          [@events[@current]]
         end
       end
     end
@@ -403,7 +404,7 @@ module REXML
 
       def expected
         return [@events[@current]] if @events.size > 0
-        return @choices.collect do |x|
+        @choices.collect do |x|
           if x[0].kind_of? State
             x[0].expected
           else
@@ -490,16 +491,16 @@ module REXML
           @current += 1
           if @events[@current].nil?
             return self unless @choices[@choice].nil?
-            return @previous.pop
+            @previous.pop
           elsif @events[@current].kind_of? State
             @current += 1
             @events[@current-1].previous = self
-            return @events[@current-1]
+            @events[@current-1]
           else
-            return self
+            self
           end
         else
-          return nil
+          nil
         end
       end
 
@@ -510,7 +511,7 @@ module REXML
 
       def expected
         return [@events[@current]] if @events[@current]
-        return @choices[@choice..-1].collect do |x|
+        @choices[@choice..-1].collect do |x|
           if x[0].kind_of? State
             x[0].expected
           else

data/lib/rexml/validation/validation.rb

@@ -80,26 +80,26 @@ module REXML
       end
 
       def single?
-        return (@event_type != :start_element and @event_type != :start_attribute)
+        (@event_type != :start_element and @event_type != :start_attribute)
       end
 
       def matches?( event )
         return false unless event[0] == @event_type
         case event[0]
         when nil
-          return true
+          true
         when :start_element
-          return true if event[1] == @event_arg
+          event[1] == @event_arg
         when :end_element
-          return true
+          true
         when :start_attribute
-          return true if event[1] == @event_arg
+          event[1] == @event_arg
         when :end_attribute
-          return true
+          true
         when :end_document
-          return true
+          true
         when :text
-          return (@event_arg.nil? or @event_arg == event[1])
+          @event_arg.nil? || @event_arg == event[1]
 =begin
         when :processing_instruction
           false