nokogiri 1.13.8 → 1.15.7

data/lib/nokogiri/xml/parse_options.rb

@@ -1,84 +1,163 @@
+# coding: utf-8
 # frozen_string_literal: true
 
 module Nokogiri
   module XML
-    ###
-    # Parse options for passing to Nokogiri.XML or Nokogiri.HTML
-    #
-    # == Building combinations of parse options
-    # You can build your own combinations of these parse options by using any of the following methods:
-    # *Note*: All examples attempt to set the +RECOVER+ & +NOENT+ options.
-    # [Ruby's bitwise operators] You can use the Ruby bitwise operators to set various combinations.
-    #   Nokogiri.XML('<content>Chapter 1</content', nil, nil, Nokogiri::XML::ParseOptions.new((1 << 0) | (1 << 1)))
-    # [Method chaining] Every option has an equivalent method in lowercase. You can chain these methods together to set various combinations.
-    #   Nokogiri.XML('<content>Chapter 1</content', nil, nil, Nokogiri::XML::ParseOptions.new.recover.noent)
-    # [Using Ruby Blocks] You can also setup parse combinations in the block passed to Nokogiri.XML or Nokogiri.HTML
-    #   Nokogiri.XML('<content>Chapter 1</content') {|config| config.recover.noent}
-    #
-    # == Removing particular parse options
-    # You can also remove options from an instance of +ParseOptions+ dynamically.
-    # Every option has an equivalent <code>no{option}</code> method in lowercase. You can call these methods on an instance of +ParseOptions+ to remove the option.
-    # Note that this is not available for +STRICT+.
-    #
-    #   # Setting the RECOVER & NOENT options...
-    #   options = Nokogiri::XML::ParseOptions.new.recover.noent
-    #   # later...
-    #   options.norecover # Removes the Nokogiri::XML::ParseOptions::RECOVER option
-    #   options.nonoent # Removes the Nokogiri::XML::ParseOptions::NOENT option
+    # Options that control the parsing behavior for XML::Document, XML::DocumentFragment,
+    # HTML4::Document, HTML4::DocumentFragment, XSLT::Stylesheet, and XML::Schema.
+    #
+    # These options directly expose libxml2's parse options, which are all boolean in the sense that
+    # an option is "on" or "off".
+    #
+    # 💡 Note that HTML5 parsing has a separate, orthogonal set of options due to the nature of the
+    # HTML5 specification. See Nokogiri::HTML5.
+    #
+    # ⚠ Not all parse options are supported on JRuby. Nokogiri will attempt to invoke the equivalent
+    # behavior in Xerces/NekoHTML on JRuby when it's possible.
+    #
+    # == Setting and unsetting parse options
+    #
+    # You can build your own combinations of parse options by using any of the following methods:
+    #
+    # [ParseOptions method chaining]
+    #
+    #   Every option has an equivalent method in lowercase. You can chain these methods together to
+    #   set various combinations.
+    #
+    #     # Set the HUGE & PEDANTIC options
+    #     po = Nokogiri::XML::ParseOptions.new.huge.pedantic
+    #     doc = Nokogiri::XML::Document.parse(xml, nil, nil, po)
+    #
+    #   Every option has an equivalent <code>no{option}</code> method in lowercase. You can call these
+    #   methods on an instance of ParseOptions to unset the option.
+    #
+    #     # Set the HUGE & PEDANTIC options
+    #     po = Nokogiri::XML::ParseOptions.new.huge.pedantic
+    #
+    #     # later we want to modify the options
+    #     po.nohuge # Unset the HUGE option
+    #     po.nopedantic # Unset the PEDANTIC option
+    #
+    #   💡 Note that some options begin with "no" leading to the logical but perhaps unintuitive
+    #   double negative:
+    #
+    #     po.nocdata # Set the NOCDATA parse option
+    #     po.nonocdata # Unset the NOCDATA parse option
+    #
+    #   💡 Note that negation is not available for STRICT, which is itself a negation of all other
+    #   features.
+    #
+    #
+    # [Using Ruby Blocks]
+    #
+    #   Most parsing methods will accept a block for configuration of parse options, and we
+    #   recommend chaining the setter methods:
+    #
+    #     doc = Nokogiri::XML::Document.parse(xml) { |config| config.huge.pedantic }
+    #
+    #
+    # [ParseOptions constants]
+    #
+    #   You can also use the constants declared under Nokogiri::XML::ParseOptions to set various
+    #   combinations. They are bits in a bitmask, and so can be combined with bitwise operators:
+    #
+    #     po = Nokogiri::XML::ParseOptions.new(Nokogiri::XML::ParseOptions::HUGE | Nokogiri::XML::ParseOptions::PEDANTIC)
+    #     doc = Nokogiri::XML::Document.parse(xml, nil, nil, po)
     #
     class ParseOptions
       # Strict parsing
       STRICT      = 0
