nokogiri 1.18.0.rc1-x86_64-linux-gnu

data/lib/nokogiri/xml/searchable.rb

@@ -0,0 +1,297 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    #
+    #  The Searchable module declares the interface used for searching your DOM.
+    #
+    #  It implements the public methods #search, #css, and #xpath,
+    #  as well as allowing specific implementations to specialize some
+    #  of the important behaviors.
+    #
+    module Searchable
+      # Regular expression used by Searchable#search to determine if a query
+      # string is CSS or XPath
+      LOOKS_LIKE_XPATH = %r{^(\./|/|\.\.|\.$)}
+
+      # :section: Searching via XPath or CSS Queries
+
+      ###
+      # call-seq:
+      #   search(*paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class])
+      #
+      # Search this object for +paths+. +paths+ must be one or more XPath or CSS queries:
+      #
+      #   node.search("div.employee", ".//title")
+      #
+      # A hash of namespace bindings may be appended:
+      #
+      #   node.search('.//bike:tire', {'bike' => 'http://schwinn.com/'})
+      #   node.search('bike|tire', {'bike' => 'http://schwinn.com/'})
+      #
+      # For XPath queries, a hash of variable bindings may also be appended to the namespace
+      # bindings. For example:
+      #
+      #   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, 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[nokogiri:regex(., "\w+")]', 'div.employee:regex("[0-9]+")', handler)
+      #
+      # See Searchable#xpath and Searchable#css for further usage help.
+      def search(*args)
+        paths, handler, ns, binds = extract_params(args)
+
+        xpaths = paths.map(&:to_s).map do |path|
+          LOOKS_LIKE_XPATH.match?(path) ? path : xpath_query_from_css_rule(path, ns)
+        end.flatten.uniq
+
+        xpath(*(xpaths + [ns, handler, binds].compact))
+      end
+
+      alias_method :/, :search
+
+      ###
+      # call-seq:
+      #   at(*paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class])
+      #
+      # Search this object for +paths+, and return only the first
+      # result. +paths+ must be one or more XPath or CSS queries.
+      #
+      # See Searchable#search for more information.
+      def at(*args)
+        search(*args).first
+      end
+
+      alias_method :%, :at
+
+      ###
+      # call-seq:
+      #   css(*rules, [namespace-bindings, custom-pseudo-class])
+      #
+      # Search this object for CSS +rules+. +rules+ must be one or more CSS
+      # selectors. For example:
+      #
+      #   node.css('title')
+      #   node.css('body h1.bold')
+      #   node.css('div + p.green', 'div#one')
+      #
+      # A hash of namespace bindings may be appended. For example:
+      #
+      #   node.css('bike|tire', {'bike' => 'http://schwinn.com/'})
+      #
+      # 💡 Custom CSS pseudo classes may also be defined which are mapped to a custom XPath
+      # function.  To define custom pseudo classes, create a class and implement the custom pseudo
+      # class you want defined. The first argument to the method will be the matching context
+      # NodeSet. Any other arguments are ones that you pass in. For example:
+      #
+      #   handler = Class.new {
+      #     def regex(node_set, regex)
+      #       node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
+      #     end
+      #   }.new
+      #   node.css('title:regex("\w+")', handler)
+      #
+      # 💡 Some XPath syntax is supported in CSS queries. For example, to query for an attribute:
+      #
+      #   node.css('img > @href') # returns all +href+ attributes on an +img+ element
+      #   node.css('img / @href') # same
+      #
+      #   # ⚠ this returns +class+ attributes from all +div+ elements AND THEIR CHILDREN!
+      #   node.css('div @class')
+      #
+      #   node.css
+      #
+      # 💡 Array-like syntax is supported in CSS queries as an alternative to using +:nth-child()+.
+      #
+      # ⚠ NOTE that indices are 1-based like +:nth-child+ and not 0-based like Ruby Arrays. For
+      # example:
+      #
+      #   # equivalent to 'li:nth-child(2)'
+      #   node.css('li[2]') # retrieve the second li element in a list
+      #
+      # ⚠ NOTE that the CSS query string is case-sensitive with regards to your document type. HTML
+      # tags will match only lowercase CSS queries, so if you search for "H1" in an HTML document,
+      # you'll never find anything. However, "H1" might be found in an XML document, where tags
+      # names are case-sensitive (e.g., "H1" is distinct from "h1").
+      def css(*args)
+        rules, handler, ns, _ = extract_params(args)
+
+        css_internal(self, rules, handler, ns)
+      end
+
+      ##
+      # call-seq:
+      #   at_css(*rules, [namespace-bindings, custom-pseudo-class])
+      #
+      # Search this object for CSS +rules+, and return only the first
+      # match. +rules+ must be one or more CSS selectors.
+      #
+      # See Searchable#css for more information.
+      def at_css(*args)
+        css(*args).first
+      end
+
+      ###
+      # call-seq:
+      #   xpath(*paths, [namespace-bindings, variable-bindings, custom-handler-class])
+      #
+      # Search this node for XPath +paths+. +paths+ must be one or more XPath
+      # queries.
+      #
+      #   node.xpath('.//title')
+      #
+      # A hash of namespace bindings may be appended. For example:
+      #
+      #   node.xpath('.//foo:name', {'foo' => 'http://example.org/'})
+      #   node.xpath('.//xmlns:name', node.root.namespaces)
+      #
+      # A hash of variable bindings may also be appended to the namespace bindings. For example:
+      #
+      #   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, 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[nokogiri:regex(., "\w+")]', handler)
+      #
+      def xpath(*args)
+        paths, handler, ns, binds = extract_params(args)
+
+        xpath_internal(self, paths, handler, ns, binds)
+      end
+
+      ##
+      # call-seq:
+      #   at_xpath(*paths, [namespace-bindings, variable-bindings, custom-handler-class])
+      #
+      # Search this node for XPath +paths+, and return only the first
+      # match. +paths+ must be one or more XPath queries.
+      #
+      # See Searchable#xpath for more information.
+      def at_xpath(*args)
+        xpath(*args).first
+      end
+
+      # :call-seq:
+      #   >(selector) → NodeSet
+      #
+      # Search this node's immediate children using CSS selector +selector+
+      def >(selector) # rubocop:disable Naming/BinaryOperatorParameterName
+        ns = document.root&.namespaces || {}
+        xpath(CSS.xpath_for(selector, prefix: "./", ns: ns).first)
+      end
+
+      # :section:
+
+      private
+
+      def extract_params(params) # :nodoc:
+        handler = params.find do |param|
+          ![Hash, String, Symbol].include?(param.class)
+        end
+        params -= [handler] if handler
+
+        hashes = []
+        while Hash === params.last || params.last.nil?
+          hashes << params.pop
+          break if params.empty?
+        end
+        ns, binds = hashes.reverse
+
+        ns ||= document.root&.namespaces || {}
+
+        [params, handler, ns, binds]
+      end
+
+      def css_internal(node, rules, handler, ns)
+        xpath_internal(node, css_rules_to_xpath(rules, ns), handler, ns, nil)
+      end
+
+      def css_rules_to_xpath(rules, ns)
+        rules.map { |rule| xpath_query_from_css_rule(rule, ns) }
+      end
+
+      def xpath_query_from_css_rule(rule, ns)
+        self.class::IMPLIED_XPATH_CONTEXTS.map do |implied_xpath_context|
+          visitor = Nokogiri::CSS::XPathVisitor.new(
+            builtins: Nokogiri::CSS::XPathVisitor::BuiltinsConfig::OPTIMAL,
+            doctype: document.xpath_doctype,
+            prefix: implied_xpath_context,
+            namespaces: ns,
+          )
+          CSS.xpath_for(rule.to_s, visitor: visitor)
+        end.join(" | ")
+      end
+
+      def xpath_internal(node, paths, handler, ns, binds)
+        document = node.document
+        return NodeSet.new(document) unless document
+
+        if paths.length == 1
+          return xpath_impl(node, paths.first, handler, ns, binds)
+        end
+
+        NodeSet.new(document) do |combined|
+          paths.each do |path|
+            xpath_impl(node, path, handler, ns, binds).each { |set| combined << set }
+          end
+        end
+      end
+
+      def xpath_impl(node, path, handler, ns, binds)
+        get_xpath_context(node) do |context|
+          context.register_namespaces(ns)
+          context.register_variables(binds)
+
+          path = path.gsub("xmlns:", " :") unless Nokogiri.uses_libxml?
+
+          context.evaluate(path, handler)
+        end
+      end
+
+      if Nokogiri.uses_libxml? && ENV["NOKOGIRI_DEOPTIMIZE_XPATH"].nil? # env var is an escape hatch
+        # optimized path
+        def get_xpath_context(node)
+          context = Thread.current.thread_variable_get(:nokogiri_xpath_context)
+          if context
+            context.node = node
+          else
+            context = Thread.current.thread_variable_set(:nokogiri_xpath_context, XPathContext.new(node))
+          end
+
+          begin
+            yield context
+          ensure
+            context.reset
+          end
+        end
+      else
+        def get_xpath_context(node)
+          yield XPathContext.new(node)
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/syntax_error.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    ###
+    # This class provides information about XML SyntaxErrors.  These
+    # exceptions are typically stored on Nokogiri::XML::Document#errors.
+    class SyntaxError < ::Nokogiri::SyntaxError
+      class << self
+        def aggregate(errors)
+          return nil if errors.empty?
+          return errors.first if errors.length == 1
+
+          messages = ["Multiple errors encountered:"]
+          errors.each do |error|
+            messages << error.to_s
+          end
+          new(messages.join("\n"))
+        end
+      end
+
+      attr_reader :domain
+      attr_reader :code
+      attr_reader :level
+      attr_reader :file
+      attr_reader :line
+
+      # The XPath path of the node that caused the error when validating a `Nokogiri::XML::Document`.
+      #
+      # This attribute will only be non-nil when the error is emitted by `Schema#validate` on
+      # Document objects. It will return `nil` for DOM parsing errors and for errors emitted during
+      # Schema validation of files.
+      #
+      # ⚠ `#path` is not supported on JRuby, where it will always return `nil`.
+      attr_reader :path
+      attr_reader :str1
+      attr_reader :str2
+      attr_reader :str3
+      attr_reader :int1
+      attr_reader :column
+
+      ###
+      # return true if this is a non error
+      def none?
+        level == 0
+      end
+
+      ###
+      # return true if this is a warning
+      def warning?
+        level == 1
+      end
+
+      ###
+      # return true if this is an error
+      def error?
+        level == 2
+      end
+
+      ###
+      # return true if this error is fatal
+      def fatal?
+        level == 3
+      end
+
+      def to_s
+        message = super.chomp
+        [location_to_s, level_to_s, message]
+          .compact.join(": ")
+          .force_encoding(message.encoding)
+      end
+
+      private
+
+      def level_to_s
+        case level
+        when 3 then "FATAL"
+        when 2 then "ERROR"
+        when 1 then "WARNING"
+        end
+      end
+
+      def nil_or_zero?(attribute)
+        attribute.nil? || attribute.zero?
+      end
+
+      def location_to_s
+        return if nil_or_zero?(line) && nil_or_zero?(column)
+
+        "#{line}:#{column}"
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/text.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    class Text < Nokogiri::XML::CharacterData
+      def content=(string)
+        self.native_content = string.to_s
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/xpath/syntax_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    module XPath
+      class SyntaxError < XML::SyntaxError
+        def to_s
+          [super.chomp, str1].compact.join(": ")
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/xml/xpath.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    module XPath
+      # The XPath search prefix to search globally, +//+
+      GLOBAL_SEARCH_PREFIX = "//"
+
+      # The XPath search prefix to search direct descendants of the root element, +/+
+      ROOT_SEARCH_PREFIX = "/"
+
+      # The XPath search prefix to search direct descendants of the current element, +./+
+      CURRENT_SEARCH_PREFIX = "./"
+
+      # The XPath search prefix to search anywhere in the current element's subtree, +.//+
+      SUBTREE_SEARCH_PREFIX = ".//"
+    end
+  end
+end
+
+require_relative "xpath/syntax_error"

