mini-pro-gem 0.0.1

data/nokogiri-1.19.4/ext/nokogiri/nokogiri.h

@@ -0,0 +1,247 @@
+#ifndef NOKOGIRI_NATIVE
+#define NOKOGIRI_NATIVE
+
+#include <ruby/defines.h> // https://github.com/sparklemotion/nokogiri/issues/2696
+
+#ifdef _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
+
+#ifdef _WIN32
+#  define NOKOPUBFUN __declspec(dllexport)
+#  define NOKOPUBVAR __declspec(dllexport) extern
+#else
+#  define NOKOPUBFUN
+#  define NOKOPUBVAR extern
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+#include <libxml/entities.h>
+#include <libxml/xpath.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 <libxml/c14n.h>
+#include <libxml/parserInternals.h>
+#include <libxml/xpathInternals.h>
+
+#include <libxslt/extensions.h>
+#include <libxslt/xsltconfig.h>
+#include <libxslt/xsltutils.h>
+#include <libxslt/transform.h>
+#include <libxslt/imports.h>
+#include <libxslt/xsltInternals.h>
+
+#include <libexslt/exslt.h>
+
+/* libxml2_polyfill.c */
+#ifndef HAVE_XMLCTXTSETOPTIONS
+int xmlCtxtSetOptions(xmlParserCtxtPtr ctxt, int options);
+#endif
+#ifndef HAVE_XMLCTXTGETOPTIONS
+int xmlCtxtGetOptions(xmlParserCtxtPtr ctxt);
+#endif
+#ifndef HAVE_XMLSWITCHENCODINGNAME
+int xmlSwitchEncodingName(xmlParserCtxtPtr ctxt, const char *encoding);
+#endif
+
+#define XMLNS_PREFIX "xmlns"
+#define XMLNS_PREFIX_LEN 6 /* including either colon or \0 */
+
+#ifndef xmlErrorConstPtr
+#  if LIBXML_VERSION >= 21200
+#    define xmlErrorConstPtr const xmlError *
+#  else
+#    define xmlErrorConstPtr xmlError *
+#  endif
+#endif
+
+#include <ruby.h>
+#include <ruby/st.h>
+#include <ruby/encoding.h>
+#include <ruby/util.h>
+#include <ruby/version.h>
+
+#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)
+
+#ifndef NORETURN_DECL
+#  if defined(__GNUC__)
+#    define NORETURN_DECL __attribute__ ((noreturn))
+#  else
+#    define NORETURN_DECL
+#  endif
+#endif
+
+#ifndef PRINTFLIKE_DECL
+#  if defined(__GNUC__)
+#    define PRINTFLIKE_DECL(stringidx, argidx) __attribute__ ((format(printf,stringidx,argidx)))
+#  else
+#    define PRINTFLIKE_DECL(stringidx, argidx)
+#  endif
+#endif
+
+#if defined(TRUFFLERUBY) && !defined(NOKOGIRI_PACKAGED_LIBRARIES)
+#  define TRUFFLERUBY_NOKOGIRI_SYSTEM_LIBRARIES
+#endif
+
+NOKOPUBVAR VALUE mNokogiri ;
+NOKOPUBVAR VALUE mNokogiriGumbo ;
+NOKOPUBVAR VALUE mNokogiriHtml4 ;
+NOKOPUBVAR VALUE mNokogiriHtml4Sax ;
+NOKOPUBVAR VALUE mNokogiriHtml5 ;
+NOKOPUBVAR VALUE mNokogiriXml ;
+NOKOPUBVAR VALUE mNokogiriXmlSax ;
+NOKOPUBVAR VALUE mNokogiriXmlXpath ;
+NOKOPUBVAR VALUE mNokogiriXslt ;
+
+NOKOPUBVAR VALUE cNokogiriEncodingHandler;
+NOKOPUBVAR VALUE cNokogiriSyntaxError;
+NOKOPUBVAR VALUE cNokogiriXmlAttr;
+NOKOPUBVAR VALUE cNokogiriXmlAttributeDecl;
+NOKOPUBVAR VALUE cNokogiriXmlCData;
+NOKOPUBVAR VALUE cNokogiriXmlCharacterData;
+NOKOPUBVAR VALUE cNokogiriXmlComment;
+NOKOPUBVAR VALUE cNokogiriXmlDocument ;
+NOKOPUBVAR VALUE cNokogiriXmlDocumentFragment;
+NOKOPUBVAR VALUE cNokogiriXmlDtd;
+NOKOPUBVAR VALUE cNokogiriXmlElement ;
+NOKOPUBVAR VALUE cNokogiriXmlElementContent;
+NOKOPUBVAR VALUE cNokogiriXmlElementDecl;
+NOKOPUBVAR VALUE cNokogiriXmlEntityDecl;
+NOKOPUBVAR VALUE cNokogiriXmlEntityReference;
+NOKOPUBVAR VALUE cNokogiriXmlNamespace ;
+NOKOPUBVAR VALUE cNokogiriXmlNode ;
+NOKOPUBVAR VALUE cNokogiriXmlNodeSet ;
+NOKOPUBVAR VALUE cNokogiriXmlProcessingInstruction;
+NOKOPUBVAR VALUE cNokogiriXmlReader;
+NOKOPUBVAR VALUE cNokogiriXmlRelaxNG;
+NOKOPUBVAR VALUE cNokogiriXmlSaxParser ;
+NOKOPUBVAR VALUE cNokogiriXmlSaxParserContext;
+NOKOPUBVAR VALUE cNokogiriXmlSaxPushParser ;
+NOKOPUBVAR VALUE cNokogiriXmlSchema;
+NOKOPUBVAR VALUE cNokogiriXmlSyntaxError;
+NOKOPUBVAR VALUE cNokogiriXmlText ;
+NOKOPUBVAR VALUE cNokogiriXmlXpathContext;
+NOKOPUBVAR VALUE cNokogiriXmlXpathSyntaxError;
+NOKOPUBVAR VALUE cNokogiriXsltStylesheet ;
+
+NOKOPUBVAR VALUE cNokogiriHtml4Document ;
+NOKOPUBVAR VALUE cNokogiriHtml4SaxPushParser ;
+NOKOPUBVAR VALUE cNokogiriHtml4ElementDescription ;
+NOKOPUBVAR VALUE cNokogiriHtml4SaxParser;
+NOKOPUBVAR VALUE cNokogiriHtml4SaxParserContext;
+NOKOPUBVAR VALUE cNokogiriHtml5Document ;
+
+typedef struct _nokogiriTuple {
+  VALUE         doc;
+  st_table     *unlinkedNodes;
+  VALUE         node_cache;
+} nokogiriTuple;
+typedef nokogiriTuple *nokogiriTuplePtr;
+
+typedef struct _libxmlStructuredErrorHandlerState {
+  void *user_data;
+  xmlStructuredErrorFunc handler;
+} libxmlStructuredErrorHandlerState ;
+
+typedef struct _nokogiriXsltStylesheetTuple {
+  xsltStylesheetPtr ss;
+  VALUE func_instances;
+} nokogiriXsltStylesheetTuple;
+
+void noko_xml_document_pin_node(xmlNodePtr);
+void noko_xml_document_pin_namespace(xmlNsPtr, xmlDocPtr);
+int noko_xml_document_has_wrapped_blank_nodes_p(xmlDocPtr c_document);
+
+int noko_io_read(void *ctx, char *buffer, int len);
+int noko_io_write(void *ctx, char *buffer, int len);
+int noko_io_close(void *ctx);
+
+static inline void *
+_noko_data_ptr(VALUE rb_object)
+{
+  void *c_data = DATA_PTR(rb_object);
+  if (c_data == NULL) {
+    rb_raise(rb_eRuntimeError, "Uninitialized %" PRIsVALUE " struct (null data pointer)", rb_obj_class(rb_object));
+  }
+  return c_data;
+}
+#define Noko_Node_Get_Struct(obj,type,sval) ((sval) = (type*)_noko_data_ptr(obj))
+#define Noko_Namespace_Get_Struct(obj,type,sval) ((sval) = (type*)_noko_data_ptr(obj))
+
+VALUE noko_xml_node_wrap(VALUE klass, xmlNodePtr node) ;
+VALUE noko_xml_node_wrap_node_set_result(xmlNodePtr node, VALUE node_set) ;
+VALUE noko_xml_node_attrs(xmlNodePtr node) ;
+
+VALUE noko_xml_namespace_wrap(xmlNsPtr node, xmlDocPtr doc);
+VALUE noko_xml_namespace_wrap_xpath_copy(xmlNsPtr node);
+
+VALUE noko_xml_element_content_wrap(VALUE doc, xmlElementContentPtr element);
+
+VALUE noko_xml_node_set_wrap(xmlNodeSetPtr node_set, VALUE document) ;
+xmlNodeSetPtr noko_xml_node_set_unwrap(VALUE rb_node_set) ;
+
+VALUE noko_xml_document_wrap_with_init_args(VALUE klass, xmlDocPtr doc, int argc, VALUE *argv);
+VALUE noko_xml_document_wrap(VALUE klass, xmlDocPtr doc);
+xmlDocPtr noko_xml_document_unwrap(VALUE rb_document);
+NOKOPUBFUN VALUE Nokogiri_wrap_xml_document(VALUE klass,
+    xmlDocPtr doc); /* deprecated. use noko_xml_document_wrap() instead. */
+
+xmlSAXHandlerPtr noko_xml_sax_parser_unwrap(VALUE rb_sax_handler);
+
+xmlParserCtxtPtr noko_xml_sax_push_parser_unwrap(VALUE rb_parser);
+
+VALUE noko_xml_sax_parser_context_wrap(VALUE klass, xmlParserCtxtPtr c_context);
+xmlParserCtxtPtr noko_xml_sax_parser_context_unwrap(VALUE rb_context);
+void noko_xml_sax_parser_context_set_encoding(xmlParserCtxtPtr c_context, VALUE rb_encoding);
+
+#define DOC_RUBY_OBJECT_TEST(x) ((nokogiriTuplePtr)(x->_private))
+#define DOC_RUBY_OBJECT(x) (((nokogiriTuplePtr)(x->_private))->doc)
+#define DOC_UNLINKED_NODE_HASH(x) (((nokogiriTuplePtr)(x->_private))->unlinkedNodes)
+#define DOC_NODE_CACHE(x) (((nokogiriTuplePtr)(x->_private))->node_cache)
+#define NOKOGIRI_NAMESPACE_EH(node) ((node)->type == XML_NAMESPACE_DECL)
+
+#define DISCARD_CONST_QUAL(t, v) ((t)(uintptr_t)(v))
+#define DISCARD_CONST_QUAL_XMLCHAR(v) DISCARD_CONST_QUAL(xmlChar *, v)
+
+#if HAVE_RB_CATEGORY_WARNING
+#  define NOKO_WARN_DEPRECATION(message...) rb_category_warning(RB_WARN_CATEGORY_DEPRECATED, message)
+#else
+#  define NOKO_WARN_DEPRECATION(message...) rb_warning(message)
+#endif
+
+void noko__structured_error_func_save(libxmlStructuredErrorHandlerState *handler_state);
+void noko__structured_error_func_save_and_set(libxmlStructuredErrorHandlerState *handler_state, void *user_data,
+    xmlStructuredErrorFunc handler);
+void noko__structured_error_func_restore(libxmlStructuredErrorHandlerState *handler_state);
+VALUE noko_xml_syntax_error__wrap(xmlErrorConstPtr error);
+void noko__error_array_pusher(void *ctx, xmlErrorConstPtr error);
+NORETURN_DECL void noko__error_raise(void *ctx, xmlErrorConstPtr error);
+void Nokogiri_marshal_xpath_funcall_and_return_values(xmlXPathParserContextPtr ctx, int nargs, VALUE handler,
+    const char *function_name) ;
+
+#endif /* NOKOGIRI_NATIVE */

