nokogiri 1.11.0.rc4-arm64-darwin

data/ext/nokogiri/nokogiri.c

@@ -0,0 +1,135 @@
+#include <nokogiri.h>
+
+VALUE mNokogiri ;
+VALUE mNokogiriXml ;
+VALUE mNokogiriHtml ;
+VALUE mNokogiriXslt ;
+VALUE mNokogiriXmlSax ;
+VALUE mNokogiriHtmlSax ;
+
+#ifndef HAVE_VASPRINTF
+/*
+ * Thank you Geoffroy Couprie for this implementation of vasprintf!
+ */
+int vasprintf(char **strp, const char *fmt, va_list ap)
+{
+  /* Mingw32/64 have a broken vsnprintf implementation that fails when
+   * using a zero-byte limit in order to retrieve the required size for malloc.
+   * So we use a one byte buffer instead.
+   */
+  char tmp[1];
+  int len = vsnprintf (tmp, 1, fmt, ap) + 1;
+  char *res = (char *)malloc((unsigned int)len);
+  if (res == NULL) {
+    return -1;
+  }
+  *strp = res;
+  return vsnprintf(res, (unsigned int)len, fmt, ap);
+}
+#endif
+
+#include "ruby/util.h"
+
+void nokogiri_root_node(xmlNodePtr node)
+{
+  xmlDocPtr doc;
+  nokogiriTuplePtr tuple;
+
+  doc = node->doc;
+  if (doc->type == XML_DOCUMENT_FRAG_NODE) { doc = doc->doc; }
+  tuple = (nokogiriTuplePtr)doc->_private;
+  st_insert(tuple->unlinkedNodes, (st_data_t)node, (st_data_t)node);
+}
+
+void nokogiri_root_nsdef(xmlNsPtr ns, xmlDocPtr doc)
+{
+  nokogiriTuplePtr tuple;
+
+  if (doc->type == XML_DOCUMENT_FRAG_NODE) { doc = doc->doc; }
+  tuple = (nokogiriTuplePtr)doc->_private;
+  st_insert(tuple->unlinkedNodes, (st_data_t)ns, (st_data_t)ns);
+}
+
+void Init_nokogiri()
+{
+  xmlMemSetup(
+    (xmlFreeFunc)ruby_xfree,
+    (xmlMallocFunc)ruby_xmalloc,
+    (xmlReallocFunc)ruby_xrealloc,
+    ruby_strdup
+  );
+
+  mNokogiri         = rb_define_module("Nokogiri");
+  mNokogiriXml      = rb_define_module_under(mNokogiri, "XML");
+  mNokogiriHtml     = rb_define_module_under(mNokogiri, "HTML");
+  mNokogiriXslt     = rb_define_module_under(mNokogiri, "XSLT");
+  mNokogiriXmlSax   = rb_define_module_under(mNokogiriXml, "SAX");
+  mNokogiriHtmlSax  = rb_define_module_under(mNokogiriHtml, "SAX");
+
+  rb_const_set(mNokogiri, rb_intern("LIBXML_COMPILED_VERSION"), NOKOGIRI_STR_NEW2(LIBXML_DOTTED_VERSION));
+  rb_const_set(mNokogiri, rb_intern("LIBXML_LOADED_VERSION"), NOKOGIRI_STR_NEW2(xmlParserVersion));
+
+  rb_const_set(mNokogiri, rb_intern("LIBXSLT_COMPILED_VERSION"), NOKOGIRI_STR_NEW2(LIBXSLT_DOTTED_VERSION));
+  rb_const_set(mNokogiri, rb_intern("LIBXSLT_LOADED_VERSION"), NOKOGIRI_STR_NEW2(xsltEngineVersion));
+
+#ifdef NOKOGIRI_PACKAGED_LIBRARIES
+  rb_const_set(mNokogiri, rb_intern("PACKAGED_LIBRARIES"), Qtrue);
+#ifdef NOKOGIRI_PRECOMPILED_LIBRARIES
+  rb_const_set(mNokogiri, rb_intern("PRECOMPILED_LIBRARIES"), Qtrue);
+#else
+  rb_const_set(mNokogiri, rb_intern("PRECOMPILED_LIBRARIES"), Qfalse);
+#endif
+  rb_const_set(mNokogiri, rb_intern("LIBXML2_PATCHES"), rb_str_split(NOKOGIRI_STR_NEW2(NOKOGIRI_LIBXML2_PATCHES), " "));
+  rb_const_set(mNokogiri, rb_intern("LIBXSLT_PATCHES"), rb_str_split(NOKOGIRI_STR_NEW2(NOKOGIRI_LIBXSLT_PATCHES), " "));
+#else
+  rb_const_set(mNokogiri, rb_intern("PACKAGED_LIBRARIES"), Qfalse);
+  rb_const_set(mNokogiri, rb_intern("PRECOMPILED_LIBRARIES"), Qfalse);
+  rb_const_set(mNokogiri, rb_intern("LIBXML2_PATCHES"), Qnil);
+  rb_const_set(mNokogiri, rb_intern("LIBXSLT_PATCHES"), Qnil);
+#endif
+
+#ifdef LIBXML_ICONV_ENABLED
+  rb_const_set(mNokogiri, rb_intern("LIBXML_ICONV_ENABLED"), Qtrue);
+#else
+  rb_const_set(mNokogiri, rb_intern("LIBXML_ICONV_ENABLED"), Qfalse);
+#endif
+
+#ifdef NOKOGIRI_OTHER_LIBRARY_VERSIONS
+  rb_const_set(mNokogiri, rb_intern("OTHER_LIBRARY_VERSIONS"), NOKOGIRI_STR_NEW2(NOKOGIRI_OTHER_LIBRARY_VERSIONS));
+#endif
+
+  xmlInitParser();
+
+  init_xml_document();
+  init_html_document();
+  init_xml_node();
+  init_xml_document_fragment();
+  init_xml_text();
+  init_xml_cdata();
+  init_xml_processing_instruction();
+  init_xml_attr();
+  init_xml_entity_reference();
+  init_xml_comment();
+  init_xml_node_set();
+  init_xml_xpath_context();
+  init_xml_sax_parser_context();
+  init_xml_sax_parser();
+  init_xml_sax_push_parser();
+  init_xml_reader();
+  init_xml_dtd();
+  init_xml_element_content();
+  init_xml_attribute_decl();
+  init_xml_element_decl();
+  init_xml_entity_decl();
+  init_xml_namespace();
+  init_html_sax_parser_context();
+  init_html_sax_push_parser();
+  init_xslt_stylesheet();
+  init_xml_syntax_error();
+  init_html_entity_lookup();
+  init_html_element_description();
+  init_xml_schema();
+  init_xml_relax_ng();
+  init_nokogiri_io();
+  init_xml_encoding_handler();
+}