data/lib/nokogiri/xml/xpath_context.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    class XPathContext
+      ###
+      # Register namespaces in +namespaces+
+      def register_namespaces(namespaces)
+        namespaces.each do |key, value|
+          key = key.to_s.gsub(/.*:/, "") # strip off 'xmlns:' or 'xml:'
+
+          register_ns(key, value)
+        end
+      end
+
+      def register_variables(binds)
+        return if binds.nil?
+
+        binds.each do |key, value|
+          key = key.to_s
+
+          register_variable(key, value)
+        end
+      end
+
+      if Nokogiri.uses_libxml?
+        def reset
+          return unless
+
+          @registered_namespaces.each do |key, _|
+            register_ns(key, nil)
+          end
+          unless @registered_namespaces.empty?
+            warn "Nokogiri::XML::XPathContext#reset: unexpected registered namespaces: #{@registered_namespaces.keys}"
+            @registered_namespaces.clear
+          end
+
+          @registered_variables.each do |key, _|
+            register_variable(key, nil)
+          end
+          unless @registered_variables.empty?
+            warn "Nokogiri::XML::XPathContext#reset: unexpected registered variables: #{@registered_variables.keys}"
+            @registered_variables.clear
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/xml.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  class << self
+    # Convenience method for Nokogiri::XML::Document.parse
+    def XML(...)
+      Nokogiri::XML::Document.parse(...)
+    end
+  end
+
+  module XML
+    # Original C14N 1.0 spec canonicalization
+    XML_C14N_1_0 = 0
+    # Exclusive C14N 1.0 spec canonicalization
+    XML_C14N_EXCLUSIVE_1_0 = 1
+    # C14N 1.1 spec canonicalization
+    XML_C14N_1_1 = 2
+
+    class << self
+      # Convenience method for Nokogiri::XML::Reader.new
+      def Reader(...)
+        Reader.new(...)
+      end
+
+      # Convenience method for Nokogiri::XML::Document.parse
+      def parse(...)
+        Document.parse(...)
+      end
+
+      # Convenience method for Nokogiri::XML::DocumentFragment.parse
+      def fragment(...)
+        XML::DocumentFragment.parse(...)
+      end
+    end
+  end
+end
+
+require_relative "xml/pp"
+require_relative "xml/parse_options"
+require_relative "xml/sax"
+require_relative "xml/searchable"
+require_relative "xml/node"
+require_relative "xml/attribute_decl"
+require_relative "xml/element_decl"
+require_relative "xml/element_content"
+require_relative "xml/character_data"
+require_relative "xml/namespace"
+require_relative "xml/attr"
+require_relative "xml/dtd"
+require_relative "xml/cdata"
+require_relative "xml/text"
+require_relative "xml/document"
+require_relative "xml/document_fragment"
+require_relative "xml/processing_instruction"
+require_relative "xml/node_set"
+require_relative "xml/syntax_error"
+require_relative "xml/xpath"
+require_relative "xml/xpath_context"
+require_relative "xml/builder"
+require_relative "xml/reader"
+require_relative "xml/notation"
+require_relative "xml/entity_decl"
+require_relative "xml/entity_reference"
+require_relative "xml/schema"
+require_relative "xml/relax_ng"

data/lib/nokogiri/xslt/stylesheet.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XSLT
+    ###
+    # A Stylesheet represents an XSLT Stylesheet object.  Stylesheet creation
+    # is done through Nokogiri.XSLT.  Here is an example of transforming
+    # an XML::Document with a Stylesheet:
+    #
+    #   doc   = Nokogiri::XML(File.read('some_file.xml'))
+    #   xslt  = Nokogiri::XSLT(File.read('some_transformer.xslt'))
+    #
+    #   xslt.transform(doc) # => Nokogiri::XML::Document
+    #
+    # 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
+      # :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
+    end
+  end
+end