nokogiri 1.12.5-arm64-darwin → 1.13.0-arm64-darwin

data/ext/nokogiri/xml_reader.c

@@ -148,9 +148,9 @@ namespaces(VALUE self)
 }
 
 /*
- * @overload attribute_nodes()
- *   Get the attributes of the current node as an Array of Attr
- *   @return [Array<Nokogiri::XML::Attr>]
+  :call-seq: attribute_nodes() → Array<Nokogiri::XML::Attr>
+
+  Get the attributes of the current node as an Array of Attr
  */
 static VALUE
 rb_xml_reader_attribute_nodes(VALUE rb_reader)
@@ -414,16 +414,23 @@ name(VALUE self)
  * Get the xml:base of the node
  */
 static VALUE
-base_uri(VALUE self)
+rb_xml_reader_base_uri(VALUE rb_reader)
 {
-  xmlTextReaderPtr reader;
-  const char *base_uri;
+  VALUE rb_base_uri;
+  xmlTextReaderPtr c_reader;
+  xmlChar *c_base_uri;
 
-  Data_Get_Struct(self, xmlTextReader, reader);
-  base_uri = (const char *)xmlTextReaderBaseUri(reader);
-  if (base_uri == NULL) { return Qnil; }
+  Data_Get_Struct(rb_reader, xmlTextReader, c_reader);
+
+  c_base_uri = xmlTextReaderBaseUri(c_reader);
+  if (c_base_uri == NULL) {
+    return Qnil;
+  }
+
+  rb_base_uri = NOKOGIRI_STR_NEW2(c_base_uri);
+  xmlFree(c_base_uri);
 
-  return NOKOGIRI_STR_NEW2(base_uri);
+  return rb_base_uri;
 }
 
 /*
@@ -652,6 +659,24 @@ empty_element_p(VALUE self)
   return Qfalse;
 }
 
+static VALUE
+rb_xml_reader_encoding(VALUE rb_reader)
+{
+  xmlTextReaderPtr c_reader;
+  const char *parser_encoding;
+  VALUE constructor_encoding;
+
+  constructor_encoding = rb_iv_get(rb_reader, "@encoding");
+  if (RTEST(constructor_encoding)) {
+    return constructor_encoding;
+  }
+
+  Data_Get_Struct(rb_reader, xmlTextReader, c_reader);
+  parser_encoding = (const char *)xmlTextReaderConstEncoding(c_reader);
+  if (parser_encoding == NULL) { return Qnil; }
+  return NOKOGIRI_STR_NEW2(parser_encoding);
+}
+
 void
 noko_init_xml_reader()
 {
@@ -672,10 +697,11 @@ noko_init_xml_reader()
   rb_define_method(cNokogiriXmlReader, "attribute_count", attribute_count, 0);
   rb_define_method(cNokogiriXmlReader, "attribute_nodes", rb_xml_reader_attribute_nodes, 0);
   rb_define_method(cNokogiriXmlReader, "attributes?", attributes_eh, 0);
-  rb_define_method(cNokogiriXmlReader, "base_uri", base_uri, 0);
+  rb_define_method(cNokogiriXmlReader, "base_uri", rb_xml_reader_base_uri, 0);
   rb_define_method(cNokogiriXmlReader, "default?", default_eh, 0);
   rb_define_method(cNokogiriXmlReader, "depth", depth, 0);
   rb_define_method(cNokogiriXmlReader, "empty_element?", empty_element_p, 0);
+  rb_define_method(cNokogiriXmlReader, "encoding", rb_xml_reader_encoding, 0);
   rb_define_method(cNokogiriXmlReader, "inner_xml", inner_xml, 0);
   rb_define_method(cNokogiriXmlReader, "lang", lang, 0);
   rb_define_method(cNokogiriXmlReader, "local_name", local_name, 0);

data/ext/nokogiri/xml_xpath_context.c

@@ -86,6 +86,26 @@ xpath_builtin_css_class(xmlXPathParserContextPtr ctxt, int nargs)
   xmlXPathFreeObject(needle);
 }
 
+
+/* xmlXPathFunction to select nodes whose local name matches, for HTML5 CSS queries that should ignore namespaces */
+static void
+xpath_builtin_local_name_is(xmlXPathParserContextPtr ctxt, int nargs)
+{
+  xmlXPathObjectPtr element_name;
+
+  assert(ctxt->context->node);
+
+  CHECK_ARITY(1);
+  CAST_TO_STRING;
+  CHECK_TYPE(XPATH_STRING);
+  element_name = valuePop(ctxt);
+
+  valuePush(ctxt, xmlXPathNewBoolean(xmlStrEqual(ctxt->context->node->name, element_name->stringval)));
+
+  xmlXPathFreeObject(element_name);
+}
+
+
 /*
  * call-seq:
  *  register_ns(prefix, uri)
@@ -128,11 +148,44 @@ register_variable(VALUE self, VALUE name, VALUE value)
   return self;
 }
 
+
+/*
+ *  convert an XPath object into a Ruby object of the appropriate type.
+ *  returns Qundef if no conversion was possible.
+ */
+static VALUE
+xpath2ruby(xmlXPathObjectPtr xobj, xmlXPathContextPtr xctx)
+{
+  VALUE retval;
+
+  assert(xctx->doc);
+  assert(DOC_RUBY_OBJECT_TEST(xctx->doc));
+
+  switch (xobj->type) {
+    case XPATH_STRING:
+      retval = NOKOGIRI_STR_NEW2(xobj->stringval);
+      xmlFree(xobj->stringval);
+      return retval;
+
+    case XPATH_NODESET:
+      return noko_xml_node_set_wrap(xobj->nodesetval,
+                                    DOC_RUBY_OBJECT(xctx->doc));
+
+    case XPATH_NUMBER:
+      return rb_float_new(xobj->floatval);
+
+    case XPATH_BOOLEAN:
+      return (xobj->boolval == 1) ? Qtrue : Qfalse;
+
+    default:
+      return Qundef;
+  }
+}
+
 void
 Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, int nargs, VALUE handler,
     const char *function_name)
 {
-  int i;
   VALUE result, doc;
   VALUE *argv;
   VALUE node_set = Qnil;
@@ -143,40 +196,25 @@ Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, i
   assert(DOC_RUBY_OBJECT_TEST(ctx->context->doc));
 
   argv = (VALUE *)calloc((size_t)nargs, sizeof(VALUE));
-  for (i = 0 ; i < nargs ; ++i) {
-    rb_gc_register_address(&argv[i]);
+  for (int j = 0 ; j < nargs ; ++j) {
+    rb_gc_register_address(&argv[j]);
   }
 
   doc = DOC_RUBY_OBJECT(ctx->context->doc);
 
-  if (nargs > 0) {
-    i = nargs - 1;
-    do {
-      obj = valuePop(ctx);
-      switch (obj->type) {
-        case XPATH_STRING:
-          argv[i] = NOKOGIRI_STR_NEW2(obj->stringval);
-          break;
-        case XPATH_BOOLEAN:
-          argv[i] = obj->boolval == 1 ? Qtrue : Qfalse;
-          break;
-        case XPATH_NUMBER:
-          argv[i] = rb_float_new(obj->floatval);
-          break;
-        case XPATH_NODESET:
-          argv[i] = noko_xml_node_set_wrap(obj->nodesetval, doc);
-          break;
-        default:
-          argv[i] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(obj));
-      }
-      xmlXPathFreeNodeSetList(obj);
-    } while (i-- > 0);
+  for (int j = nargs - 1 ; j >= 0 ; --j) {
+    obj = valuePop(ctx);
+    argv[j] = xpath2ruby(obj, ctx->context);
+    if (argv[j] == Qundef) {
+      argv[j] = NOKOGIRI_STR_NEW2(xmlXPathCastToString(obj));
+    }
+    xmlXPathFreeNodeSetList(obj);
   }
 
   result = rb_funcall2(handler, rb_intern((const char *)function_name), nargs, argv);
 
-  for (i = 0 ; i < nargs ; ++i) {
-    rb_gc_unregister_address(&argv[i]);
+  for (int j = 0 ; j < nargs ; ++j) {
+    rb_gc_unregister_address(&argv[j]);
   }
   free(argv);
 
@@ -275,7 +313,7 @@ static VALUE
 evaluate(int argc, VALUE *argv, VALUE self)
 {
   VALUE search_path, xpath_handler;
-  VALUE thing = Qnil;
+  VALUE retval = Qnil;
   xmlXPathContextPtr ctx;
   xmlXPathObjectPtr xpath;
   xmlChar *query;
@@ -310,31 +348,14 @@ evaluate(int argc, VALUE *argv, VALUE self)
     rb_exc_raise(Nokogiri_wrap_xml_syntax_error(error));
   }
 
-  assert(ctx->doc);
-  assert(DOC_RUBY_OBJECT_TEST(ctx->doc));
-
-  switch (xpath->type) {
-    case XPATH_STRING:
-      thing = NOKOGIRI_STR_NEW2(xpath->stringval);
-      xmlFree(xpath->stringval);
-      break;
-    case XPATH_NODESET:
-      thing = noko_xml_node_set_wrap(xpath->nodesetval,
-                                     DOC_RUBY_OBJECT(ctx->doc));
-      break;
-    case XPATH_NUMBER:
-      thing = rb_float_new(xpath->floatval);
-      break;
-    case XPATH_BOOLEAN:
-      thing = xpath->boolval == 1 ? Qtrue : Qfalse;
-      break;
-    default:
-      thing = noko_xml_node_set_wrap(NULL, DOC_RUBY_OBJECT(ctx->doc));
+  retval = xpath2ruby(xpath, ctx);
+  if (retval == Qundef) {
+    retval = noko_xml_node_set_wrap(NULL, DOC_RUBY_OBJECT(ctx->doc));
   }
 
   xmlXPathFreeNodeSetList(xpath);
 
-  return thing;
+  return retval;
 }
 
 /*
@@ -360,6 +381,8 @@ new (VALUE klass, VALUE nodeobj)
   xmlXPathRegisterNs(ctx, NOKOGIRI_BUILTIN_PREFIX, NOKOGIRI_BUILTIN_URI);
   xmlXPathRegisterFuncNS(ctx, (const xmlChar *)"css-class", NOKOGIRI_BUILTIN_URI,
                          xpath_builtin_css_class);
+  xmlXPathRegisterFuncNS(ctx, (const xmlChar *)"local-name-is", NOKOGIRI_BUILTIN_URI,
+                         xpath_builtin_local_name_is);
 
   self = Data_Wrap_Struct(klass, 0, deallocate, ctx);
   return self;

data/lib/nokogiri/class_resolver.rb

@@ -0,0 +1,67 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require "set"
+
+module Nokogiri
+  #
+  # Some classes in Nokogiri are namespaced as a group, for example
+  # Document, DocumentFragment, and Builder.
+  #
+  # It's sometimes necessary to look up the related class, e.g.:
+  #
+  #   XML::Builder → XML::Document
+  #   HTML4::Builder → HTML4::Document
+  #   HTML5::Document → HTML5::DocumentFragment
+  #
+  # This module is included into those key classes who need to do this.
+  #
+  module ClassResolver
+    # #related_class restricts matching namespaces to those matching this set.
+    VALID_NAMESPACES = Set.new(["HTML", "HTML4", "HTML5", "XML"])
+
+    # :call-seq:
+    #   related_class(class_name) → Class
+    #
+    # Find a class constant within the
+    #
+    # Some examples:
+    #
+    #   Nokogiri::XML::Document.new.related_class("DocumentFragment")
+    #   # => Nokogiri::XML::DocumentFragment
+    #   Nokogiri::HTML4::Document.new.related_class("DocumentFragment")
+    #   # => Nokogiri::HTML4::DocumentFragment
+    #
+    # Note this will also work for subclasses that follow the same convention, e.g.:
+    #
+    #   Loofah::HTML::Document.new.related_class("DocumentFragment")
+    #   # => Loofah::HTML::DocumentFragment
+    #
+    # And even if it's a subclass, this will iterate through the superclasses:
+    #
+    #   class ThisIsATopLevelClass < Nokogiri::HTML4::Builder ; end
+    #   ThisIsATopLevelClass.new.related_class("Document")
+    #   # => Nokogiri::HTML4::Document
+    #
+    def related_class(class_name)
+      klass = nil
+      inspecting = self.class
+
+      while inspecting
+        namespace_path = inspecting.name.split("::")[0..-2]
+        inspecting = inspecting.superclass
+
+        next unless VALID_NAMESPACES.include?(namespace_path.last)
+
+        related_class_name = (namespace_path << class_name).join("::")
+        klass = begin
+          Object.const_get(related_class_name)
+        rescue NameError
+          nil
+        end
+        break if klass
+      end
+      klass
+    end
+  end
+end

data/lib/nokogiri/css/node.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
+
 module Nokogiri
   module CSS
-    class Node
+    class Node # :nodoc:
       ALLOW_COMBINATOR_ON_SELF = [:DIRECT_ADJACENT_SELECTOR, :FOLLOWING_SELECTOR, :CHILD_SELECTOR]
 
       # Get the type of this node
@@ -10,25 +11,25 @@ module Nokogiri
       attr_accessor :value
 
       # Create a new Node with +type+ and +value+
-      def initialize type, value
+      def initialize(type, value)
         @type = type
         @value = value
       end
 
       # Accept +visitor+
-      def accept visitor
+      def accept(visitor)
         visitor.send(:"visit_#{type.to_s.downcase}", self)
       end
 
       ###
       # Convert this CSS node to xpath with +prefix+ using +visitor+
-      def to_xpath prefix = '//', visitor = XPathVisitor.new
-        prefix = '.' if ALLOW_COMBINATOR_ON_SELF.include?(type) && value.first.nil?
+      def to_xpath(prefix, visitor)
+        prefix = "." if ALLOW_COMBINATOR_ON_SELF.include?(type) && value.first.nil?
         prefix + visitor.accept(self)
       end
 
       # Find a node by type using +types+
-      def find_by_type types
+      def find_by_type(types)
         matches = []
         matches << self if to_type == types
         @value.each do |v|
@@ -39,9 +40,9 @@ module Nokogiri
 
       # Convert to_type
       def to_type
-        [@type] + @value.map { |n|
+        [@type] + @value.map do |n|
           n.to_type if n.respond_to?(:to_type)
-        }.compact
+        end.compact
       end
 
       # Convert to array

data/lib/nokogiri/css/parser.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 #
 # DO NOT MODIFY!!!!
-# This file is automatically generated by Racc 1.5.2
+# This file is automatically generated by Racc 1.6.0
 # from Racc grammar file "".
 #
 
@@ -10,6 +10,14 @@ require 'racc/parser.rb'
 
 require_relative "parser_extras"
 
+module Nokogiri
+  module CSS
+    # :nodoc: all
+    class Parser < Racc::Parser
+    end
+  end
+end
+
 module Nokogiri
   module CSS
     class Parser < Racc::Parser
@@ -485,7 +493,7 @@ def _reduce_27(val, _values, result)
 end
 
 def _reduce_28(val, _values, result)
-        result = Node.new(:ELEMENT_NAME,
+        result = Node.new(:ATTRIB_NAME,
           [[val.first, val.last].compact.join(':')]
         )
 
@@ -495,7 +503,7 @@ end
 def _reduce_29(val, _values, result)
         # Default namespace is not applied to attributes.
         # So we don't add prefix "xmlns:" as in namespaced_ident.
-        result = Node.new(:ELEMENT_NAME, [val.first])
+        result = Node.new(:ATTRIB_NAME, [val.first])
 
     result
 end

data/lib/nokogiri/css/parser.y

@@ -96,14 +96,14 @@ rule
     ;
   attrib_name
     : namespace '|' IDENT {
-        result = Node.new(:ELEMENT_NAME,
+        result = Node.new(:ATTRIB_NAME,
           [[val.first, val.last].compact.join(':')]
         )
       }
     | IDENT {
         # Default namespace is not applied to attributes.
         # So we don't add prefix "xmlns:" as in namespaced_ident.
-        result = Node.new(:ELEMENT_NAME, [val.first])
+        result = Node.new(:ATTRIB_NAME, [val.first])
       }
     ;
   function
@@ -255,6 +255,14 @@ end
 
 require_relative "parser_extras"
 
+module Nokogiri
+  module CSS
+    # :nodoc: all
+    class Parser < Racc::Parser
+    end
+  end
+end
+
 ---- inner
 
 def unescape_css_identifier(identifier)

data/lib/nokogiri/css/parser_extras.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 require "thread"
 
 module Nokogiri
   module CSS
-    class Parser < Racc::Parser
+    class Parser < Racc::Parser # :nodoc:
       CACHE_SWITCH_NAME = :nokogiri_css_parser_cache_is_off
 
       @cache = {}
@@ -16,13 +17,13 @@ module Nokogiri
         end
 
         # Set a thread-local boolean to turn cacheing on and off. Truthy values turn the cache on, falsey values turn the cache off.
-        def set_cache(value)
+        def set_cache(value) # rubocop:disable Naming/AccessorMethodName
           Thread.current[CACHE_SWITCH_NAME] = !value
         end
 
         # Get the css selector in +string+ from the cache
         def [](string)
-          return unless cache_on?
+          return nil unless cache_on?
           @mutex.synchronize { @cache[string] }
         end
 
@@ -46,10 +47,10 @@ module Nokogiri
         # Execute +block+ without cache
         def without_cache(&block)
           original_cache_setting = cache_on?
-          set_cache false
-          block.call
+          set_cache(false)
+          yield
         ensure
-          set_cache original_cache_setting
+          set_cache(original_cache_setting)
         end
       end
 
@@ -61,7 +62,7 @@ module Nokogiri
       end
 
       def parse(string)
-        @tokenizer.scan_setup string
+        @tokenizer.scan_setup(string)
         do_parse
       end
 
@@ -70,24 +71,23 @@ module Nokogiri
       end
 
       # Get the xpath for +string+ using +options+
-      def xpath_for(string, options = {})
-        key = "#{string}#{options[:ns]}#{options[:prefix]}"
-        v = self.class[key]
-        return v if v
-
-        args = [
-          options[:prefix] || "//",
-          options[:visitor] || XPathVisitor.new,
-        ]
-        self.class[key] = parse(string).map { |ast|
-          ast.to_xpath(*args)
-        }
+      def xpath_for(string, prefix, visitor)
+        key = cache_key(string, prefix, visitor)
+        self.class[key] ||= parse(string).map do |ast|
+          ast.to_xpath(prefix, visitor)
+        end
       end
 
       # On CSS parser error, raise an exception
       def on_error(error_token_id, error_value, value_stack)
         after = value_stack.compact.last
-        raise SyntaxError.new("unexpected '#{error_value}' after '#{after}'")
+        raise SyntaxError, "unexpected '#{error_value}' after '#{after}'"
+      end
+
+      def cache_key(query, prefix, visitor)
+        if self.class.cache_on?
+          [query, prefix, @namespaces, visitor.config]
+        end
       end
     end
   end

data/lib/nokogiri/css/syntax_error.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative "../syntax_error"
 module Nokogiri
   module CSS

data/lib/nokogiri/css/tokenizer.rb

@@ -7,7 +7,8 @@
 
 module Nokogiri
 module CSS
-class Tokenizer # :nodoc:
+# :nodoc: all
+class Tokenizer
       require 'strscan'
 
       class ScanError < StandardError ; end

data/lib/nokogiri/css/tokenizer.rex

@@ -1,6 +1,7 @@
 module Nokogiri
 module CSS
-class Tokenizer # :nodoc:
+# :nodoc: all
+class Tokenizer
 
 macro
   nl        \n|\r\n|\r|\f