data/ext/nokogiri/nokogiri.h

@@ -0,0 +1,130 @@
+#ifndef NOKOGIRI_NATIVE
+#define NOKOGIRI_NATIVE
+
+#if _MSC_VER
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif /* WIN32_LEAN_AND_MEAN */
+
+#  ifndef WIN32
+#    define WIN32
+#  endif /* WIN32 */
+
+#  include <winsock2.h>
+#  include <ws2tcpip.h>
+#  include <windows.h>
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#include <libxml/parser.h>
+#include <libxml/entities.h>
+#include <libxml/parserInternals.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+#include <libxml/xmlreader.h>
+#include <libxml/xmlsave.h>
+#include <libxml/xmlschemas.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/relaxng.h>
+#include <libxml/xinclude.h>
+#include <libxslt/extensions.h>
+#include <libxslt/xsltconfig.h>
+#include <libxml/c14n.h>
+
+#include <ruby.h>
+#include <ruby/st.h>
+#include <ruby/encoding.h>
+
+#ifndef NORETURN
+# if defined(__GNUC__)
+#  define NORETURN(name) __attribute__((noreturn)) name
+# else
+#  define NORETURN(name) name
+# endif
+#endif
+
+#define NOKOGIRI_STR_NEW2(str) \
+  NOKOGIRI_STR_NEW(str, strlen((const char *)(str)))
+
+#define NOKOGIRI_STR_NEW(str, len) \
+  rb_external_str_new_with_enc((const char *)(str), (long)(len), rb_utf8_encoding())
+
+#define RBSTR_OR_QNIL(_str) \
+  (_str ? NOKOGIRI_STR_NEW2(_str) : Qnil)
+
+#include <xml_libxml2_hacks.h>
+
+#include <xml_io.h>
+#include <xml_document.h>
+#include <html_entity_lookup.h>
+#include <html_document.h>
+#include <xml_node.h>
+#include <xml_text.h>
+#include <xml_cdata.h>
+#include <xml_attr.h>
+#include <xml_processing_instruction.h>
+#include <xml_entity_reference.h>
+#include <xml_document_fragment.h>
+#include <xml_comment.h>
+#include <xml_node_set.h>
+#include <xml_dtd.h>
+#include <xml_attribute_decl.h>
+#include <xml_element_decl.h>
+#include <xml_entity_decl.h>
+#include <xml_xpath_context.h>
+#include <xml_element_content.h>
+#include <xml_sax_parser_context.h>
+#include <xml_sax_parser.h>
+#include <xml_sax_push_parser.h>
+#include <xml_reader.h>
+#include <html_sax_parser_context.h>
+#include <html_sax_push_parser.h>
+#include <xslt_stylesheet.h>
+#include <xml_syntax_error.h>
+#include <xml_schema.h>
+#include <xml_relax_ng.h>
+#include <html_element_description.h>
+#include <xml_namespace.h>
+#include <xml_encoding_handler.h>
+
+extern VALUE mNokogiri ;
+extern VALUE mNokogiriXml ;
+extern VALUE mNokogiriXmlSax ;
+extern VALUE mNokogiriHtml ;
+extern VALUE mNokogiriHtmlSax ;
+extern VALUE mNokogiriXslt ;
+
+int vasprintf(char **strp, const char *fmt, va_list ap);
+
+void nokogiri_root_node(xmlNodePtr);
+void nokogiri_root_nsdef(xmlNsPtr, xmlDocPtr);
+
+#ifdef DEBUG
+
+#  define NOKOGIRI_DEBUG_START(p) if (getenv("NOKOGIRI_NO_FREE")) return ; if (getenv("NOKOGIRI_DEBUG")) fprintf(stderr,"nokogiri: %s:%d %p start\n", __FILE__, __LINE__, p);
+#  define NOKOGIRI_DEBUG_END(p) if (getenv("NOKOGIRI_DEBUG")) fprintf(stderr,"nokogiri: %s:%d %p end\n", __FILE__, __LINE__, p);
+
+#else
+
+#  define NOKOGIRI_DEBUG_START(p)
+#  define NOKOGIRI_DEBUG_END(p)
+
+#endif
+
+#ifndef __builtin_expect
+#  if defined(__GNUC__)
+#    define __builtin_expect(expr, c) __builtin_expect((long)(expr), (long)(c))
+#  endif
+#endif
+
+#define XMLNS_PREFIX "xmlns"
+#define XMLNS_PREFIX_LEN 6 /* including either colon or \0 */
+#define XMLNS_BUFFER_LEN 128
+
+#endif