data/nokogiri-1.19.4/ext/nokogiri/test_global_handlers.c

@@ -0,0 +1,40 @@
+#include <nokogiri.h>
+
+static VALUE foreign_error_handler_block = Qnil;
+
+static void
+foreign_error_handler(void *user_data, xmlErrorConstPtr c_error)
+{
+  rb_funcall(foreign_error_handler_block, rb_intern("call"), 0);
+}
+
+/*
+ * call-seq:
+ *   __foreign_error_handler { ... } -> nil
+ *
+ * Override libxml2's global error handlers to call the block. This method thus has very little
+ * value except to test that Nokogiri is properly setting error handlers elsewhere in the code. See
+ * test/helper.rb for how this is being used.
+ */
+static VALUE
+rb_foreign_error_handler(VALUE klass)
+{
+  rb_need_block();
+  foreign_error_handler_block = rb_block_proc();
+  xmlSetStructuredErrorFunc(NULL, foreign_error_handler);
+  return Qnil;
+}
+
+/*
+ *  Document-module: Nokogiri::Test
+ *
+ *  The Nokogiri::Test module should only be used for testing Nokogiri.
+ *  Do NOT use this outside of the Nokogiri test suite.
+ */
+void
+noko_init_test_global_handlers(void)
+{
+  VALUE mNokogiriTest = rb_define_module_under(mNokogiri, "Test");
+
+  rb_define_singleton_method(mNokogiriTest, "__foreign_error_handler", rb_foreign_error_handler, 0);
+}

