nokogiri 1.10.7 → 1.16.0

data/lib/nokogiri/xml/pp/character_data.rb

@@ -1,16 +1,19 @@
+# frozen_string_literal: true
+
 module Nokogiri
   module XML
+    # :nodoc: all
     module PP
       module CharacterData
-        def pretty_print pp # :nodoc:
-          nice_name = self.class.name.split('::').last
-          pp.group(2, "#(#{nice_name} ", ')') do
-            pp.pp text
+        def pretty_print(pp)
+          nice_name = self.class.name.split("::").last
+          pp.group(2, "#(#{nice_name} ", ")") do
+            pp.pp(text)
           end
         end
 
-        def inspect # :nodoc:
-          "#<#{self.class.name}:#{sprintf("0x%x",object_id)} #{text.inspect}>"
+        def inspect
+          "#<#{self.class.name}:#{format("0x%x", object_id)} #{text.inspect}>"
         end
       end
     end

data/lib/nokogiri/xml/pp/node.rb

@@ -1,53 +1,65 @@
+# frozen_string_literal: true
+
 module Nokogiri
   module XML
+    # :nodoc: all
     module PP
       module Node
-        def inspect # :nodoc:
-          attributes = inspect_attributes.reject { |x|
-            begin
-              attribute = send x
-              !attribute || (attribute.respond_to?(:empty?) && attribute.empty?)
-            rescue NoMethodError
-              true
-            end
-          }.map { |attribute|
-            "#{attribute.to_s.sub(/_\w+/, 's')}=#{send(attribute).inspect}"
-          }.join ' '
-          "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{attributes}>"
-        end
+        COLLECTIONS = [:attribute_nodes, :children]
 
-        def pretty_print pp # :nodoc:
-          nice_name = self.class.name.split('::').last
-          pp.group(2, "#(#{nice_name}:#{sprintf("0x%x", object_id)} {", '})') do
+        def inspect
+          attributes = inspect_attributes.reject do |x|
+            attribute = send(x)
+            !attribute || (attribute.respond_to?(:empty?) && attribute.empty?)
+          rescue NoMethodError
+            true
+          end
+          attributes = if inspect_attributes.length == 1
+            send(attributes.first).inspect
+          else
+            attributes.map do |attribute|
+              "#{attribute}=#{send(attribute).inspect}"
+            end.join(" ")
+          end
+          "#<#{self.class.name}:#{format("0x%x", object_id)} #{attributes}>"
+        end
 
+        def pretty_print(pp)
+          nice_name = self.class.name.split("::").last
+          pp.group(2, "#(#{nice_name}:#{format("0x%x", object_id)} {", "})") do
             pp.breakable
-            attrs = inspect_attributes.map { |t|
+
+            attrs = inspect_attributes.filter_map do |t|
               [t, send(t)] if respond_to?(t)
-            }.compact.find_all { |x|
+            end.find_all do |x|
               if x.last
-                if [:attribute_nodes, :children].include? x.first
+                if COLLECTIONS.include?(x.first)
                   !x.last.empty?
                 else
                   true
                 end
               end
-            }
+            end
 
-            pp.seplist(attrs) do |v|
-              if [:attribute_nodes, :children].include? v.first
-                pp.group(2, "#{v.first.to_s.sub(/_\w+$/, 's')} = [", "]") do
-                  pp.breakable
-                  pp.seplist(v.last) do |item|
-                    pp.pp item
+            if inspect_attributes.length == 1
+              pp.pp(attrs.first.last)
+            else
+              pp.seplist(attrs) do |v|
+                if COLLECTIONS.include?(v.first)
+                  pp.group(2, "#{v.first} = [", "]") do
+                    pp.breakable
+                    pp.seplist(v.last) do |item|
+                      pp.pp(item)
+                    end
                   end
+                else
+                  pp.text("#{v.first} = ")
+                  pp.pp(v.last)
                 end
-              else
-                pp.text "#{v.first} = "
-                pp.pp v.last
               end
             end
-            pp.breakable
 