data/ext/nokogiri/xml_attr.c

@@ -0,0 +1,103 @@
+#include <xml_attr.h>
+
+/*
+ * call-seq:
+ *  value=(content)
+ *
+ * Set the value for this Attr to +content+. Use `nil` to remove the value
+ * (e.g., a HTML boolean attribute).
+ */
+static VALUE set_value(VALUE self, VALUE content)
+{
+  xmlAttrPtr attr;
+  xmlChar *value;
+  xmlNode *cur;
+
+  Data_Get_Struct(self, xmlAttr, attr);
+
+  if (attr->children) {
+    xmlFreeNodeList(attr->children);
+  }
+  attr->children = attr->last = NULL;
+
+  if (content == Qnil) {
+    return content;
+  }
+
+  value = xmlEncodeEntitiesReentrant(attr->doc, (unsigned char *)StringValueCStr(content));
+  if (xmlStrlen(value) == 0) {
+    attr->children = xmlNewDocText(attr->doc, value);
+  } else {
+    attr->children = xmlStringGetNodeList(attr->doc, value);
+  }
+  xmlFree(value);
+
+  for (cur = attr->children; cur; cur = cur->next) {
+    cur->parent = (xmlNode *)attr;
+    cur->doc = attr->doc;
+    if (cur->next == NULL) {
+      attr->last = cur;
+    }
+  }
+
+  return content;
+}
+
+/*
+ * call-seq:
+ *  new(document, name)
+ *
+ * Create a new Attr element on the +document+ with +name+
+ */
+static VALUE new(int argc, VALUE *argv, VALUE klass)
+{
+  xmlDocPtr xml_doc;
+  VALUE document;
+  VALUE name;
+  VALUE rest;
+  xmlAttrPtr node;
+  VALUE rb_node;
+
+  rb_scan_args(argc, argv, "2*", &document, &name, &rest);
+
+  if (! rb_obj_is_kind_of(document, cNokogiriXmlDocument)) {
+    rb_raise(rb_eArgError, "parameter must be a Nokogiri::XML::Document");
+  }
+
+  Data_Get_Struct(document, xmlDoc, xml_doc);
+
+  node = xmlNewDocProp(
+           xml_doc,
+           (const xmlChar *)StringValueCStr(name),
+           NULL
+         );
+
+  nokogiri_root_node((xmlNodePtr)node);
+
+  rb_node = Nokogiri_wrap_xml_node(klass, (xmlNodePtr)node);
+  rb_obj_call_init(rb_node, argc, argv);
+
+  if (rb_block_given_p()) {
+    rb_yield(rb_node);
+  }
+
+  return rb_node;
+}
+
+VALUE cNokogiriXmlAttr;
+void init_xml_attr()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
+
+  /*
+   * Attr represents a Attr node in an xml document.
+   */
+  VALUE klass = rb_define_class_under(xml, "Attr", node);
+
+  cNokogiriXmlAttr = klass;
+
+  rb_define_singleton_method(klass, "new", new, -1);
+  rb_define_method(klass, "value=", set_value, 1);
+}

