nokogiri 1.13.0-x64-mingw-ucrt

data/lib/nokogiri/xml/searchable.rb

@@ -0,0 +1,259 @@
+# 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.  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:
+      #
+      #   node.search('.//title[regex(., "\w+")]', 'div.employee:regex("[0-9]+")'
+      #     Class.new {
+      #       def regex node_set, regex
+      #         node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
+      #       end
+      #     }.new
+      #   )
+      #
+      # 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.  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 current matching NodeSet.  Any other
+      # arguments are ones that you pass in.  For example:
+      #
+      #   node.css('title:regex("\w+")', Class.new {
+      #     def regex node_set, regex
+      #       node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
+      #     end
+      #   }.new)
+      #
+      # Note that the CSS query string is case-sensitive with regards
+      # to your document type. That is, if you're looking for "H1" in
+      # an HTML document, you'll never find anything, since HTML tags
+      # will match only lowercase CSS queries. 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.  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:
+      #
+      #   node.xpath('.//title[regex(., "\w+")]', Class.new {
+      #     def regex node_set, regex
+      #       node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
+      #     end
+      #   }.new)
+      #
+      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 css_internal(node, rules, handler, ns)
+        xpath_internal(node, css_rules_to_xpath(rules, ns), handler, ns, nil)
+      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)
+        ctx = XPathContext.new(node)
+        ctx.register_namespaces(ns)
+        path = path.gsub(/xmlns:/, " :") unless Nokogiri.uses_libxml?
+
+        binds&.each do |key, value|
+          ctx.register_variable(key.to_s, value)
+        end
+
+        ctx.evaluate(path, handler)
+      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)
+        visitor = Nokogiri::CSS::XPathVisitor.new(
+          builtins: Nokogiri::CSS::XPathVisitor::BuiltinsConfig::OPTIMAL,
+          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, })
+        end.join(" | ")
+      end
+
+      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
+    end
+  end
+end

data/lib/nokogiri/xml/syntax_error.rb

@@ -0,0 +1,71 @@
+# 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
+      attr_reader :domain
+      attr_reader :code
+      attr_reader :level
+      attr_reader :file
+      attr_reader :line
+      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 nil 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,16 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module XML
+    class XPathContext
+      ###
+      # Register namespaces in +namespaces+
+      def register_namespaces(namespaces)
+        namespaces.each do |k, v|
+          k = k.to_s.gsub(/.*:/, "") # strip off 'xmlns:' or 'xml:'
+          register_ns(k, v)
+        end
+      end
+    end
+  end
+end

data/lib/nokogiri/xml.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  class << self
+    ###
+    # Parse XML.  Convenience method for Nokogiri::XML::Document.parse
+    def XML(thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_XML, &block)
+      Nokogiri::XML::Document.parse(thing, url, encoding, options, &block)
+    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
+      ###
+      # Parse an XML document using the Nokogiri::XML::Reader API.  See
+      # Nokogiri::XML::Reader for mor information
+      def Reader(string_or_io, url = nil, encoding = nil, options = ParseOptions::STRICT)
+        options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
+        yield options if block_given?
+
+        if string_or_io.respond_to?(:read)
+          return Reader.from_io(string_or_io, url, encoding, options.to_i)
+        end
+        Reader.from_memory(string_or_io, url, encoding, options.to_i)
+      end
+
+      ###
+      # Parse XML.  Convenience method for Nokogiri::XML::Document.parse
+      def parse(thing, url = nil, encoding = nil, options = ParseOptions::DEFAULT_XML, &block)
+        Document.parse(thing, url, encoding, options, &block)
+      end
+
+      ####
+      # Parse a fragment from +string+ in to a NodeSet.
+      def fragment(string, options = ParseOptions::DEFAULT_XML, &block)
+        XML::DocumentFragment.parse(string, options, &block)
+      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,27 @@
+# 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'))
+    #
+    #   puts xslt.transform(doc)
+    #
+    # See Nokogiri::XSLT::Stylesheet#transform for more transformation
+    # information.
+    class Stylesheet
+      ###
+      # Apply an XSLT stylesheet to an XML::Document.
+      # +params+ is an array of strings used as XSLT parameters.
+      # returns serialized document
+      def apply_to(document, params = [])
+        serialize(transform(document, params))
+      end
+    end
+  end
+end