+            pp.breakable
           end
         end
       end

data/lib/nokogiri/xml/pp.rb

@@ -1,2 +1,4 @@
-require 'nokogiri/xml/pp/node'
-require 'nokogiri/xml/pp/character_data'
+# frozen_string_literal: true
+
+require_relative "pp/node"
+require_relative "pp/character_data"

data/lib/nokogiri/xml/processing_instruction.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 module Nokogiri
   module XML
     class ProcessingInstruction < Node
-      def initialize document, name, content
+      def initialize(document, name, content)
+        super(document, name)
       end
     end
   end

data/lib/nokogiri/xml/reader.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Nokogiri
   module XML
     ###
@@ -7,18 +9,18 @@ module Nokogiri
     #
     # Here is an example of usage:
     #
-    #   reader = Nokogiri::XML::Reader(<<-eoxml)
-    #     <x xmlns:tenderlove='http://tenderlovemaking.com/'>
-    #       <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
-    #     </x>
-    #   eoxml
+    #     reader = Nokogiri::XML::Reader(<<-eoxml)
+    #       <x xmlns:tenderlove='http://tenderlovemaking.com/'>
+    #         <tenderlove:foo awesome='true'>snuggles!</tenderlove:foo>
+    #       </x>
+    #     eoxml
     #
-    #   reader.each do |node|
+    #     reader.each do |node|
     #
-    #     # node is an instance of Nokogiri::XML::Reader
-    #     puts node.name
+    #       # node is an instance of Nokogiri::XML::Reader
+    #       puts node.name
     #
-    #   end
+    #     end
     #
     # Note that Nokogiri::XML::Reader#each can only be called once!!  Once
     # the cursor moves through the entire document, you must parse the
@@ -69,41 +71,32 @@ module Nokogiri
       # A list of errors encountered while parsing
       attr_accessor :errors
 
-      # The encoding for the document
-      attr_reader :encoding
-
       # The XML source
       attr_reader :source
 
-      alias :self_closing? :empty_element?
+      alias_method :self_closing?, :empty_element?
 
-      def initialize source, url = nil, encoding = nil # :nodoc:
+      def initialize(source, url = nil, encoding = nil) # :nodoc:
         @source   = source
         @errors   = []
         @encoding = encoding
       end
       private :initialize
 
-      ###
-      # Get a list of attributes for the current node.
+      # Get the attributes and namespaces of the current node as a Hash.
+      #
+      # This is the union of Reader#attribute_hash and Reader#namespaces
+      #
+      # [Returns]
+      #   (Hash<String, String>) Attribute names and values, and namespace prefixes and hrefs.
       def attributes
-        Hash[attribute_nodes.map { |node|
-          [node.name, node.to_s]
-        }].merge(namespaces || {})
-      end
-
-      ###
-      # Get a list of attributes for the current node
-      def attribute_nodes
-        nodes = attr_nodes
-        nodes.each { |v| v.instance_variable_set(:@_r, self) }
-        nodes
+        attribute_hash.merge(namespaces)
       end
 
       ###
       # Move the cursor through the document yielding the cursor to the block
       def each
-        while cursor = self.read
+        while (cursor = read)
           yield cursor
         end
       end

data/lib/nokogiri/xml/relax_ng.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module Nokogiri
   module XML
     class << self
       ###
       # Create a new Nokogiri::XML::RelaxNG document from +string_or_io+.
       # See Nokogiri::XML::RelaxNG for an example.
-      def RelaxNG string_or_io
-        RelaxNG.new(string_or_io)
+      def RelaxNG(string_or_io, options = ParseOptions::DEFAULT_SCHEMA)
+        RelaxNG.new(string_or_io, options)
       end
     end
 
@@ -26,6 +28,10 @@ module Nokogiri
     #   end
     #
     # The list of errors are Nokogiri::XML::SyntaxError objects.