data/ext/nokogiri/xml_attr.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_ATTR
+#define NOKOGIRI_XML_ATTR
+
+#include <nokogiri.h>
+
+void init_xml_attr();
+
+extern VALUE cNokogiriXmlAttr;
+#endif

data/ext/nokogiri/xml_attribute_decl.c

@@ -0,0 +1,70 @@
+#include <xml_attribute_decl.h>
+
+/*
+ * call-seq:
+ *  attribute_type
+ *
+ * The attribute_type for this AttributeDecl
+ */
+static VALUE attribute_type(VALUE self)
+{
+  xmlAttributePtr node;
+  Data_Get_Struct(self, xmlAttribute, node);
+  return INT2NUM((long)node->atype);
+}
+
+/*
+ * call-seq:
+ *  default
+ *
+ * The default value
+ */
+static VALUE default_value(VALUE self)
+{
+  xmlAttributePtr node;
+  Data_Get_Struct(self, xmlAttribute, node);
+
+  if(node->defaultValue) return NOKOGIRI_STR_NEW2(node->defaultValue);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  enumeration
+ *
+ * An enumeration of possible values
+ */
+static VALUE enumeration(VALUE self)
+{
+  xmlAttributePtr node;
+  xmlEnumerationPtr enm;
+  VALUE list;
+
+  Data_Get_Struct(self, xmlAttribute, node);
+
+  list = rb_ary_new();
+  enm = node->tree;
+
+  while(enm) {
+    rb_ary_push(list, NOKOGIRI_STR_NEW2(enm->name));
+    enm = enm->next;
+  }
+
+  return list;
+}
+
+VALUE cNokogiriXmlAttributeDecl;
+
+void init_xml_attribute_decl()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
+  VALUE klass = rb_define_class_under(xml, "AttributeDecl", node);
+
+  cNokogiriXmlAttributeDecl = klass;
+
+  rb_define_method(klass, "attribute_type", attribute_type, 0);
+  rb_define_method(klass, "default", default_value, 0);
+  rb_define_method(klass, "enumeration", enumeration, 0);
+}