data/lib/nokogiri/xslt.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  class << self
+    ###
+    # Create a Nokogiri::XSLT::Stylesheet with +stylesheet+.
+    #
+    # Example:
+    #
+    #   xslt = Nokogiri::XSLT(File.read(ARGV[0]))
+    #
+    def XSLT(stylesheet, modules = {})
+      XSLT.parse(stylesheet, modules)
+    end
+  end
+
+  ###
+  # See Nokogiri::XSLT::Stylesheet for creating and manipulating
+  # Stylesheet object.
+  module XSLT
+    class << self
+      ###
+      # Parse the stylesheet in +string+, register any +modules+
+      def parse(string, modules = {})
+        modules.each do |url, klass|
+          XSLT.register(url, klass)
+        end
+
+        doc = XML::Document.parse(string, nil, nil, XML::ParseOptions::DEFAULT_XSLT)
+        if Nokogiri.jruby?
+          Stylesheet.parse_stylesheet_doc(doc, string)
+        else
+          Stylesheet.parse_stylesheet_doc(doc)
+        end
+      end
+
+      ###
+      # Quote parameters in +params+ for stylesheet safety
+      def quote_params(params)
+        parray = (params.instance_of?(Hash) ? params.to_a.flatten : params).dup
+        parray.each_with_index do |v, i|
+          parray[i] = if i % 2 > 0
+            if /'/.match?(v)
+              "concat('#{v.gsub(/'/, %q{', "'", '})}')"
+            else
+              "'#{v}'"
+            end
+          else
+            v.to_s
+          end
+        end
+        parray.flatten
+      end
+    end
+  end
+end
+
+require_relative "xslt/stylesheet"

data/lib/nokogiri.rb

@@ -0,0 +1,128 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require "rbconfig"
+
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+  require_relative "nokogiri/jruby/dependencies"
+end
+
+require_relative "nokogiri/extension"
+
+# Nokogiri parses and searches XML/HTML very quickly, and also has
+# correctly implemented CSS3 selector support as well as XPath 1.0
+# support.
+#
+# Parsing a document returns either a Nokogiri::XML::Document, or a
+# Nokogiri::HTML4::Document depending on the kind of document you parse.
+#
+# Here is an example:
+#
+#     require 'nokogiri'
+#     require 'open-uri'
+#
+#     # Get a Nokogiri::HTML4::Document for the page we’re interested in...
+#
+#     doc = Nokogiri::HTML4(URI.open('http://www.google.com/search?q=tenderlove'))
+#
+#     # Do funky things with it using Nokogiri::XML::Node methods...
+#
+#     ####
+#     # Search for nodes by css
+#     doc.css('h3.r a.l').each do |link|
+#       puts link.content
+#     end
+#
+# See also:
+#
+# - Nokogiri::XML::Searchable#css for more information about CSS searching
+# - Nokogiri::XML::Searchable#xpath for more information about XPath searching
+module Nokogiri
+  class << self
+    ###
+    # Parse an HTML or XML document.  +string+ contains the document.
+    def parse(string, url = nil, encoding = nil, options = nil)
+      if string.respond_to?(:read) ||
+          /^\s*<(?:!DOCTYPE\s+)?html[\s>]/i.match?(string[0, 512])
+        # 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)
+      else
+        Nokogiri.XML(string, url, encoding,
+          options || XML::ParseOptions::DEFAULT_XML)
+      end.tap do |doc|
+        yield doc if block_given?
+      end
+    end
+
+    ###
+    # Create a new Nokogiri::XML::DocumentFragment
+    def make(input = nil, opts = {}, &blk)
+      if input
+        Nokogiri::HTML4.fragment(input).children.first
+      else
+        Nokogiri(&blk)
+      end
+    end
+
+    ###
+    # Parse a document and add the Slop decorator.  The Slop decorator
+    # implements method_missing such that methods may be used instead of CSS
+    # or XPath.  For example:
+    #
+    #   doc = Nokogiri::Slop(<<-eohtml)
+    #     <html>
+    #       <body>
+    #         <p>first</p>
+    #         <p>second</p>
+    #       </body>
+    #     </html>
+    #   eohtml
+    #   assert_equal('second', doc.html.body.p[1].text)
+    #
+    def Slop(*args, &block)
+      Nokogiri(*args, &block).slop!
+    end
+
+    # :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
+    end
+  end
+
+  Nokogiri.install_default_aliases
+end
+
+###
+# Parse a document contained in +args+.  Nokogiri will try to guess what type of document you are
+# attempting to parse.  For more information, see Nokogiri.parse
+#
+# To specify the type of document, use {Nokogiri.XML}, {Nokogiri.HTML4}, or {Nokogiri.HTML5}.
+def Nokogiri(*args, &block)
+  if block
+    Nokogiri::HTML4::Builder.new(&block).doc.root
+  else
+    Nokogiri.parse(*args)
+  end
+end
+
+require_relative "nokogiri/version"
+require_relative "nokogiri/class_resolver"
+require_relative "nokogiri/syntax_error"
+require_relative "nokogiri/xml"
+require_relative "nokogiri/xslt"
+require_relative "nokogiri/html4"
+require_relative "nokogiri/html"
+require_relative "nokogiri/decorators/slop"
+require_relative "nokogiri/css"
+require_relative "nokogiri/html4/builder"
+
+require_relative "nokogiri/html5" if Nokogiri.uses_gumbo?