nokogiri 1.6.0 → 1.13.2

data/gumbo-parser/Makefile

@@ -0,0 +1,101 @@
+.PHONY: all clean check coverage
+
+gumbo_objs := $(patsubst %.c,build/%.o,$(wildcard src/*.c))
+test_objs := $(patsubst %.cc,build/%.o,$(wildcard test/*.cc))
+gtest_lib := googletest/make/gtest_main.a
+
+# make SANITIZEFLAGS='-fsanitize=undefined -fsanitize=address'
+SANITIZEFLAGS :=
+CPPFLAGS := -Isrc
+CFLAGS := -std=c99 -Os -Wall
+CXXFLAGS := -isystem googletest/include -std=c++11 -Os -Wall
+LDFLAGS := -pthread
+
+all: check
+
+src/%.c: src/%.rl
+	ragel -F1 -o $@ $<
+
+build/src:
+	mkdir -p $@
+
+build/test:
+	mkdir -p $@
+
+build/src/%.o: src/%.c build/src/flags | build/src
+	$(CC) -MMD $(CPPFLAGS) $(CFLAGS) $(SANITIZEFLAGS) -c -o $@ $<
+
+build/test/%.o: test/%.cc build/test/flags | build/test
+	$(CXX) -MMD $(CPPFLAGS) $(CXXFLAGS) $(SANITIZEFLAGS) -c -o $@ $<
+
+build/run_tests: $(gumbo_objs) $(test_objs) $(gtest_lib)
+	$(CXX) -o $@ $+ $(LDFLAGS) $(SANITIZEFLAGS)
+
+check: build/run_tests
+	./build/run_tests
+
+coverage:
+	$(RM) build/{src,test}/*.gcda
+	$(RM) build/*.info
+	$(MAKE) CPPFLAGS='-Isrc -DNDEBUG=1' \
+		CFLAGS='-std=c99 --coverage -g -O0' \
+		CXXFLAGS='-isystem googletest/include -std=c++11 --coverage -g -O0' \
+		LDFLAGS='--coverage' \
+		build/run_tests
+	lcov	--no-external \
+		--initial \
+		--capture \
+		--base-directory . \
+		--directory build \
+		--output-file build/coverage-pre.info
+	awk	-F '[:,]' \
+		'/^SF:/ { delete defs } /^FN:/ { defs[$$2]=1 } /^DA:/ { if ($$3 == 0 && $$2 in defs) next } { print }' \
+		build/coverage-pre.info > build/coverage-initial.info
+	./build/run_tests
+	lcov	--no-external \
+		--capture \
+		--base-directory . \
+		--directory build \
+		--rc lcov_branch_coverage=1 \
+		--output-file build/coverage-test.info
+	lcov	--add-tracefile build/coverage-initial.info \
+		--add-tracefile build/coverage-test.info \
+		--rc lcov_branch_coverage=1 \
+		--output-file build/coverage.info
+	lcov	--remove build/coverage.info '$(CURDIR)/googletest/*' \
+		--rc lcov_branch_coverage=1 \
+		--output-file build/coverage.info
+	genhtml --branch-coverage \
+		--output-directory build/coverage \
+		build/coverage.info
+
+clean:
+	$(RM) -r build
+
+build/src/flags: | build/src
+	@echo 'old_CC := $(CC)' > $@
+	@echo 'old_CPPFLAGS := $(CPPFLAGS)' >> $@
+	@echo 'old_CFLAGS := $(CFLAGS)' >>$@
+	@echo 'old_SANITIZEFLAGS := $(SANITIZEFLAGS)' >> $@
+	@echo 'old_LDFLAGS := $(LDFLAGS)' >> $@
+
+build/test/flags: | build/test
+	@echo 'old_CXX := $(CXX)' > $@
+	@echo 'old_CPPFLAGS := $(CPPFLAGS)' >> $@
+	@echo 'old_CXXFLAGS := $(CXXFLAGS)' >> $@
+	@echo 'old_SANITIZEFLAGS := $(SANITIZEFLAGS)' >> $@
+	@echo 'old_LDFLAGS := $(LDFLAGS)' >> $@
+
+ifeq (,$(filter clean coverage,$(MAKECMDGOALS)))
+# Ensure that the flags are up to date.
+-include build/src/flags build/test/flags
+ifneq ($(old_CC) | $(old_CPPFLAGS) | $(old_CFLAGS) | $(old_SANITIZEFLAGS) | $(old_LDFLAGS),$(CC) | $(CPPFLAGS) | $(CFLAGS) | $(SANITIZEFLAGS) | $(LDFLAGS))
+.PHONY: build/src/flags
+endif
+ifneq ($(old_CXX) | $(old_CPPFLAGS) | $(old_CXXFLAGS) | $(old_SANITIZEFLAGS) | $(old_LDFLAGS),$(CXX) | $(CPPFLAGS) | $(CXXFLAGS) | $(SANITIZEFLAGS) | $(LDFLAGS))
+.PHONY: build/test/flags
+endif
+
+# Include dependencies.
+-include $(test_objs:.o=.d) $(gumbo_objs:.o=.d)
+endif

data/gumbo-parser/THANKS

@@ -0,0 +1,27 @@
+Gumbo HTML parser THANKS file
+
+Gumbo was originally written by Jonathan Tang, but many people helped out through suggestions, question-answering, code reviews, bugfixes, and organizational support.  Here is a list of these people.  Help me keep it complete and exempt of errors.
+
+Adam Barth
+Adam Roben
+Ben Noordhuis
+Bowen Han
+Constantinos Michael
+Craig Barnes
+Geoffrey Sneddon
+Ian Hickson
+Jack Deng
+Joel Low
+Jonathan Shneier
+Kevin Hendricks
+Mason Tang
+Maxim Zakharov
+Michal Zalewski
+Neal Norwitz
+Othar Hansson
+Ryan Grove
+Stefan Haustein
+Steffen Meschkat
+Steven Kabbes
+Thiago Farina
+Vicent Marti

data/gumbo-parser/src/Makefile

@@ -0,0 +1,34 @@
+# this Makefile is used by ext/nokogiri/extconf.rb
+# to enable a mini_portile2 recipe to build the gumbo parser
+.PHONY: clean
+
+CFLAGS += -std=c99 -Wall
+
+# allow the ENV var to override this
+RANLIB ?= ranlib
+
+gumbo_objs := \
+	ascii.o \
+	attribute.o \
+	char_ref.o \
+	error.o \
+	foreign_attrs.o \
+	parser.o \
+	string_buffer.o \
+	string_piece.o \
+	svg_attrs.o \
+	svg_tags.o \
+	tag.o \
+	tag_lookup.o \
+	token_buffer.o \
+	tokenizer.o \
+	utf8.o \
+	util.o \
+	vector.o
+
+libgumbo.a: $(gumbo_objs)
+	$(AR) $(ARFLAGS) $@ $(gumbo_objs)
+	- ($(RANLIB) $@ || true) >/dev/null 2>&1
+
+clean:
+	rm -f $(gumbo_objs) libgumbo.a

data/gumbo-parser/src/README.md

@@ -0,0 +1,41 @@
+libgumbo
+========
+
+This is an internal fork of the [libgumbo] library, which was copied and
+later modified under the terms of the Apache 2.0 [license]. See `lua-gumbo`
+commit [`0a04728`] for details of the original import.
+
+Since importing the code, the following notable fixes and improvements
+have been made:
+
+* `91cef89`: Re-implement `adjust_foreign_attributes()` with a gperf hash
+* `b11abe7`: Pass `TagSet` arrays into functions by reference instead of value
+* `b73dc03`: Simplify `maybe_replace_codepoint()` function
+* `d5d0bb3`: Remove special handling of `<menuitem>` tag
+* `7bd5162`: Remove special handling of `<isindex>` tag
+* `a5c1b0e`: Use `realloc(3)` instead of `malloc(3)` in `enlarge_vector_if_full()`
+* `dcbebd7`: Use `realloc(3)` instead of `malloc(3)` in `maybe_resize_string_buffer()`
+* `df15262`: Make `destroy_node()` function non-recursive
+* `2df37f5`: Fix signedness of some format specifiers
+* `176553e`: Add maximum element nesting limit
+* `bed0f4a`: Annotate `gumbo_debug()` with `PRINTF` macro and fix warnings
+* `7ffc218`: Annotate `print_message()` with `PRINTF` macro and fix warnings
+* `1bd8ab5`, `9136507`, `53a1f9a`: Deduplicate some identical `TagSet` arrays
+* `a7a9065`: Add some GCC/Clang function attributes
+* `8d3d4e4`: Remove custom allocator support
+* `8d3b006`: Fix recording of source positions for `</form>` end tags
+* `1a8d763`: Replace linear search in `maybe_replace_codepoint()` with a lookup table
+* `6dca79e`: Replace `strcasecmp()` and `strncasecmp()` with ascii-only equivalents
+* `17ab1d2`: Fix `TAGSET_INCLUDES` macro to work properly with multiple bit flags
+* `7e56d45`: Re-implement `gumbo_normalize_svg_tagname()` with a gperf hash
+* `a518d35`: Replace linear array search in `adjust_svg_attributes()` with a gperf hash
+* `a4a7433`: Fix duplicate `TagSet` initializer being ignored in `is_special_node()`
+* `8137fcd`: Add support for `<dialog>` tag
+* `4b35471`: Add missing `static` qualifiers to hide symbols that shouldn't be extern
+* `df57c59`, `03101f3`, `ea62330`: Replace use of locale-dependant `ctype.h` functions
+  with custom, ASCII-only equivalents
+
+
+[libgumbo]: https://github.com/google/gumbo-parser/tree/aa91b27b02c0c80c482e24348a457ed7c3c088e0/src
+[license]: https://github.com/google/gumbo-parser/blob/aa91b27b02c0c80c482e24348a457ed7c3c088e0/COPYING
+[`0a04728`]: https://gitlab.com/craigbarnes/lua-gumbo/commit/0a047282815af86f3367a7d95fefcfe5723ece48

data/gumbo-parser/src/ascii.c

@@ -0,0 +1,75 @@
+#include "ascii.h"
+
+int gumbo_ascii_strcasecmp(const char *s1, const char *s2) {
+  int c1, c2;
+  while (*s1 && *s2) {
+    c1 = (int)(unsigned char) gumbo_ascii_tolower(*s1);
+    c2 = (int)(unsigned char) gumbo_ascii_tolower(*s2);
+    if (c1 != c2) {
+      return (c1 - c2);
+    }
+    s1++;
+    s2++;
+  }
+  return (((int)(unsigned char) *s1) - ((int)(unsigned char) *s2));
+}
+
+int gumbo_ascii_strncasecmp(const char *s1, const char *s2, size_t n) {
+  int c1, c2;
+  while (n && *s1 && *s2) {
+    n -= 1;
+    c1 = (int)(unsigned char) gumbo_ascii_tolower(*s1);
+    c2 = (int)(unsigned char) gumbo_ascii_tolower(*s2);
+    if (c1 != c2) {
+      return (c1 - c2);
+    }
+    s1++;
+    s2++;
+  }
+  if (n) {
+    return (((int)(unsigned char) *s1) - ((int)(unsigned char) *s2));
+  }
+  return 0;
+}
+
+const unsigned char _gumbo_ascii_table[0x80] = {
+  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x03,0x03,0x01,0x03,0x03,0x01,0x01,
+  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
+  0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x28,0x28,0x28,0x28,0x28,0x28,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
+  0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x50,0x50,0x50,0x50,0x50,0x50,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,
+  0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x00,0x00,0x00,0x00,0x00,
+};
+
+// Table generation code.
+// clang -DGUMBO_GEN_TABLE=1 ascii.c && ./a.out && rm a.out
+#if GUMBO_GEN_TABLE
+#include <stdio.h>
+
+int main() {
+  printf("const unsigned char _gumbo_ascii_table[0x80] = {");
+  for (int c = 0; c < 0x80; ++c) {
+    unsigned int x = 0;
+    // https://infra.spec.whatwg.org/#ascii-code-point
+    if (c <= 0x1f)
+      x |= GUMBO_ASCII_CNTRL;
+    if (c == 0x09 || c == 0x0a || c == 0x0c || c == 0x0d || c == 0x20)
+      x |= GUMBO_ASCII_SPACE;
+    if (c >= 0x30 && c <= 0x39)
+      x |= GUMBO_ASCII_DIGIT;
+    if ((c >= 0x30 && c <= 0x39) || (c >= 0x41 && c <= 0x46))
+      x |= GUMBO_ASCII_UPPER_XDIGIT;
+    if ((c >= 0x30 && c <= 0x39) || (c >= 0x61 && c <= 0x66))
+      x |= GUMBO_ASCII_LOWER_XDIGIT;
+    if (c >= 0x41 && c <= 0x5a)
+      x |= GUMBO_ASCII_UPPER_ALPHA;
+    if (c >= 0x61 && c <= 0x7a)
+      x |= GUMBO_ASCII_LOWER_ALPHA;
+    printf("%s0x%02x,", (c % 16 == 0? "\n  " : ""), x);
+  }
+  printf("\n};\n");
+  return 0;
+}
+#endif

data/gumbo-parser/src/ascii.h

@@ -0,0 +1,115 @@
+#ifndef GUMBO_ASCII_H_
+#define GUMBO_ASCII_H_
+
+#include <stddef.h>
+#include "macros.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PURE NONNULL_ARGS
+int gumbo_ascii_strcasecmp(const char *s1, const char *s2);
+
+PURE NONNULL_ARGS
+int gumbo_ascii_strncasecmp(const char *s1, const char *s2, size_t n);
+
+// If these values change, then _gumbo_ascii_table needs to be regenerated.
+#define GUMBO_ASCII_CNTRL 1
+#define GUMBO_ASCII_SPACE 2
+#define GUMBO_ASCII_DIGIT 4
+#define GUMBO_ASCII_UPPER_XDIGIT 8
+#define GUMBO_ASCII_LOWER_XDIGIT 16
+#define GUMBO_ASCII_UPPER_ALPHA 32
+#define GUMBO_ASCII_LOWER_ALPHA 64
+#define GUMBO_ASCII_XDIGIT (GUMBO_ASCII_LOWER_XDIGIT | GUMBO_ASCII_UPPER_XDIGIT)
+#define GUMBO_ASCII_ALPHA (GUMBO_ASCII_UPPER_ALPHA | GUMBO_ASCII_LOWER_ALPHA)
+#define GUMBO_ASCII_ALNUM (GUMBO_ASCII_DIGIT | GUMBO_ASCII_ALPHA)
+
+extern const unsigned char _gumbo_ascii_table[0x80];
+
+CONST_FN
+static inline int gumbo_ascii_isascii(int c) {
+  return ((unsigned int)c & ~0x7fu) == 0;
+}
+
+// 0x00 -- 0x1F (A C0 control)
+CONST_FN
+static inline int gumbo_ascii_iscntrl(int c) {
+  return gumbo_ascii_isascii(c)
+         && (_gumbo_ascii_table[c] & GUMBO_ASCII_CNTRL);
+}
+
+// 0x09, 0x0a, 0x0c, 0x0d, 0x20
+CONST_FN
+static inline int gumbo_ascii_isspace(int c) {
+  return gumbo_ascii_isascii(c)
+         && (_gumbo_ascii_table[c] & GUMBO_ASCII_SPACE);
+}
+
+CONST_FN
+static inline int gumbo_ascii_istab_or_newline(int c) {
+  return c == 0x09 || c == 0x0a || c == 0x0d;
+}
+
+
+CONST_FN
+static inline int gumbo_ascii_isdigit(int c) {
+  return c >= 0x30 && c <= 0x39;
+}
+
+CONST_FN
+static inline int gumbo_ascii_isalpha(int c) {
+  return gumbo_ascii_isascii(c)
+         && (_gumbo_ascii_table[c] & GUMBO_ASCII_ALPHA);
+}
+
+CONST_FN
+static inline int gumbo_ascii_isxdigit(int c) {
+  return gumbo_ascii_isascii(c)
+         && (_gumbo_ascii_table[c] & GUMBO_ASCII_XDIGIT);
+}
+
+CONST_FN
+static inline int gumbo_ascii_isupper_xdigit(int c) {
+  return gumbo_ascii_isascii(c)
+         && (_gumbo_ascii_table[c] & GUMBO_ASCII_UPPER_XDIGIT);
+}
+
+CONST_FN
+static inline int gumbo_ascii_islower_xdigit(int c) {
+  return gumbo_ascii_isascii(c)
+         && (_gumbo_ascii_table[c] & GUMBO_ASCII_LOWER_XDIGIT);
+}
+
+CONST_FN
+static inline int gumbo_ascii_isupper(int c) {
+  return ((unsigned)(c) - 'A') < 26;
+}
+
+CONST_FN
+static inline int gumbo_ascii_islower(int c) {
+  return gumbo_ascii_isascii(c)
+         && (_gumbo_ascii_table[c] & GUMBO_ASCII_LOWER_ALPHA);
+}
+
+CONST_FN
+static inline int gumbo_ascii_isalnum(int c) {
+  return gumbo_ascii_isascii(c)
+         && (_gumbo_ascii_table[c] & GUMBO_ASCII_ALNUM);
+}
+  
+
+CONST_FN
+static inline int gumbo_ascii_tolower(int c) {
+  if (gumbo_ascii_isupper(c)) {
+    return c | 32;
+  }
+  return c;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GUMBO_ASCII_H_

data/gumbo-parser/src/attribute.c

@@ -0,0 +1,42 @@
+/*
+ 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 "attribute.h"
+#include "ascii.h"
+#include "util.h"
+
+GumboAttribute* gumbo_get_attribute (
+  const GumboVector* attributes,
+  const char* name
+) {
+  for (unsigned int i = 0; i < attributes->length; ++i) {
+    GumboAttribute* attr = attributes->data[i];
+    if (!gumbo_ascii_strcasecmp(attr->name, name)) {
+      return attr;
+    }
+  }
+  return NULL;
+}
+
+void gumbo_destroy_attribute(GumboAttribute* attribute) {
+  gumbo_free((void*) attribute->name);
+  gumbo_free((void*) attribute->value);
+  gumbo_free((void*) attribute);
+}

data/gumbo-parser/src/attribute.h

@@ -0,0 +1,17 @@
+#ifndef GUMBO_ATTRIBUTE_H_
+#define GUMBO_ATTRIBUTE_H_
+
+#include "gumbo.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Release the memory used for a GumboAttribute, including the attribute itself
+void gumbo_destroy_attribute(GumboAttribute* attribute);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // GUMBO_ATTRIBUTE_H_