+    #
+    # NOTE: RelaxNG input is always treated as TRUSTED documents, meaning that they will cause the
+    # underlying parsing libraries to access network resources. This is counter to Nokogiri's
+    # "untrusted by default" security policy, but is a limitation of the underlying libraries.
     class RelaxNG < Nokogiri::XML::Schema
     end
   end

data/lib/nokogiri/xml/sax/document.rb

@@ -1,20 +1,21 @@
+# frozen_string_literal: true
+
 module Nokogiri
   module XML
     ###
-    # SAX Parsers are event driven parsers.  Nokogiri provides two different
-    # event based parsers when dealing with XML.  If you want to do SAX style
-    # parsing using HTML, check out Nokogiri::HTML::SAX.
+    # SAX Parsers are event driven parsers. Nokogiri provides two different event based parsers when
+    # dealing with XML. If you want to do SAX style parsing using HTML, check out
+    # Nokogiri::HTML4::SAX.
     #
-    # The basic way a SAX style parser works is by creating a parser,
-    # telling the parser about the events we're interested in, then giving
-    # the parser some XML to process.  The parser will notify you when
-    # it encounters events you said you would like to know about.
+    # The basic way a SAX style parser works is by creating a parser, telling the parser about the
+    # events we're interested in, then giving the parser some XML to process. The parser will notify
+    # you when it encounters events you said you would like to know about.
     #
-    # To register for events, you simply subclass Nokogiri::XML::SAX::Document,
-    # and implement the methods for which you would like notification.
+    # To register for events, you simply subclass Nokogiri::XML::SAX::Document, and implement the
+    # methods for which you would like notification.
     #
-    # For example, if I want to be notified when a document ends, and when an
-    # element starts, I would write a class like this:
+    # For example, if I want to be notified when a document ends, and when an element starts, I
+    # would write a class like this:
     #
     #   class MyDocument < Nokogiri::XML::SAX::Document
     #     def end_document
@@ -26,8 +27,7 @@ module Nokogiri
     #     end
     #   end
     #
-    # Then I would instantiate a SAX parser with this document, and feed the
-    # parser some XML
+    # Then I would instantiate a SAX parser with this document, and feed the parser some XML
     #
     #   # Create a new parser
     #   parser = Nokogiri::XML::SAX::Parser.new(MyDocument.new)
@@ -35,25 +35,21 @@ module Nokogiri
     #   # Feed the parser some XML
     #   parser.parse(File.open(ARGV[0]))
     #
-    # Now my document handler will be called when each node starts, and when
-    # then document ends.  To see what kinds of events are available, take
-    # a look at Nokogiri::XML::SAX::Document.
+    # Now my document handler will be called when each node starts, and when then document ends. To
+    # see what kinds of events are available, take a look at Nokogiri::XML::SAX::Document.
     #
-    # Two SAX parsers for XML are available, a parser that reads from a string
-    # or IO object as it feels necessary, and a parser that lets you spoon
-    # feed it XML.  If you want to let Nokogiri deal with reading your XML,
-    # use the Nokogiri::XML::SAX::Parser.  If you want to have fine grain
+    # Two SAX parsers for XML are available, a parser that reads from a string or IO object as it
+    # feels necessary, and a parser that lets you spoon feed it XML. If you want to let Nokogiri
+    # deal with reading your XML, use the Nokogiri::XML::SAX::Parser. If you want to have fine grain
     # control over the XML input, use the Nokogiri::XML::SAX::PushParser.
     module SAX
       ###
-      # This class is used for registering types of events you are interested
-      # in handling.  All of the methods on this class are available as
-      # possible events while parsing an XML document.  To register for any
-      # particular event, just subclass this class and implement the methods
-      # you are interested in knowing about.
+      # This class is used for registering types of events you are interested in handling. All of
+      # the methods on this class are available as possible events while parsing an XML document. To
+      # register for any particular event, just subclass this class and implement the methods you
+      # are interested in knowing about.
       #
-      # To only be notified about start and end element events, write a class
-      # like this:
+      # To only be notified about start and end element events, write a class like this:
       #
       #   class MyDocument < Nokogiri::XML::SAX::Document
       #     def start_element name, attrs = []
