nokogiri 1.10.3 → 1.13.9

data/lib/nokogiri/html.rb

@@ -1,37 +1,48 @@
-require 'nokogiri/html/entity_lookup'
-require 'nokogiri/html/document'
-require 'nokogiri/html/document_fragment'
-require 'nokogiri/html/sax/parser_context'
-require 'nokogiri/html/sax/parser'
-require 'nokogiri/html/sax/push_parser'
-require 'nokogiri/html/element_description'
-require 'nokogiri/html/element_description_defaults'
+# coding: utf-8
+# frozen_string_literal: true
+
+require_relative "html4"
 
 module Nokogiri
-  class << self
-    ###
-    # Parse HTML.  Convenience method for Nokogiri::HTML::Document.parse
-    def HTML thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block
-      Nokogiri::HTML::Document.parse(thing, url, encoding, options, &block)
-    end
-  end
+  # Alias for Nokogiri::HTML4
+  HTML = Nokogiri::HTML4
+
+  # :singleton-method: HTML
+  # :call-seq: HTML(input, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block) → Nokogiri::HTML4::Document
+  #
+  # Parse HTML. Convenience method for Nokogiri::HTML4::Document.parse
 
+  # :nodoc:
+  define_singleton_method(:HTML, Nokogiri.method(:HTML4))
+
+  # 💡 This module/namespace is an alias for Nokogiri::HTML4 as of v1.12.0. Before v1.12.0,
+  #   Nokogiri::HTML4 did not exist, and this was the module/namespace for all HTML-related
+  #   classes.
   module HTML
-    class << self
-      ###
-      # Parse HTML.  Convenience method for Nokogiri::HTML::Document.parse
-      def parse thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block
-        Document.parse(thing, url, encoding, options, &block)
+    # 💡 This class is an alias for Nokogiri::HTML4::Document as of v1.12.0.
+    class Document < Nokogiri::XML::Document
+    end
+
+    # 💡 This class is an alias for Nokogiri::HTML4::DocumentFragment as of v1.12.0.
+    class DocumentFragment < Nokogiri::XML::DocumentFragment
+    end
+
+    # 💡 This class is an alias for Nokogiri::HTML4::Builder as of v1.12.0.
+    class Builder < Nokogiri::XML::Builder
+    end
+
+    module SAX
+      # 💡 This class is an alias for Nokogiri::HTML4::SAX::Parser as of v1.12.0.
+      class Parser < Nokogiri::XML::SAX::Parser
       end
 
-      ####
-      # Parse a fragment from +string+ in to a NodeSet.
-      def fragment string, encoding = nil
-        HTML::DocumentFragment.parse string, encoding
+      # 💡 This class is an alias for Nokogiri::HTML4::SAX::ParserContext as of v1.12.0.
+      class ParserContext < Nokogiri::XML::SAX::ParserContext
       end
-    end
 
-    # Instance of Nokogiri::HTML::EntityLookup
-    NamedCharacters = EntityLookup.new
+      # 💡 This class is an alias for Nokogiri::HTML4::SAX::PushParser as of v1.12.0.
+      class PushParser
+      end
+    end
   end
 end

data/lib/nokogiri/{html → html4}/builder.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Nokogiri
-  module HTML
+  module HTML4
     ###
     # Nokogiri HTML builder is used for building HTML documents.  It is very
     # similar to the Nokogiri::XML::Builder.  In fact, you should go read the
@@ -11,7 +13,7 @@ module Nokogiri
     # Create an HTML document with a body that has an onload attribute, and a
     # span tag with a class of "bold" that has content of "Hello world".
     #
-    #   builder = Nokogiri::HTML::Builder.new do |doc|
+    #   builder = Nokogiri::HTML4::Builder.new do |doc|
     #     doc.html {
     #       doc.body(:onload => 'some_func();') {
     #         doc.span.bold {

data/lib/nokogiri/{html → html4}/document.rb

@@ -1,15 +1,19 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require "pathname"
+
 module Nokogiri
-  module HTML
+  module HTML4
     class Document < Nokogiri::XML::Document
       ###
       # Get the meta tag encoding for this document.  If there is no meta tag,
       # then nil is returned.
       def meta_encoding
-        case
-        when meta = at('//meta[@charset]')
+        if (meta = at_xpath("//meta[@charset]"))
           meta[:charset]
-        when meta = meta_content_type
-          meta['content'][/charset\s*=\s*([\w-]+)/i, 1]
+        elsif (meta = meta_content_type)
+          meta["content"][/charset\s*=\s*([\w-]+)/i, 1]
         end
       end
 
@@ -29,24 +33,22 @@ module Nokogiri
       #
       # Beware in CRuby, that libxml2 automatically inserts a meta tag
       # into a head element.