-      # Recover from errors
+
+      # Recover from errors. On by default for XML::Document, XML::DocumentFragment,
+      # HTML4::Document, HTML4::DocumentFragment, XSLT::Stylesheet, and XML::Schema.
       RECOVER     = 1 << 0
-      # Substitute entities
+
+      # Substitute entities. Off by default.
+      #
+      # ⚠ This option enables entity substitution, contrary to what the name implies.
+      #
+      # ⚠ <b>It is UNSAFE to set this option</b> when parsing untrusted documents.
       NOENT       = 1 << 1
-      # Load external subsets
+
+      # Load external subsets. On by default for XSLT::Stylesheet.
+      #
+      # ⚠ <b>It is UNSAFE to set this option</b> when parsing untrusted documents.
       DTDLOAD     = 1 << 2
-      # Default DTD attributes
+
+      # Default DTD attributes. On by default for XSLT::Stylesheet.
       DTDATTR     = 1 << 3
-      # validate with the DTD
+
+      # Validate with the DTD. Off by default.
       DTDVALID    = 1 << 4
-      # suppress error reports
+
+      # Suppress error reports. On by default for HTML4::Document and HTML4::DocumentFragment
       NOERROR     = 1 << 5
-      # suppress warning reports
+
+      # Suppress warning reports. On by default for HTML4::Document and HTML4::DocumentFragment
       NOWARNING   = 1 << 6
-      # pedantic error reporting
+
+      # Enable pedantic error reporting. Off by default.
       PEDANTIC    = 1 << 7
-      # remove blank nodes
+
+      # Remove blank nodes. Off by default.
       NOBLANKS    = 1 << 8
-      # use the SAX1 interface internally
+
+      # Use the SAX1 interface internally. Off by default.
       SAX1        = 1 << 9
-      # Implement XInclude substitution
+
+      # Implement XInclude substitution. Off by default.
       XINCLUDE    = 1 << 10
-      # Forbid network access. Recommended for dealing with untrusted documents.
+
+      # Forbid network access. On by default for XML::Document, XML::DocumentFragment,
+      # HTML4::Document, HTML4::DocumentFragment, XSLT::Stylesheet, and XML::Schema.
+      #
+      # ⚠ <b>It is UNSAFE to unset this option</b> when parsing untrusted documents.
       NONET       = 1 << 11
-      # Do not reuse the context dictionary
+
+      # Do not reuse the context dictionary. Off by default.
       NODICT      = 1 << 12
-      # remove redundant namespaces declarations
+
+      # Remove redundant namespaces declarations. Off by default.
       NSCLEAN     = 1 << 13
-      # merge CDATA as text nodes
+
+      # Merge CDATA as text nodes. On by default for XSLT::Stylesheet.
       NOCDATA     = 1 << 14
-      # do not generate XINCLUDE START/END nodes
+
+      # Do not generate XInclude START/END nodes. Off by default.
       NOXINCNODE  = 1 << 15
-      # compact small text nodes; no modification of the tree allowed afterwards (will possibly crash if you try to modify the tree)
+
+      # Compact small text nodes. Off by default.
+      #
+      # ⚠ No modification of the DOM tree is allowed after parsing. libxml2 may crash if you try to
+      # modify the tree.
       COMPACT     = 1 << 16
-      # parse using XML-1.0 before update 5
+
+      # Parse using XML-1.0 before update 5. Off by default
       OLD10       = 1 << 17
-      # do not fixup XINCLUDE xml:base uris
+
+      # Do not fixup XInclude xml:base uris. Off by default
       NOBASEFIX   = 1 << 18