@@ -65,12 +61,12 @@ module Nokogiri
       #     end
       #   end
       #
-      # You can use this event handler for any SAX style parser included with
-      # Nokogiri.  See Nokogiri::XML::SAX, and Nokogiri::HTML::SAX.
+      # You can use this event handler for any SAX style parser included with Nokogiri. See
+      # Nokogiri::XML::SAX, and Nokogiri::HTML4::SAX.
       class Document
         ###
         # Called when an XML declaration is parsed
-        def xmldecl version, encoding, standalone
+        def xmldecl(version, encoding, standalone)
         end
 
         ###
@@ -88,13 +84,13 @@ module Nokogiri
         # * +name+ is the name of the tag
         # * +attrs+ are an assoc list of namespaces and attributes, e.g.:
         #     [ ["xmlns:foo", "http://sample.net"], ["size", "large"] ]
-        def start_element name, attrs = []
+        def start_element(name, attrs = [])
         end
 
         ###
         # Called at the end of an element
         # +name+ is the tag name
-        def end_element name
+        def end_element(name)
         end
 
         ###
@@ -104,16 +100,16 @@ module Nokogiri
         # +prefix+ is the namespace prefix for the element
         # +uri+ is the associated namespace URI
         # +ns+ is a hash of namespace prefix:urls associated with the element
-        def start_element_namespace name, attrs = [], prefix = nil, uri = nil, ns = []
+        def start_element_namespace(name, attrs = [], prefix = nil, uri = nil, ns = []) # rubocop:disable Metrics/ParameterLists
           ###
           # Deal with SAX v1 interface
-          name = [prefix, name].compact.join(':')
-          attributes = ns.map { |ns_prefix,ns_uri|
-            [['xmlns', ns_prefix].compact.join(':'), ns_uri]
-          } + attrs.map { |attr|
-            [[attr.prefix, attr.localname].compact.join(':'), attr.value]
-          }
-          start_element name, attributes
+          name = [prefix, name].compact.join(":")
+          attributes = ns.map do |ns_prefix, ns_uri|
+            [["xmlns", ns_prefix].compact.join(":"), ns_uri]
+          end + attrs.map do |attr|
+            [[attr.prefix, attr.localname].compact.join(":"), attr.value]
+          end
+          start_element(name, attributes)
         end
 
         ###
@@ -121,49 +117,49 @@ module Nokogiri
         # +name+ is the element's name
         # +prefix+ is the namespace prefix associated with the element
         # +uri+ is the associated namespace URI
-        def end_element_namespace name, prefix = nil, uri = nil
+        def end_element_namespace(name, prefix = nil, uri = nil)
           ###
           # Deal with SAX v1 interface
-          end_element [prefix, name].compact.join(':')
+          end_element([prefix, name].compact.join(":"))
         end
 
         ###
-        # Characters read between a tag.  This method might be called multiple
+        # Characters read between a tag. This method might be called multiple
         # times given one contiguous string of characters.
         #
         # +string+ contains the character data
-        def characters string
+        def characters(string)
         end
 
         ###
         # Called when comments are encountered
         # +string+ contains the comment data
-        def comment string
+        def comment(string)
         end
 
         ###
         # Called on document warnings
         # +string+ contains the warning
-        def warning string
+        def warning(string)
         end
 
         ###
         # Called on document errors
         # +string+ contains the error
-        def error string
+        def error(string)
         end
 
         ###
         # Called when cdata blocks are found
         # +string+ contains the cdata content
-        def cdata_block string
+        def cdata_block(string)
         end
 
         ###
         # Called when processing instructions are found
         # +name+ is the target of the instruction
         # +content+ is the value of the instruction
-        def processing_instruction name, content
+        def processing_instruction(name, content)
         end
       end
     end

data/lib/nokogiri/xml/sax/parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Nokogiri
   module XML
     module SAX