-      def meta_encoding= encoding
-        case
-        when meta = meta_content_type
-          meta['content'] = 'text/html; charset=%s' % encoding
+      def meta_encoding=(encoding)
+        if (meta = meta_content_type)
+          meta["content"] = format("text/html; charset=%s", encoding)
           encoding
-        when meta = at('//meta[@charset]')
-          meta['charset'] = encoding
+        elsif (meta = at_xpath("//meta[@charset]"))
+          meta["charset"] = encoding
         else
-          meta = XML::Node.new('meta', self)
-          if dtd = internal_subset and dtd.html5_dtd?
-            meta['charset'] = encoding
+          meta = XML::Node.new("meta", self)
+          if (dtd = internal_subset) && dtd.html5_dtd?
+            meta["charset"] = encoding
           else
-            meta['http-equiv'] = 'Content-Type'
-            meta['content'] = 'text/html; charset=%s' % encoding
+            meta["http-equiv"] = "Content-Type"
+            meta["content"] = format("text/html; charset=%s", encoding)
           end
 
-          case
-          when head = at('//head')
+          if (head = at_xpath("//head"))
             head.prepend_child(meta)
           else
             set_metadata_element(meta)
@@ -56,9 +58,9 @@ module Nokogiri
       end
 
       def meta_content_type
-        xpath('//meta[@http-equiv and boolean(@content)]').find { |node|
-          node['http-equiv'] =~ /\AContent-Type\z/i
-        }
+        xpath("//meta[@http-equiv and boolean(@content)]").find do |node|
+          node["http-equiv"] =~ /\AContent-Type\z/i
+        end
       end
       private :meta_content_type
 
@@ -66,7 +68,7 @@ module Nokogiri
       # Get the title string of this document.  Return nil if there is
       # no title tag.
       def title
-        title = at('//title') and title.inner_text
+        (title = at_xpath("//title")) && title.inner_text
       end
 
       ###
@@ -82,52 +84,50 @@ module Nokogiri
       # content element (typically <body>) if any.
       def title=(text)
         tnode = XML::Text.new(text, self)
-        if title = at('//title')
+        if (title = at_xpath("//title"))
           title.children = tnode
           return text
         end
 
-        title = XML::Node.new('title', self) << tnode
-        case
-        when head = at('//head')
+        title = XML::Node.new("title", self) << tnode
+        if (head = at_xpath("//head"))
           head << title
-        when meta = at('//meta[@charset]') || meta_content_type
+        elsif (meta = (at_xpath("//meta[@charset]") || meta_content_type))
           # better put after charset declaration
           meta.add_next_sibling(title)
         else
           set_metadata_element(title)
         end
-        text
       end
 
-      def set_metadata_element(element)
-        case
-        when head = at('//head')
+      def set_metadata_element(element) # rubocop:disable Naming/AccessorMethodName
+        if (head = at_xpath("//head"))
           head << element
-        when html = at('//html')
-          head = html.prepend_child(XML::Node.new('head', self))
+        elsif (html = at_xpath("//html"))
+          head = html.prepend_child(XML::Node.new("head", self))
           head.prepend_child(element)
-        when first = children.find { |node|
-            case node
-            when XML::Element, XML::Text
-              true
-            end
-          }
+        elsif (first = children.find do |node|
+                 case node
+                 when XML::Element, XML::Text
+                   true
+                 end
+               end)
           # We reach here only if the underlying document model
           # allows <html>/<head> elements to be omitted and does not
           # automatically supply them.
           first.add_previous_sibling(element)
         else
-          html = add_child(XML::Node.new('html', self))
-          head = html.add_child(XML::Node.new('head', self))
+          html = add_child(XML::Node.new("html", self))
+          head = html.add_child(XML::Node.new("head", self))
           head.prepend_child(element)
         end
       end
       private :set_metadata_element
 
       ####
-      # Serialize Node using +options+.  Save options can also be set using a
-      # block. See SaveOptions.
+      # Serialize Node using +options+. Save options can also be set using a block.
+      #
+      # See also Nokogiri::XML::Node::SaveOptions and Node@Serialization+and+Generating+Output.
       #
       # These two statements are equivalent:
       #
@@ -139,15 +139,25 @@ module Nokogiri
       #     config.format.as_xml
       #   end
       #
-      def serialize options = {}
+      def serialize(options = {})
         options[:save_with] ||= XML::Node::SaveOptions::DEFAULT_HTML
         super
       end
 
       ####
       # Create a Nokogiri::XML::DocumentFragment from +tags+