data/nokogiri-1.19.4/ext/nokogiri/xml_attr.c

@@ -0,0 +1,108 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlAttr;
+
+/*
+ * 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
+noko_xml_attr_set_value(VALUE self, VALUE content)
+{
+  xmlAttrPtr attr;
+
+  Noko_Node_Get_Struct(self, xmlAttr, attr);
+
+  {
+    /* Unlink and pin any wrapped children */
+    xmlNode *cur = attr->children;
+    xmlNode *next;
+
+    while (cur) {
+      next = cur->next;
+      if (cur->_private) {
+        xmlUnlinkNode(cur);
+        noko_xml_document_pin_node(cur);
+      }
+      cur = next;
+    }
+  }
+
+  if (content == Qnil) {
+    xmlNodeSetContent((xmlNodePtr)attr, NULL); /* Clear any remaining unwrapped children. */
+  } else {
+    xmlChar *value = xmlEncodeEntitiesReentrant(attr->doc, (unsigned char *)StringValueCStr(content));
+
+    if (xmlStrlen(value) == 0) {
+      xmlNodeSetContent((xmlNodePtr)attr, NULL); /* Clear any remaining unwrapped children. */
+
+      /* Preserve empty-string attributes as `foo=""` and not boolean `foo` */
+      attr->children = attr->last = xmlNewDocText(attr->doc, value);
+      attr->children->parent = (xmlNode *)attr;
+    } else {
+      xmlNodeSetContent((xmlNodePtr)attr, value);
+    }
+    xmlFree(value);
+  }
+
+  return content;
+}
+
+/*
+ * call-seq:
+ *  new(document, name)
+ *
+ * Create a new Attr element on the +document+ with +name+
+ */
+static VALUE
+noko_xml_attr__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");
+  }
+
+  xml_doc = noko_xml_document_unwrap(document);
+
+  node = xmlNewDocProp(
+           xml_doc,
+           (const xmlChar *)StringValueCStr(name),
+           NULL
+         );
+
+  noko_xml_document_pin_node((xmlNodePtr)node);
+
+  rb_node = noko_xml_node_wrap(klass, (xmlNodePtr)node);
+  rb_obj_call_init(rb_node, argc, argv);
+
+  if (rb_block_given_p()) {
+    rb_yield(rb_node);
+  }
+
+  return rb_node;
+}
+
+void
+noko_init_xml_attr(void)
+{
+  assert(cNokogiriXmlNode);
+  /*
+   * Attr represents a Attr node in an xml document.
+   */
+  cNokogiriXmlAttr = rb_define_class_under(mNokogiriXml, "Attr", cNokogiriXmlNode);
+
+  rb_define_singleton_method(cNokogiriXmlAttr, "new", noko_xml_attr__new, -1);
+
+  rb_define_method(cNokogiriXmlAttr, "value=", noko_xml_attr_set_value, 1);
+}

