nokogiri 1.13.6 → 1.16.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/reader.rb

@@ -3,9 +3,11 @@
 module Nokogiri
   module XML
     ###
-    # Nokogiri::XML::Reader parses an XML document similar to the way a cursor
-    # would move.  The Reader is given an XML document, and yields nodes
-    # to an each block.
+    # Nokogiri::XML::Reader parses an XML document similar to the way a cursor would move. The
+    # Reader is given an XML document, and yields nodes to an each block.
+    #
+    # The Reader parser might be good for when you need the speed and low memory usage of the SAX
+    # parser, but do not want to write a Document handler.
     #
     # Here is an example of usage:
     #
@@ -22,13 +24,12 @@ module Nokogiri
     #
     #     end
     #
-    # Note that Nokogiri::XML::Reader#each can only be called once!!  Once
-    # the cursor moves through the entire document, you must parse the
-    # document again.  So make sure that you capture any information you
-    # need during the first iteration.
+    # ⚠ Nokogiri::XML::Reader#each can only be called once! Once the cursor moves through the entire
+    # document, you must parse the document again. It may be better to capture all information you
+    # need during a single iteration.
     #
-    # The Reader parser is good for when you need the speed of a SAX parser,
-    # but do not want to write a Document handler.
+    # ⚠ libxml2 does not support error recovery in the Reader parser. The `RECOVER` ParseOption is
+    # ignored. If a syntax error is encountered during parsing, an exception will be raised.
     class Reader
       include Enumerable
 
@@ -83,16 +84,14 @@ module Nokogiri
       end
       private :initialize
 
-      # Get the attributes of the current node as a Hash
+      # 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
+      # [Returns]
+      #   (Hash<String, String>) Attribute names and values, and namespace prefixes and hrefs.
       def attributes
-        attrs_hash = attribute_nodes.each_with_object({}) do |node, hash|
-          hash[node.name] = node.to_s
-        end
-        ns = namespaces
-        attrs_hash.merge!(ns) if ns
-        attrs_hash
+        attribute_hash.merge(namespaces)
       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)
@@ -194,7 +199,7 @@ module Nokogiri
       #
       # Search this node's immediate children using CSS selector +selector+
       def >(selector) # rubocop:disable Naming/BinaryOperatorParameterName
-        ns = (document.root&.namespaces || {})
+        ns = document.root&.namespaces || {}
         xpath(CSS.xpath_for(selector, prefix: "./", ns: ns).first)
       end
 
@@ -224,7 +229,7 @@ module Nokogiri
       def xpath_impl(node, path, handler, ns, binds)
         ctx = XPathContext.new(node)
         ctx.register_namespaces(ns)
-        path = path.gsub(/xmlns:/, " :") unless Nokogiri.uses_libxml?
+        path = path.gsub("xmlns:", " :") unless Nokogiri.uses_libxml?
 
         binds&.each do |key, value|
           ctx.register_variable(key.to_s, value)
@@ -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
 
@@ -261,7 +269,7 @@ module Nokogiri
         end
         ns, binds = hashes.reverse
 
-        ns ||= (document.root&.namespaces || {})
+        ns ||= document.root&.namespaces || {}
 
         [params, handler, ns, binds]
       end

data/lib/nokogiri/xml/syntax_error.rb

@@ -63,7 +63,7 @@ module Nokogiri
       end
 
       def location_to_s
-        return nil if nil_or_zero?(line) && nil_or_zero?(column)
+        return if nil_or_zero?(line) && nil_or_zero?(column)
 
         "#{line}:#{column}"
       end

data/lib/nokogiri/xml.rb

@@ -11,7 +11,7 @@ module Nokogiri
 
   module XML
     # Original C14N 1.0 spec canonicalization
-    XML_C14N_1_0 =       0
+    XML_C14N_1_0 = 0
     # Exclusive C14N 1.0 spec canonicalization
     XML_C14N_EXCLUSIVE_1_0 = 1
     # C14N 1.1 spec canonicalization

data/lib/nokogiri/xslt/stylesheet.rb

@@ -10,15 +10,37 @@ module Nokogiri
     #   doc   = Nokogiri::XML(File.read('some_file.xml'))
     #   xslt  = Nokogiri::XSLT(File.read('some_transformer.xslt'))
     #
-    #   puts xslt.transform(doc)
+    #   xslt.transform(doc) # => Nokogiri::XML::Document
     #
-    # See Nokogiri::XSLT::Stylesheet#transform for more transformation
-    # information.
+    # Many XSLT transformations include serialization behavior to emit a non-XML document. For these
+    # cases, please take care to invoke the #serialize method on the result of the transformation:
+    #
+    #   doc   = Nokogiri::XML(File.read('some_file.xml'))
+    #   xslt  = Nokogiri::XSLT(File.read('some_transformer.xslt'))
+    #   xslt.serialize(xslt.transform(doc)) # => String
+    #
+    # or use the #apply_to method, which is a shortcut for `serialize(transform(document))`:
+    #
+    #   doc   = Nokogiri::XML(File.read('some_file.xml'))
+    #   xslt  = Nokogiri::XSLT(File.read('some_transformer.xslt'))
+    #   xslt.apply_to(doc) # => String
+    #
+    # See Nokogiri::XSLT::Stylesheet#transform for more information and examples.
     class Stylesheet
-      ###
-      # Apply an XSLT stylesheet to an XML::Document.
-      # +params+ is an array of strings used as XSLT parameters.
-      # returns serialized document
+      # :call-seq:
+      #   apply_to(document, params = []) -> String
+      #
+      # Apply an XSLT stylesheet to an XML::Document and serialize it properly. This method is
+      # equivalent to calling #serialize on the result of #transform.
+      #
+      # [Parameters]
+      # - +document+ is an instance of XML::Document to transform
+      # - +params+ is an array of strings used as XSLT parameters, passed into #transform
+      #
+      # [Returns]
+      #   A string containing the serialized result of the transformation.
+      #
+      # See Nokogiri::XSLT::Stylesheet#transform for more information and examples.
       def apply_to(document, params = [])
         serialize(transform(document, params))
       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,10 +98,10 @@ 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)
-            "concat('#{value.gsub(/'/, %q{', "'", '})}')"
+          value = if value.include?("'")
+            "concat('#{value.gsub("'", %q{', "'", '})}')"
           else
             "'#{value}'"
           end
@@ -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