-      def fragment tags = nil
-        DocumentFragment.new(self, tags, self.root)
+      def fragment(tags = nil)
+        DocumentFragment.new(self, tags, root)
+      end
+
+      # :call-seq:
+      #   xpath_doctype() → Nokogiri::CSS::XPathVisitor::DoctypeConfig
+      #
+      # [Returns] The document type which determines CSS-to-XPath translation.
+      #
+      # See XPathVisitor for more information.
+      def xpath_doctype
+        Nokogiri::CSS::XPathVisitor::DoctypeConfig::HTML4
       end
 
       class << self
@@ -159,12 +169,12 @@ module Nokogiri
         # is a number that sets options in the parser, such as
         # Nokogiri::XML::ParseOptions::RECOVER.  See the constants in
         # Nokogiri::XML::ParseOptions.
-        def parse string_or_io, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML
-
+        def parse(string_or_io, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML)
           options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
-          # Give the options to the user
           yield options if block_given?
 
+          url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
+
           if string_or_io.respond_to?(:encoding)
             unless string_or_io.encoding.name == "ASCII-8BIT"
               encoding ||= string_or_io.encoding.name
@@ -172,7 +182,12 @@ module Nokogiri
           end
 
           if string_or_io.respond_to?(:read)
-            url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
+            if string_or_io.is_a?(Pathname)
+              # resolve the Pathname to the file and open it as an IO object, see #2110
+              string_or_io = string_or_io.expand_path.open
+              url ||= string_or_io.path
+            end
+
             unless encoding
               # Libxml2's parser has poor support for encoding
               # detection.  First, it does not recognize the HTML5
@@ -196,7 +211,7 @@ module Nokogiri
           end
 
           # read_memory pukes on empty docs
-          if string_or_io.nil? or string_or_io.empty?
+          if string_or_io.nil? || string_or_io.empty?
             return encoding ? new.tap { |i| i.encoding = encoding } : new
           end
 
@@ -206,37 +221,39 @@ module Nokogiri
         end
       end
 
-      class EncodingFound < StandardError # :nodoc:
+      class EncodingFound < StandardError # :nodoc: all
         attr_reader :found_encoding
 
         def initialize(encoding)
           @found_encoding = encoding
-          super("encoding found: %s" % encoding)
+          super(format("encoding found: %s", encoding))
         end
       end
 
-      class EncodingReader # :nodoc:
-        class SAXHandler < Nokogiri::XML::SAX::Document # :nodoc:
+      # :nodoc: all
+      class EncodingReader
+        class SAXHandler < Nokogiri::XML::SAX::Document
           attr_reader :encoding
-          
+
           def initialize
             @encoding = nil
             super()
           end
-    
+
           def start_element(name, attrs = [])
-            return unless name == 'meta'
+            return unless name == "meta"
+
             attr = Hash[attrs]
-            charset = attr['charset'] and
-              @encoding = charset
-            http_equiv = attr['http-equiv'] and
-              http_equiv.match(/\AContent-Type\z/i) and
-              content = attr['content'] and
-              m = content.match(/;\s*charset\s*=\s*([\w-]+)/) and
-              @encoding = m[1]
+            (charset = attr["charset"]) &&
+              (@encoding = charset)
+            (http_equiv = attr["http-equiv"]) &&
+              http_equiv.match(/\AContent-Type\z/i) &&
+              (content = attr["content"]) &&
+              (m = content.match(/;\s*charset\s*=\s*([\w-]+)/)) &&
+              (@encoding = m[1])
           end
         end
-        
+
         class JumpSAXHandler < SAXHandler
           def initialize(jumptag)
             @jumptag = jumptag
@@ -245,53 +262,34 @@ module Nokogiri
 
           def start_element(name, attrs = [])
             super
-            throw @jumptag, @encoding if @encoding
-            throw @jumptag, nil if name =~ /\A(?:div|h1|img|p|br)\z/
+            throw(@jumptag, @encoding) if @encoding
+            throw(@jumptag, nil) if /\A(?:div|h1|img|p|br)\z/.match?(name)
           end
         end
 
         def self.detect_encoding(chunk)
-          if Nokogiri.jruby? && EncodingReader.is_jruby_without_fix?
-            return EncodingReader.detect_encoding_for_jruby_without_fix(chunk)
-          end
-          m = chunk.match(/\A(<\?xml[ \t\r\n]+[^>]*>)/) and
-            return Nokogiri.XML(m[1]).encoding
+          (m = chunk.match(/\A(<\?xml[ \t\r\n][^>]*>)/)) &&
+            (return Nokogiri.XML(m[1]).encoding)
 
           if Nokogiri.jruby?