data/nokogiri-1.19.4/ext/nokogiri/xml_attribute_decl.c

@@ -0,0 +1,70 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlAttributeDecl;
+
+/*
+ * call-seq:
+ *  attribute_type
+ *
+ * The attribute_type for this AttributeDecl
+ */
+static VALUE
+attribute_type(VALUE self)
+{
+  xmlAttributePtr node;
+  Noko_Node_Get_Struct(self, xmlAttribute, node);
+  return INT2NUM(node->atype);
+}
+
+/*
+ * call-seq:
+ *  default
+ *
+ * The default value
+ */
+static VALUE
+default_value(VALUE self)
+{
+  xmlAttributePtr node;
+  Noko_Node_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;
+
+  Noko_Node_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;
+}
+
+void
+noko_init_xml_attribute_decl(void)
+{
+  assert(cNokogiriXmlNode);
+  cNokogiriXmlAttributeDecl = rb_define_class_under(mNokogiriXml, "AttributeDecl", cNokogiriXmlNode);
+
+  rb_define_method(cNokogiriXmlAttributeDecl, "attribute_type", attribute_type, 0);
+  rb_define_method(cNokogiriXmlAttributeDecl, "default", default_value, 0);
+  rb_define_method(cNokogiriXmlAttributeDecl, "enumeration", enumeration, 0);
+}

data/nokogiri-1.19.4/ext/nokogiri/xml_cdata.c

