nokogiri 1.5.10 → 1.13.0

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_