-            m = chunk.match(/(<meta\s)(.*)(charset\s*=\s*([\w-]+))(.*)/i) and
-              return m[4]
-            catch(:encoding_found) {
-              Nokogiri::HTML::SAX::Parser.new(JumpSAXHandler.new(:encoding_found)).parse(chunk)
+            (m = chunk.match(/(<meta\s)(.*)(charset\s*=\s*([\w-]+))(.*)/i)) &&
+              (return m[4])
+            catch(:encoding_found) do
+              Nokogiri::HTML4::SAX::Parser.new(JumpSAXHandler.new(:encoding_found)).parse(chunk)
               nil
-            }
+            end
           else
             handler = SAXHandler.new
-            parser = Nokogiri::HTML::SAX::PushParser.new(handler)
-            parser << chunk rescue Nokogiri::SyntaxError
+            parser = Nokogiri::HTML4::SAX::PushParser.new(handler)
+            begin
+              parser << chunk
+            rescue
+              Nokogiri::SyntaxError
+            end
             handler.encoding
           end
         end
 
-        def self.is_jruby_without_fix?
-          JRUBY_VERSION.split('.').join.to_i < 165
-        end
-
-        def self.detect_encoding_for_jruby_without_fix(chunk)
-          m = chunk.match(/\A(<\?xml[ \t\r\n]+[^>]*>)/) and
-            return Nokogiri.XML(m[1]).encoding
-
-          m = chunk.match(/(<meta\s)(.*)(charset\s*=\s*([\w-]+))(.*)/i) and
-            return m[4]
-
-          catch(:encoding_found) {
-            Nokogiri::HTML::SAX::Parser.new(JumpSAXHandler.new(:encoding_found.to_s)).parse(chunk)
-            nil
-          }
-        rescue Nokogiri::SyntaxError, RuntimeError
-          # Ignore parser errors that nokogiri may raise
-          nil
-        end
-
         def initialize(io)
           @io = io
           @firstchunk = nil
@@ -299,20 +297,20 @@ module Nokogiri
         end
 
         # This method is used by the C extension so that
-        # Nokogiri::HTML::Document#read_io() does not leak memory when
+        # Nokogiri::HTML4::Document#read_io() does not leak memory when
         # EncodingFound is raised.
         attr_reader :encoding_found
 
         def read(len)
           # no support for a call without len
 
-          if !@firstchunk
-            @firstchunk = @io.read(len) or return nil
+          unless @firstchunk
+            (@firstchunk = @io.read(len)) || (return nil)
 
             # This implementation expects that the first call from
             # htmlReadIO() is made with a length long enough (~1KB) to
             # achieve advanced encoding detection.
-            if encoding = EncodingReader.detect_encoding(@firstchunk)
+            if (encoding = EncodingReader.detect_encoding(@firstchunk))
               # The first chunk is stored for the next read in retry.
               raise @encoding_found = EncodingFound.new(encoding)
             end
@@ -321,7 +319,7 @@ module Nokogiri
 
           ret = @firstchunk.slice!(0, len)
           if (len -= ret.length) > 0
-            rest = @io.read(len) and ret << rest
+            (rest = @io.read(len)) && ret << (rest)
           end
           if ret.empty?
             nil

data/lib/nokogiri/html4/document_fragment.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Nokogiri
+  module HTML4
+    class DocumentFragment < Nokogiri::XML::DocumentFragment
+      ####
+      # Create a Nokogiri::XML::DocumentFragment from +tags+, using +encoding+
+      def self.parse(tags, encoding = nil, options = XML::ParseOptions::DEFAULT_HTML, &block)
+        doc = HTML4::Document.new
+
+        encoding ||= if tags.respond_to?(:encoding)
+          encoding = tags.encoding
+          if encoding == ::Encoding::ASCII_8BIT
+            "UTF-8"
+          else
+            encoding.name
+          end
+        else
+          "UTF-8"
+        end
+
+        doc.encoding = encoding
+
+        new(doc, tags, nil, options, &block)
+      end
+
+      def initialize(document, tags = nil, ctx = nil, options = XML::ParseOptions::DEFAULT_HTML)
+        return self unless tags
+
+        options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
+        yield options if block_given?
+
+        if ctx
+          preexisting_errors = document.errors.dup
+          node_set = ctx.parse("<div>#{tags}</div>", options)
+          node_set.first.children.each { |child| child.parent = self } unless node_set.empty?
+          self.errors = document.errors - preexisting_errors
+        else
+          # This is a horrible hack, but I don't care
+          path = if /^\s*?<body/i.match?(tags)
+            "/html/body"
+          else
+            "/html/body/node()"
+          end
+
+          temp_doc = HTML4::Document.parse("<html><body>#{tags}", nil, document.encoding, options)
+          temp_doc.xpath(path).each { |child| child.parent = self }
+          self.errors = temp_doc.errors
+        end
+        children
+      end
+    end
+  end
+end

data/lib/nokogiri/{html → html4}/element_description.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Nokogiri
-  module HTML
+  module HTML4
     class ElementDescription
       ###
       # Is this element a block element?