-      # relax any hardcoded limit from the parser
+
+      # Relax any hardcoded limit from the parser. Off by default.
+      #
+      # ⚠ There may be a performance penalty when this option is set.
       HUGE        = 1 << 19
-      # line numbers stored as long int (instead of a short int)
+
+      # Support line numbers up to <code>long int</code> (default is a <code>short int</code>). On
+      # by default for for XML::Document, XML::DocumentFragment, HTML4::Document,
+      # HTML4::DocumentFragment, XSLT::Stylesheet, and XML::Schema.
       BIG_LINES   = 1 << 22
 
-      # the default options used for parsing XML documents
+      # The options mask used by default for parsing XML::Document and XML::DocumentFragment
       DEFAULT_XML  = RECOVER | NONET | BIG_LINES
-      # the default options used for parsing XSLT stylesheets
+
+      # The options mask used by default used for parsing XSLT::Stylesheet
       DEFAULT_XSLT = RECOVER | NONET | NOENT | DTDLOAD | DTDATTR | NOCDATA | BIG_LINES
-      # the default options used for parsing HTML documents
+
+      # The options mask used by default used for parsing HTML4::Document and HTML4::DocumentFragment
       DEFAULT_HTML = RECOVER | NOERROR | NOWARNING | NONET | BIG_LINES
-      # the default options used for parsing XML schemas
+
+      # The options mask used by default used for parsing XML::Schema
       DEFAULT_SCHEMA = NONET | BIG_LINES
 
       attr_accessor :options
@@ -90,7 +169,7 @@ module Nokogiri
       constants.each do |constant|
         next if constant.to_sym == :STRICT
 
-        class_eval %{
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
           def #{constant.downcase}
             @options |= #{constant}
             self
@@ -104,7 +183,7 @@ module Nokogiri
           def #{constant.downcase}?
             #{constant} & @options == #{constant}
           end
-        }
+        RUBY
       end
 
       def strict

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

@@ -5,15 +5,22 @@ module Nokogiri
     # :nodoc: all
     module PP
       module Node
+        COLLECTIONS = [:attribute_nodes, :children]
+
         def inspect
           attributes = inspect_attributes.reject do |x|
             attribute = send(x)
             !attribute || (attribute.respond_to?(:empty?) && attribute.empty?)
           rescue NoMethodError
             true
-          end.map do |attribute|
-            "#{attribute.to_s.sub(/_\w+/, "s")}=#{send(attribute).inspect}"
-          end.join(" ")
+          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
 
@@ -21,11 +28,12 @@ module Nokogiri
           nice_name = self.class.name.split("::").last
           pp.group(2, "#(#{nice_name}:#{format("0x%x", object_id)} {", "})") do
             pp.breakable
-            attrs = inspect_attributes.map do |t|
+
+            attrs = inspect_attributes.filter_map do |t|
               [t, send(t)] if respond_to?(t)
-            end.compact.find_all do |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
@@ -33,19 +41,24 @@ module Nokogiri
               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
           end
         end

data/lib/nokogiri/xml/processing_instruction.rb

@@ -3,7 +3,8 @@
 module Nokogiri
   module XML
     class ProcessingInstruction < Node
-      def initialize(document, name, content) # rubocop:disable Style/RedundantInitialize
+      def initialize(document, name, content)
+        super(document, name)
       end
     end
   end

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

@@ -100,7 +100,7 @@ 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(":")

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

@@ -88,9 +88,8 @@ 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)
         end

data/lib/nokogiri/xml/searchable.rb

@@ -36,16 +36,19 @@ module Nokogiri
       #   node.search('.//address[@domestic=$value]', nil, {:value => 'Yes'})
       #
       # 💡 Custom XPath functions and CSS pseudo-selectors may also be defined. To define custom
-      # functions create a class and implement the function you want to define. The first argument
-      # to the method will be the current matching NodeSet. Any other arguments are ones that you
-      # pass in. Note that this class may appear anywhere in the argument list. For example:
+      # functions create a class and implement the function you want to define, which will be in the
+      # `nokogiri` namespace in XPath queries.
+      #
+      # The first argument to the method will be the current matching NodeSet. Any other arguments
+      # are ones that you pass in. Note that this class may appear anywhere in the argument
+      # list. For example:
       #
       #   handler = Class.new {
       #     def regex node_set, regex
       #       node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
       #     end
       #   }.new
