nokogiri 1.11.1 → 1.12.0.rc1

data/gumbo-parser/src/util.h

@@ -0,0 +1,30 @@
+#ifndef GUMBO_UTIL_H_
+#define GUMBO_UTIL_H_
+
+#include <stdbool.h>
+#include <stddef.h>
+#include "macros.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Utility function for allocating & copying a null-terminated string into a
+// freshly-allocated buffer. This is necessary for proper memory management; we
+// have the convention that all const char* in parse tree structures are
+// freshly-allocated, so if we didn't copy, we'd try to delete a literal string
+// when the parse tree is destroyed.
+char* gumbo_strdup(const char* str) XMALLOC NONNULL_ARGS;
+
+void* gumbo_alloc(size_t size) XMALLOC;
+void* gumbo_realloc(void* ptr, size_t size) RETURNS_NONNULL;
+void gumbo_free(void* ptr);
+
+// Debug wrapper for printf
+void gumbo_debug(const char* format, ...) PRINTF(1);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GUMBO_UTIL_H_

data/gumbo-parser/src/vector.c

@@ -0,0 +1,111 @@
+/*
+ Copyright 2018 Craig Barnes.
+ Copyright 2010 Google Inc.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include "vector.h"
+#include "util.h"
+
+void gumbo_vector_init(unsigned int initial_capacity, GumboVector* vector) {
+  vector->length = 0;
+  vector->capacity = initial_capacity;
+  if (initial_capacity > 0) {
+    vector->data = gumbo_alloc(sizeof(void*) * initial_capacity);
+  } else {
+    vector->data = NULL;
+  }
+}
+
+void gumbo_vector_destroy(GumboVector* vector) {
+  if (vector->capacity > 0) {
+    gumbo_free(vector->data);
+  }
+}
+
+static void enlarge_vector_if_full(GumboVector* vector) {
+  if (vector->length >= vector->capacity) {
+    if (vector->capacity) {
+      vector->capacity *= 2;
+      size_t num_bytes = sizeof(void*) * vector->capacity;
+      vector->data = gumbo_realloc(vector->data, num_bytes);
+    } else {
+      // 0-capacity vector; no previous array to deallocate.
+      vector->capacity = 2;
+      vector->data = gumbo_alloc(sizeof(void*) * vector->capacity);
+    }
+  }
+}
+
+void gumbo_vector_add(void* element, GumboVector* vector) {
+  enlarge_vector_if_full(vector);
+  assert(vector->data);
+  assert(vector->length < vector->capacity);
+  vector->data[vector->length++] = element;
+}
+
+void* gumbo_vector_pop(GumboVector* vector) {
+  if (vector->length == 0) {
+    return NULL;
+  }
+  return vector->data[--vector->length];
+}
+
+int gumbo_vector_index_of(GumboVector* vector, const void* element) {
+  for (unsigned int i = 0; i < vector->length; ++i) {
+    if (vector->data[i] == element) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+void gumbo_vector_insert_at (
+  void* element,
+  unsigned int index,
+  GumboVector* vector
+) {
+  assert(index <= vector->length);
+  enlarge_vector_if_full(vector);
+  ++vector->length;
+  memmove (
+    &vector->data[index + 1],
+    &vector->data[index],
+    sizeof(void*) * (vector->length - index - 1)
+  );
+  vector->data[index] = element;
+}
+
+void gumbo_vector_remove(void* node, GumboVector* vector) {
+  int index = gumbo_vector_index_of(vector, node);
+  if (index == -1) {
+    return;
+  }
+  gumbo_vector_remove_at(index, vector);
+}
+
+void* gumbo_vector_remove_at(unsigned int index, GumboVector* vector) {
+  assert(index < vector->length);
+  void* result = vector->data[index];
+  memmove (
+    &vector->data[index],
+    &vector->data[index + 1],
+    sizeof(void*) * (vector->length - index - 1)
+  );
+  --vector->length;
+  return result;
+}

data/gumbo-parser/src/vector.h

@@ -0,0 +1,45 @@
+#ifndef GUMBO_VECTOR_H_
+#define GUMBO_VECTOR_H_
+
+#include "gumbo.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Initializes a new GumboVector with the specified initial capacity.
+void gumbo_vector_init(unsigned int initial_capacity, GumboVector* vector);
+
+// Frees the memory used by a GumboVector. Does not free the contained
+// pointers.
+void gumbo_vector_destroy(GumboVector* vector);
+
+// Adds a new element to a GumboVector.
+void gumbo_vector_add(void* element, GumboVector* vector);
+
+// Removes and returns the element most recently added to the GumboVector.
+// Ownership is transferred to caller. Capacity is unchanged. If the vector is
+// empty, NULL is returned.
+void* gumbo_vector_pop(GumboVector* vector);
+
+// Inserts an element at a specific index. This is potentially O(N) time, but
+// is necessary for some of the spec's behavior.
+void gumbo_vector_insert_at (
+  void* element,
+  unsigned int index,
+  GumboVector* vector
+);
+
+// Removes an element from the vector, or does nothing if the element is not in
+// the vector.
+void gumbo_vector_remove(void* element, GumboVector* vector);
+
+// Removes and returns an element at a specific index. Note that this is
+// potentially O(N) time and should be used sparingly.
+void* gumbo_vector_remove_at(unsigned int index, GumboVector* vector);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GUMBO_VECTOR_H_

data/lib/nokogiri.rb

@@ -2,59 +2,29 @@
 # frozen_string_literal: true
 # Modify the PATH on windows so that the external DLLs will get loaded.
 
-require 'rbconfig'
+require "rbconfig"
 
 if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
-  require 'nokogiri/jruby/dependencies'
+  require_relative "nokogiri/jruby/dependencies"
 end
 
-begin
-  RUBY_VERSION =~ /(\d+\.\d+)/
-  require "nokogiri/#{$1}/nokogiri"
-rescue LoadError => e
-  if e.message =~ /GLIBC/
-    warn <<~EOM
-
-      ERROR: It looks like you're trying to use Nokogiri as a precompiled native gem on a system with glibc < 2.17:
-
-        #{e.message}
-
-        If that's the case, then please install Nokogiri via the `ruby` platform gem:
-            gem install nokogiri --platform=ruby
-        or:
-            bundle config set force_ruby_platform true
-
-        Please visit https://nokogiri.org/tutorials/installing_nokogiri.html for more help.
-
-    EOM
-    raise e
-  end
-  require 'nokogiri/nokogiri'
-end
-require 'nokogiri/version'
-require 'nokogiri/syntax_error'
-require 'nokogiri/xml'
-require 'nokogiri/xslt'
-require 'nokogiri/html'
-require 'nokogiri/decorators/slop'
-require 'nokogiri/css'
-require 'nokogiri/html/builder'
+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::HTML::Document depending on the kind of document you parse.
+# Nokogiri::HTML4::Document depending on the kind of document you parse.
 #
 # Here is an example:
 #
 #   require 'nokogiri'
 #   require 'open-uri'
 #
-#   # Get a Nokogiri::HTML:Document for the page we’re interested in...
+#   # Get a Nokogiri::HTML4::Document for the page we’re interested in...
 #
-#   doc = Nokogiri::HTML(URI.open('http://www.google.com/search?q=tenderlove'))
+#   doc = Nokogiri::HTML4(URI.open('http://www.google.com/search?q=tenderlove'))
 #
 #   # Do funky things with it using Nokogiri::XML::Node methods...
 #
@@ -70,27 +40,27 @@ module Nokogiri
   class << self
     ###
     # Parse an HTML or XML document.  +string+ contains the document.
-    def parse string, url = nil, encoding = nil, options = nil
+    def parse(string, url = nil, encoding = nil, options = nil)
       if string.respond_to?(:read) ||
           /^\s*<(?:!DOCTYPE\s+)?html[\s>]/i === 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.HTML(string, url, encoding,
+        Nokogiri.HTML4(string, url, encoding,
           options || XML::ParseOptions::DEFAULT_HTML)
       else
         Nokogiri.XML(string, url, encoding,
           options || XML::ParseOptions::DEFAULT_XML)
-      end.tap { |doc|
+      end.tap do |doc|
         yield doc if block_given?
-      }
+      end
     end
 
     ###
     # Create a new Nokogiri::XML::DocumentFragment
-    def make input = nil, opts = {}, &blk
+    def make(input = nil, opts = {}, &blk)
       if input
-        Nokogiri::HTML.fragment(input).children.first
+        Nokogiri::HTML4.fragment(input).children.first
       else
         Nokogiri(&blk)
       end
@@ -119,10 +89,10 @@ module Nokogiri
       # 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 { |alias_name, name|
+        "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
 
@@ -130,15 +100,26 @@ module Nokogiri
 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
+# 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 or Nokogiri.HTML.
+# To specify the type of document, use {Nokogiri.XML}, {Nokogiri.HTML4}, or {Nokogiri.HTML5}.
 def Nokogiri(*args, &block)
   if block_given?
-    Nokogiri::HTML::Builder.new(&block).doc.root
+    Nokogiri::HTML4::Builder.new(&block).doc.root
   else
     Nokogiri.parse(*args)
   end
 end
+
+require_relative "nokogiri/version"
+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?

data/lib/nokogiri/css.rb

@@ -1,28 +1,28 @@
 # frozen_string_literal: true
-require 'nokogiri/css/node'
-require 'nokogiri/css/xpath_visitor'
-x = $-w
-$-w = false
-require 'nokogiri/css/parser'
-$-w = x
-
-require 'nokogiri/css/tokenizer'
-require 'nokogiri/css/syntax_error'
-
 module Nokogiri
   module CSS
     class << self
       ###
       # Parse this CSS selector in +selector+.  Returns an AST.
-      def parse selector
-        Parser.new.parse selector
+      def parse(selector)
+        Parser.new.parse(selector)
       end
 
       ###
       # Get the XPath for +selector+.
-      def xpath_for selector, options={}
-        Parser.new(options[:ns] || {}).xpath_for selector, options
+      def xpath_for(selector, options = {})
+        Parser.new(options[:ns] || {}).xpath_for(selector, options)
       end
     end
   end
 end
+
+require_relative "css/node"
+require_relative "css/xpath_visitor"
+x = $-w
+$-w = false
+require_relative "css/parser"
+$-w = x
+
+require_relative "css/tokenizer"
+require_relative "css/syntax_error"

data/lib/nokogiri/css/parser.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 #
 # DO NOT MODIFY!!!!
-# This file is automatically generated by Racc 1.5.1
+# This file is automatically generated by Racc 1.5.2
 # from Racc grammar file "".
 #
 
 require 'racc/parser.rb'
 
 
-require 'nokogiri/css/parser_extras'
+require_relative "parser_extras"
 
 module Nokogiri
   module CSS

data/lib/nokogiri/css/parser.y

@@ -253,7 +253,7 @@ end
 
 ---- header
 
-require 'nokogiri/css/parser_extras'
+require_relative "parser_extras"
 
 ---- inner
 

data/lib/nokogiri/css/syntax_error.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require 'nokogiri/syntax_error'
+require_relative "../syntax_error"
 module Nokogiri
   module CSS
     class SyntaxError < ::Nokogiri::SyntaxError

data/lib/nokogiri/extension.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# load the C or Java extension
+begin
+  ::RUBY_VERSION =~ /(\d+\.\d+)/
+  require_relative "#{Regexp.last_match(1)}/nokogiri"
+rescue LoadError => e
+  if e.message =~ /GLIBC/
+    warn(<<~EOM)
+
+      ERROR: It looks like you're trying to use Nokogiri as a precompiled native gem on a system with glibc < 2.17:
+
+        #{e.message}
+
+        If that's the case, then please install Nokogiri via the `ruby` platform gem:
+            gem install nokogiri --platform=ruby
+        or:
+            bundle config set force_ruby_platform true
+
+        Please visit https://nokogiri.org/tutorials/installing_nokogiri.html for more help.
+
+    EOM
+    raise e
+  end
+  require_relative "nokogiri"
+end

data/lib/nokogiri/gumbo.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Nokogiri
+  module Gumbo
+    # The default maximum number of attributes per element.
+    DEFAULT_MAX_ATTRIBUTES = 400
+
+    # The default maximum number of errors for parsing a document or a fragment.
+    DEFAULT_MAX_ERRORS = 0
+
+    # The default maximum depth of the DOM tree produced by parsing a document
+    # or fragment.
+    DEFAULT_MAX_TREE_DEPTH = 400
+  end
+end