@@ -0,0 +1,62 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlCData;
+
+/*
+ * call-seq:
+ *  new(document, content)
+ *
+ * Create a new CDATA element on the +document+ with +content+
+ *
+ * If +content+ cannot be implicitly converted to a string, this method will
+ * raise a TypeError exception.
+ */
+static VALUE
+rb_xml_cdata_s_new(int argc, VALUE *argv, VALUE klass)
+{
+  xmlDocPtr c_document;
+  xmlNodePtr c_node;
+  VALUE rb_document;
+  VALUE rb_content;
+  VALUE rb_rest;
+  VALUE rb_node;
+
+  rb_scan_args(argc, argv, "2*", &rb_document, &rb_content, &rb_rest);
+
+  Check_Type(rb_content, T_STRING);
+  if (!rb_obj_is_kind_of(rb_document, cNokogiriXmlNode)) {
+    rb_raise(rb_eTypeError,
+             "expected first parameter to be a Nokogiri::XML::Document, received %"PRIsVALUE,
+             rb_obj_class(rb_document));
+  }
+
+  if (!rb_obj_is_kind_of(rb_document, cNokogiriXmlDocument)) {
+    xmlNodePtr deprecated_node_type_arg;
+    NOKO_WARN_DEPRECATION("Passing a Node as the first parameter to CDATA.new is deprecated. Please pass a Document instead. This will become an error in Nokogiri v1.17.0."); // TODO: deprecated in v1.15.3, remove in v1.17.0
+    Noko_Node_Get_Struct(rb_document, xmlNode, deprecated_node_type_arg);
+    c_document = deprecated_node_type_arg->doc;
+  } else {
+    c_document = noko_xml_document_unwrap(rb_document);
+  }
+
+  c_node = xmlNewCDataBlock(c_document, (xmlChar *)StringValueCStr(rb_content), RSTRING_LENINT(rb_content));
+  noko_xml_document_pin_node(c_node);
+  rb_node = noko_xml_node_wrap(klass, c_node);
+  rb_obj_call_init(rb_node, argc, argv);
+
+  if (rb_block_given_p()) { rb_yield(rb_node); }
+
+  return rb_node;
+}
+
+void
+noko_init_xml_cdata(void)
+{
+  assert(cNokogiriXmlText);
+  /*
+   * CData represents a CData node in an xml document.
+   */
+  cNokogiriXmlCData = rb_define_class_under(mNokogiriXml, "CDATA", cNokogiriXmlText);
+
+  rb_define_singleton_method(cNokogiriXmlCData, "new", rb_xml_cdata_s_new, -1);
+}

data/nokogiri-1.19.4/ext/nokogiri/xml_comment.c

@@ -0,0 +1,57 @@
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlComment;
+
+static ID document_id ;
+
+/*
+ * call-seq:
+ *  new(document_or_node, content)
+ *
+ * Create a new Comment element on the +document+ with +content+.
+ * Alternatively, if a +node+ is passed, the +node+'s document is used.
+ */
+static VALUE
+new (int argc, VALUE *argv, VALUE klass)
+{
+  xmlDocPtr xml_doc;
+  xmlNodePtr node;
+  VALUE document;
+  VALUE content;
+  VALUE rest;
+  VALUE rb_node;
+
+  rb_scan_args(argc, argv, "2*", &document, &content, &rest);
+
+  Check_Type(content, T_STRING);
+  if (rb_obj_is_kind_of(document, cNokogiriXmlNode)) {
+    document = rb_funcall(document, document_id, 0);
+  } else if (!rb_obj_is_kind_of(document, cNokogiriXmlDocument)
+             && !rb_obj_is_kind_of(document, cNokogiriXmlDocumentFragment)) {
+    rb_raise(rb_eArgError, "first argument must be a XML::Document or XML::Node");
+  }
+  xml_doc = noko_xml_document_unwrap(document);
+
+  node = xmlNewDocComment(xml_doc, (const xmlChar *)StringValueCStr(content));
+  noko_xml_document_pin_node(node);
+  rb_node = noko_xml_node_wrap(klass, node);
+  rb_obj_call_init(rb_node, argc, argv);
+
+  if (rb_block_given_p()) { rb_yield(rb_node); }
+
+  return rb_node;
+}
+
+void
+noko_init_xml_comment(void)
+{
+  assert(cNokogiriXmlCharacterData);
+  /*
+   * Comment represents a comment node in an xml document.
+   */
+  cNokogiriXmlComment = rb_define_class_under(mNokogiriXml, "Comment", cNokogiriXmlCharacterData);
+
+  rb_define_singleton_method(cNokogiriXmlComment, "new", new, -1);
+
+  document_id = rb_intern("document");
+}