@@ -35,29 +37,29 @@ module Nokogiri
 
         # Encodinds this parser supports
         ENCODINGS = {
-          'NONE'        => 0, # No char encoding detected
-          'UTF-8'       => 1, # UTF-8
-          'UTF16LE'     => 2, # UTF-16 little endian
-          'UTF16BE'     => 3, # UTF-16 big endian
-          'UCS4LE'      => 4, # UCS-4 little endian
-          'UCS4BE'      => 5, # UCS-4 big endian
-          'EBCDIC'      => 6, # EBCDIC uh!
-          'UCS4-2143'   => 7, # UCS-4 unusual ordering
-          'UCS4-3412'   => 8, # UCS-4 unusual ordering
-          'UCS2'        => 9, # UCS-2
-          'ISO-8859-1'  => 10, # ISO-8859-1 ISO Latin 1
-          'ISO-8859-2'  => 11, # ISO-8859-2 ISO Latin 2
-          'ISO-8859-3'  => 12, # ISO-8859-3
-          'ISO-8859-4'  => 13, # ISO-8859-4
-          'ISO-8859-5'  => 14, # ISO-8859-5
-          'ISO-8859-6'  => 15, # ISO-8859-6
-          'ISO-8859-7'  => 16, # ISO-8859-7
-          'ISO-8859-8'  => 17, # ISO-8859-8
-          'ISO-8859-9'  => 18, # ISO-8859-9
-          'ISO-2022-JP' => 19, # ISO-2022-JP
-          'SHIFT-JIS'   => 20, # Shift_JIS
-          'EUC-JP'      => 21, # EUC-JP
-          'ASCII'       => 22, # pure ASCII
+          "NONE" => 0, # No char encoding detected
+          "UTF-8" => 1, # UTF-8
+          "UTF16LE" => 2, # UTF-16 little endian
+          "UTF16BE" => 3, # UTF-16 big endian
+          "UCS4LE" => 4, # UCS-4 little endian
+          "UCS4BE" => 5, # UCS-4 big endian
+          "EBCDIC" => 6, # EBCDIC uh!
+          "UCS4-2143" => 7, # UCS-4 unusual ordering
+          "UCS4-3412" => 8, # UCS-4 unusual ordering
+          "UCS2" => 9, # UCS-2
+          "ISO-8859-1" => 10, # ISO-8859-1 ISO Latin 1
+          "ISO-8859-2" => 11, # ISO-8859-2 ISO Latin 2
+          "ISO-8859-3" => 12, # ISO-8859-3
+          "ISO-8859-4" => 13, # ISO-8859-4
+          "ISO-8859-5" => 14, # ISO-8859-5
+          "ISO-8859-6" => 15, # ISO-8859-6
+          "ISO-8859-7" => 16, # ISO-8859-7
+          "ISO-8859-8" => 17, # ISO-8859-8
+          "ISO-8859-9" => 18, # ISO-8859-9
+          "ISO-2022-JP" => 19, # ISO-2022-JP
+          "SHIFT-JIS" => 20, # Shift_JIS
+          "EUC-JP" => 21, # EUC-JP
+          "ASCII" => 22, # pure ASCII
         }
 
         # The Nokogiri::XML::SAX::Document where events will be sent.
@@ -67,7 +69,7 @@ module Nokogiri
         attr_accessor :encoding
 
         # Create a new Parser with +doc+ and +encoding+
-        def initialize doc = Nokogiri::XML::SAX::Document.new, encoding = 'UTF-8'
+        def initialize(doc = Nokogiri::XML::SAX::Document.new, encoding = "UTF-8")
           @encoding = check_encoding(encoding)
           @document = doc
           @warned   = false
@@ -76,7 +78,7 @@ module Nokogiri
         ###
         # Parse given +thing+ which may be a string containing xml, or an
         # IO object.
-        def parse thing, &block
+        def parse(thing, &block)
           if thing.respond_to?(:read) && thing.respond_to?(:close)
             parse_io(thing, &block)
           else
@@ -86,34 +88,35 @@ module Nokogiri
 
         ###
         # Parse given +io+