-      #   node.search('.//title[regex(., "\w+")]', 'div.employee:regex("[0-9]+")', handler)
+      #   node.search('.//title[nokogiri:regex(., "\w+")]', 'div.employee:regex("[0-9]+")', handler)
       #
       # See Searchable#xpath and Searchable#css for further usage help.
       def search(*args)
@@ -160,16 +163,18 @@ module Nokogiri
       #   node.xpath('.//address[@domestic=$value]', nil, {:value => 'Yes'})
       #
       # 💡 Custom XPath functions may also be defined. To define custom functions create a class and
-      # implement the function you want to define. The first argument to the method will be the
-      # current matching NodeSet. Any other arguments are ones that you pass in. Note that this
-      # class may appear anywhere in the argument list. For example:
+      # implement the function you want to define, which will be in the `nokogiri` namespace.
+      #
+      # The first argument to the method will be the current matching NodeSet. Any other arguments
+      # are ones that you pass in. Note that this class may appear anywhere in the argument
+      # list. For example:
       #
       #   handler = Class.new {
       #     def regex(node_set, regex)
       #       node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
       #     end
       #   }.new
-      #   node.xpath('.//title[regex(., "\w+")]', handler)
+      #   node.xpath('.//title[nokogiri:regex(., "\w+")]', handler)
       #
       def xpath(*args)
         paths, handler, ns, binds = extract_params(args)
@@ -243,8 +248,11 @@ module Nokogiri
           doctype: document.xpath_doctype,
         )
         self.class::IMPLIED_XPATH_CONTEXTS.map do |implied_xpath_context|
-          CSS.xpath_for(rule.to_s, { prefix: implied_xpath_context, ns: ns,
-                                     visitor: visitor, })
+          CSS.xpath_for(rule.to_s, {
+            prefix: implied_xpath_context,
+            ns: ns,
+            visitor: visitor,
+          })
         end.join(" | ")
       end
 

data/lib/nokogiri/xslt.rb

@@ -20,8 +20,59 @@ module Nokogiri
   # Stylesheet object.
   module XSLT
     class << self
-      ###
-      # Parse the stylesheet in +string+, register any +modules+
+      # :call-seq:
+      #   parse(xsl) → Nokogiri::XSLT::Stylesheet
+      #   parse(xsl, modules) → Nokogiri::XSLT::Stylesheet
+      #
+      # Parse the stylesheet in +xsl+, registering optional +modules+ as custom class handlers.
+      #
+      # [Parameters]
+      # - +xsl+ (String) XSL content to be parsed into a stylesheet
+      # - +modules+ (Hash<String ⇒ Class>) A hash of URI-to-handler relations for linking a
+      #   namespace to a custom function handler.
+      #
+      # ⚠ The XSLT handler classes are registered *globally*.
+      #
+      # Also see Nokogiri::XSLT.register
+      #
+      # *Example*
+      #
+      #   xml = Nokogiri.XML(<<~XML)
+      #     <nodes>
+      #       <node>Foo</node>
+      #       <node>Bar</node>
+      #     </nodes>
+      #   XML
+      #
+      #   handler = Class.new do
+      #     def reverse(node)
+      #       node.text.reverse
+      #     end
+      #   end
+      #
+      #   xsl = <<~XSL
+      #     <xsl:stylesheet version="1.0"
+      #       xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+      #       xmlns:myfuncs="http://nokogiri.org/xslt/myfuncs"
+      #       extension-element-prefixes="myfuncs">
+      #       <xsl:template match="/">
+      #         <reversed>
+      #           <xsl:for-each select="nodes/node">
+      #             <reverse><xsl:copy-of select="myfuncs:reverse(.)"/></reverse>
+      #           </xsl:for-each>
+      #         </reversed>
+      #       </xsl:template>
+      #     </xsl:stylesheet>
+      #   XSL
+      #
+      #   xsl = Nokogiri.XSLT(xsl, "http://nokogiri.org/xslt/myfuncs" => handler)
+      #   xsl.transform(xml).to_xml
+      #   # => "<?xml version=\"1.0\"?>\n" +
+      #   #    "<reversed>\n" +
+      #   #    "  <reverse>ooF</reverse>\n" +
+      #   #    "  <reverse>raB</reverse>\n" +
+      #   #    "</reversed>\n"
+      #
       def parse(string, modules = {})
         modules.each do |url, klass|
           XSLT.register(url, klass)