-        def parse_io io, encoding = 'ASCII'
-          @encoding = check_encoding(encoding)
-          ctx = ParserContext.io(io, ENCODINGS[@encoding])
+        def parse_io(io, encoding = @encoding)
+          ctx = ParserContext.io(io, ENCODINGS[check_encoding(encoding)])
           yield ctx if block_given?
-          ctx.parse_with self
+          ctx.parse_with(self)
         end
 
         ###
         # Parse a file with +filename+
-        def parse_file filename
+        def parse_file(filename)
           raise ArgumentError unless filename
           raise Errno::ENOENT unless File.exist?(filename)
           raise Errno::EISDIR if File.directory?(filename)
-          ctx = ParserContext.file filename
+
+          ctx = ParserContext.file(filename)
           yield ctx if block_given?
-          ctx.parse_with self
+          ctx.parse_with(self)
         end
 
-        def parse_memory data
-          ctx = ParserContext.memory data
+        def parse_memory(data)
+          ctx = ParserContext.memory(data)
           yield ctx if block_given?
-          ctx.parse_with self
+          ctx.parse_with(self)
         end
 
         private
+
         def check_encoding(encoding)
           encoding.upcase.tap do |enc|
-            raise ArgumentError.new("'#{enc}' is not a valid encoding") unless ENCODINGS[enc]
+            raise ArgumentError, "'#{enc}' is not a valid encoding" unless ENCODINGS[enc]
           end
         end
       end

data/lib/nokogiri/xml/sax/parser_context.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Nokogiri
   module XML
     module SAX
@@ -6,9 +8,12 @@ module Nokogiri
       # by the user.  Instead, you should be looking at
       # Nokogiri::XML::SAX::Parser
       class ParserContext
-        def self.new thing, encoding = 'UTF-8'
-          [:read, :close].all? { |x| thing.respond_to?(x) } ?
-            io(thing, Parser::ENCODINGS[encoding]) : memory(thing)
+        def self.new(thing, encoding = "UTF-8")
+          if [:read, :close].all? { |x| thing.respond_to?(x) }
+            io(thing, Parser::ENCODINGS[encoding])
+          else
+            memory(thing)
+          end
         end
       end
     end

data/lib/nokogiri/xml/sax/push_parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Nokogiri
   module XML
     module SAX
@@ -23,7 +25,6 @@ module Nokogiri
       #   parser << "/div>"
       #   parser.finish
       class PushParser
-
         # The Nokogiri::XML::SAX::Document on which the PushParser will be
         # operating
         attr_accessor :document
@@ -31,7 +32,7 @@ module Nokogiri
         ###
         # Create a new PushParser with +doc+ as the SAX Document, providing
         # an optional +file_name+ and +encoding+
-        def initialize(doc = XML::SAX::Document.new, file_name = nil, encoding = 'UTF-8')
+        def initialize(doc = XML::SAX::Document.new, file_name = nil, encoding = "UTF-8")
           @document = doc
           @encoding = encoding
           @sax_parser = XML::SAX::Parser.new(doc)
@@ -43,16 +44,16 @@ module Nokogiri
         ###
         # Write a +chunk+ of XML to the PushParser.  Any callback methods
         # that can be called will be called immediately.
-        def write chunk, last_chunk = false
+        def write(chunk, last_chunk = false)
           native_write(chunk, last_chunk)
         end
-        alias :<< :write
+        alias_method :<<, :write
 
         ###
         # Finish the parsing.  This method is only necessary for
         # Nokogiri::XML::SAX::Document#end_document to be called.
         def finish
-          write '', true
+          write("", true)
         end
       end
     end

data/lib/nokogiri/xml/sax.rb

@@ -1,4 +1,6 @@
-require 'nokogiri/xml/sax/document'
-require 'nokogiri/xml/sax/parser_context'
-require 'nokogiri/xml/sax/parser'
-require 'nokogiri/xml/sax/push_parser'
+# frozen_string_literal: true
+
+require_relative "sax/document"
+require_relative "sax/parser_context"
+require_relative "sax/parser"
+require_relative "sax/push_parser"