@@ -47,9 +98,9 @@ module Nokogiri
       # [Returns] Array of string parameters, with quotes correctly escaped for use with XSLT::Stylesheet.transform
       #
       def quote_params(params)
-        params.flatten.each_slice(2).each_with_object([]) do |kv, quoted_params|
+        params.flatten.each_slice(2).with_object([]) do |kv, quoted_params|
           key, value = kv.map(&:to_s)
-          value = if /'/.match?(value)
+          value = if value.include?("'")
             "concat('#{value.gsub(/'/, %q{', "'", '})}')"
           else
             "'#{value}'"
@@ -58,6 +109,25 @@ module Nokogiri
           quoted_params << value
         end
       end
+
+      #  call-seq:
+      #    register(uri, custom_handler_class)
+      #
+      #  Register a class that implements custom XSLT transformation functions.
+      #
+      #  ⚠ The XSLT handler classes are registered *globally*.
+      #
+      #  [Parameters}
+      #  - +uri+ (String) The namespace for the custom handlers
+      #  - +custom_handler_class+ (Class) A class with ruby methods that can be called during
+      #    transformation
+      #
+      #  See Nokogiri::XSLT.parse for usage.
+      #
+      def register(uri, custom_handler_class)
+        # NOTE: this is implemented in the C extension, see ext/nokogiri/xslt_stylesheet.c
+        raise NotImplementedError, "Nokogiri::XSLT.register is not implemented on JRuby"
+      end if Nokogiri.jruby?
     end
   end
 end

data/lib/nokogiri.rb

@@ -1,8 +1,6 @@
 # coding: utf-8
 # frozen_string_literal: true
 
-require "rbconfig"
-
 if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
   require_relative "nokogiri/jruby/dependencies"
 end
@@ -47,11 +45,19 @@ module Nokogiri
         # Expect an HTML indicator to appear within the first 512
         # characters of a document. (<?xml ?> + <?xml-stylesheet ?>
         # shouldn't be that long)
-        Nokogiri.HTML4(string, url, encoding,
-          options || XML::ParseOptions::DEFAULT_HTML)
+        Nokogiri.HTML4(
+          string,
+          url,
+          encoding,
+          options || XML::ParseOptions::DEFAULT_HTML,
+        )
       else
-        Nokogiri.XML(string, url, encoding,
-          options || XML::ParseOptions::DEFAULT_XML)
+        Nokogiri.XML(
+          string,
+          url,
+          encoding,
+          options || XML::ParseOptions::DEFAULT_XML,
+        )
       end.tap do |doc|
         yield doc if block_given?
       end
@@ -88,17 +94,10 @@ module Nokogiri
 
     # :nodoc:
     def install_default_aliases
-      # Make sure to support some popular encoding aliases not known by
-      # all iconv implementations.
-      {
-        "Windows-31J" => "CP932",	# Windows-31J is the IANA registered name of CP932.
-      }.each do |alias_name, name|
-        EncodingHandler.alias(name, alias_name) if EncodingHandler[alias_name].nil?
-      end
+      warn("Nokogiri.install_default_aliases is deprecated and will be removed in a future version of Nokogiri. Please call Nokogiri::EncodingHandler.install_default_aliases instead.")
+      Nokogiri::EncodingHandler.install_default_aliases
     end
   end
-
-  Nokogiri.install_default_aliases
 end
 
 ###
@@ -124,5 +123,6 @@ require_relative "nokogiri/html"
 require_relative "nokogiri/decorators/slop"
 require_relative "nokogiri/css"
 require_relative "nokogiri/html4/builder"
+require_relative "nokogiri/encoding_handler"
 
 require_relative "nokogiri/html5" if Nokogiri.uses_gumbo?

data/lib/xsd/xmlparser/nokogiri.rb

@@ -71,7 +71,7 @@ module XSD
       # +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(":")
@@ -95,7 +95,9 @@ module XSD
       end
 
       ["xmldecl", "start_document", "end_document", "comment"].each do |name|
-        class_eval %{ def #{name}(*args); end }
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{name}(*args); end
+        RUBY
       end
 
       add_factory(self)