nokogiri 1.0.0 → 1.6.8.1

data/ext/nokogiri/xml_entity_reference.c

@@ -0,0 +1,52 @@
+#include <xml_entity_reference.h>
+
+/*
+ * call-seq:
+ *  new(document, content)
+ *
+ * Create a new EntityReference element on the +document+ with +name+
+ */
+static VALUE new(int argc, VALUE *argv, VALUE klass)
+{
+  xmlDocPtr xml_doc;
+  xmlNodePtr node;
+  VALUE document;
+  VALUE name;
+  VALUE rest;
+  VALUE rb_node;
+
+  rb_scan_args(argc, argv, "2*", &document, &name, &rest);
+
+  Data_Get_Struct(document, xmlDoc, xml_doc);
+
+  node = xmlNewReference(
+      xml_doc,
+      (const xmlChar *)StringValueCStr(name)
+  );
+
+  nokogiri_root_node(node);
+
+  rb_node = Nokogiri_wrap_xml_node(klass, node);
+  rb_obj_call_init(rb_node, argc, argv);
+
+  if(rb_block_given_p()) rb_yield(rb_node);
+
+  return rb_node;
+}
+
+VALUE cNokogiriXmlEntityReference;
+void init_xml_entity_reference()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
+
+  /*
+   * EntityReference represents an EntityReference node in an xml document.
+   */
+  VALUE klass = rb_define_class_under(xml, "EntityReference", node);
+
+  cNokogiriXmlEntityReference = klass;
+
+  rb_define_singleton_method(klass, "new", new, -1);
+}

data/ext/nokogiri/xml_entity_reference.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_ENTITY_REFERENCE
+#define NOKOGIRI_XML_ENTITY_REFERENCE
+
+#include <nokogiri.h>
+
+void init_xml_entity_reference();
+
+extern VALUE cNokogiriXmlEntityReference;
+#endif

data/ext/nokogiri/xml_io.c

@@ -0,0 +1,60 @@
+#include <xml_io.h>
+
+static ID id_read, id_write;
+
+VALUE read_check(VALUE *args) {
+  return rb_funcall(args[0], id_read, 1, args[1]);
+}
+
+VALUE read_failed(void) {
+	return Qundef;
+}
+
+int io_read_callback(void * ctx, char * buffer, int len) {
+  VALUE string, args[2];
+  size_t str_len, safe_len;
+
+  args[0] = (VALUE)ctx;
+  args[1] = INT2NUM(len);
+
+  string = rb_rescue(read_check, (VALUE)args, read_failed, 0);
+
+  if (NIL_P(string)) return 0;
+  if (string == Qundef) return -1;
+
+  str_len = (size_t)RSTRING_LEN(string);
+  safe_len = str_len > (size_t)len ? (size_t)len : str_len;
+  memcpy(buffer, StringValuePtr(string), safe_len);
+
+  return (int)safe_len;
+}
+
+VALUE write_check(VALUE *args) {
+  return rb_funcall(args[0], id_write, 1, args[1]);
+}
+
+VALUE write_failed(void) {
+	return Qundef;
+}
+
+int io_write_callback(void * ctx, char * buffer, int len) {
+  VALUE args[2], size;
+
+  args[0] = (VALUE)ctx;
+  args[1] = rb_str_new(buffer, (long)len);
+
+  size = rb_rescue(write_check, (VALUE)args, write_failed, 0);
+
+  if (size == Qundef) return -1;
+
+  return NUM2INT(size);
+}
+
+int io_close_callback(void * ctx) {
+  return 0;
+}
+
+void init_nokogiri_io() {
+  id_read = rb_intern("read");
+  id_write = rb_intern("write");
+}

data/ext/nokogiri/xml_io.h

@@ -0,0 +1,11 @@
+#ifndef NOKOGIRI_XML_IO
+#define NOKOGIRI_XML_IO
+
+#include <nokogiri.h>
+
+int io_read_callback(void * ctx, char * buffer, int len);
+int io_write_callback(void * ctx, char * buffer, int len);
+int io_close_callback(void * ctx);
+void init_nokogiri_io();
+
+#endif

data/ext/nokogiri/xml_libxml2_hacks.c

@@ -0,0 +1,112 @@
+#ifndef HAVE_XMLFIRSTELEMENTCHILD
+#include <libxml/tree.h>
+/**
+ * xmlFirstElementChild:
+ * @parent: the parent node
+ *
+ * Finds the first child node of that element which is a Element node
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the first element child or NULL if not available
+ */
+xmlNodePtr
+xmlFirstElementChild(xmlNodePtr parent) {
+    xmlNodePtr cur = NULL;
+
+    if (parent == NULL)
+        return(NULL);
+    switch (parent->type) {
+        case XML_ELEMENT_NODE:
+        case XML_ENTITY_NODE:
+        case XML_DOCUMENT_NODE:
+        case XML_HTML_DOCUMENT_NODE:
+            cur = parent->children;
+            break;
+        default:
+            return(NULL);
+    }
+    while (cur != NULL) {
+        if (cur->type == XML_ELEMENT_NODE)
+            return(cur);
+        cur = cur->next;
+    }
+    return(NULL);
+}
+
+/**
+ * xmlNextElementSibling:
+ * @node: the current node
+ *
+ * Finds the first closest next sibling of the node which is an
+ * element node.
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the next element sibling or NULL if not available
+ */
+xmlNodePtr
+xmlNextElementSibling(xmlNodePtr node) {
+    if (node == NULL)
+        return(NULL);
+    switch (node->type) {
+        case XML_ELEMENT_NODE:
+        case XML_TEXT_NODE:
+        case XML_CDATA_SECTION_NODE:
+        case XML_ENTITY_REF_NODE:
+        case XML_ENTITY_NODE:
+        case XML_PI_NODE:
+        case XML_COMMENT_NODE:
+        case XML_DTD_NODE:
+        case XML_XINCLUDE_START:
+        case XML_XINCLUDE_END:
+            node = node->next;
+            break;
+        default:
+            return(NULL);
+    }
+    while (node != NULL) {
+        if (node->type == XML_ELEMENT_NODE)
+            return(node);
+        node = node->next;
+    }
+    return(NULL);
+}
+
+/**
+ * xmlLastElementChild:
+ * @parent: the parent node
+ *
+ * Finds the last child node of that element which is a Element node
+ * Note the handling of entities references is different than in
+ * the W3C DOM element traversal spec since we don't have back reference
+ * from entities content to entities references.
+ *
+ * Returns the last element child or NULL if not available
+ */
+xmlNodePtr
+xmlLastElementChild(xmlNodePtr parent) {
+    xmlNodePtr cur = NULL;
+
+    if (parent == NULL)
+        return(NULL);
+    switch (parent->type) {
+        case XML_ELEMENT_NODE:
+        case XML_ENTITY_NODE:
+        case XML_DOCUMENT_NODE:
+        case XML_HTML_DOCUMENT_NODE:
+            cur = parent->last;
+            break;
+        default:
+            return(NULL);
+    }
+    while (cur != NULL) {
+        if (cur->type == XML_ELEMENT_NODE)
+            return(cur);
+        cur = cur->prev;
+    }
+    return(NULL);
+}
+#endif

data/ext/nokogiri/xml_libxml2_hacks.h

@@ -0,0 +1,12 @@
+#ifndef HAVE_XMLFIRSTELEMENTCHILD
+
+#ifndef XML_LIBXML2_HACKS
+#define XML_LIBXML2_HACKS
+
+xmlNodePtr xmlFirstElementChild(xmlNodePtr parent);
+xmlNodePtr xmlNextElementSibling(xmlNodePtr node);
+xmlNodePtr xmlLastElementChild(xmlNodePtr parent);
+
+#endif
+
+#endif

data/ext/nokogiri/xml_namespace.c

@@ -0,0 +1,117 @@
+#include <xml_namespace.h>
+
+VALUE cNokogiriXmlNamespace ;
+
+static void dealloc_namespace(xmlNsPtr ns)
+{
+  /*
+   *
+   * this deallocator is only used for namespace nodes that are part of an xpath
+   * node set.
+   *
+   * see Nokogiri_wrap_xml_namespace() for more details.
+   *
+   */
+  NOKOGIRI_DEBUG_START(ns) ;
+  if (ns->href) {
+    xmlFree((xmlChar *)ns->href);
+  }
+  if (ns->prefix) {
+    xmlFree((xmlChar *)ns->prefix);
+  }
+  xmlFree(ns);
+  NOKOGIRI_DEBUG_END(ns) ;
+}
+
+
+int Nokogiri_namespace_eh(xmlNodePtr node)
+{
+  return (node->type == XML_NAMESPACE_DECL);
+}
+
+
+/*
+ * call-seq:
+ *  prefix
+ *
+ * Get the prefix for this namespace.  Returns +nil+ if there is no prefix.
+ */
+static VALUE prefix(VALUE self)
+{
+  xmlNsPtr ns;
+
+  Data_Get_Struct(self, xmlNs, ns);
+  if(!ns->prefix) return Qnil;
+
+  return NOKOGIRI_STR_NEW2(ns->prefix);
+}
+
+/*
+ * call-seq:
+ *  href
+ *
+ * Get the href for this namespace
+ */
+static VALUE href(VALUE self)
+{
+  xmlNsPtr ns;
+
+  Data_Get_Struct(self, xmlNs, ns);
+  if(!ns->href) return Qnil;
+
+  return NOKOGIRI_STR_NEW2(ns->href);
+}
+
+static int part_of_an_xpath_node_set_eh(xmlNsPtr node)
+{
+  return (node->next && ! Nokogiri_namespace_eh(node->next));
+}
+
+VALUE Nokogiri_wrap_xml_namespace(xmlDocPtr doc, xmlNsPtr node)
+{
+  VALUE ns, document, node_cache;
+
+  assert(doc->type == XML_DOCUMENT_NODE || doc->type == XML_HTML_DOCUMENT_NODE);
+
+  if (node->_private) return (VALUE)node->_private;
+
+  if (doc->type == XML_DOCUMENT_FRAG_NODE) doc = doc->doc;
+
+  ns = Data_Wrap_Struct(cNokogiriXmlNamespace, 0, 0, node);
+
+  if (DOC_RUBY_OBJECT_TEST(doc)) {
+    document = DOC_RUBY_OBJECT(doc);
+
+    if (part_of_an_xpath_node_set_eh(node)) {
+      /*
+       *  this is a duplicate returned as part of an xpath query node set, and so
+       *  we need to make sure we manage this memory.
+       *
+       *  see comments in xml_node_set.c for more details.
+       */
+      ns = Data_Wrap_Struct(cNokogiriXmlNamespace, 0, dealloc_namespace, node);
+    } else {
+      ns = Data_Wrap_Struct(cNokogiriXmlNamespace, 0, 0, node);
+      node_cache = rb_iv_get(document, "@node_cache");
+      rb_ary_push(node_cache, ns);
+    }
+
+    rb_iv_set(ns, "@document", document);
+  }
+
+  node->_private = (void *)ns;
+
+  return ns;
+}
+
+void init_xml_namespace()
+{
+  VALUE nokogiri  = rb_define_module("Nokogiri");
+  VALUE xml       = rb_define_module_under(nokogiri, "XML");
+  VALUE klass     = rb_define_class_under(xml, "Namespace", rb_cObject);
+
+  cNokogiriXmlNamespace = klass;
+
+  rb_define_method(klass, "prefix", prefix, 0);
+  rb_define_method(klass, "href", href, 0);
+}

data/ext/nokogiri/xml_namespace.h

@@ -0,0 +1,13 @@
+#ifndef NOKOGIRI_XML_NAMESPACE
+#define NOKOGIRI_XML_NAMESPACE
+
+#include <nokogiri.h>
+
+void init_xml_namespace();
+
+extern VALUE cNokogiriXmlNamespace ;
+
+VALUE Nokogiri_wrap_xml_namespace(xmlDocPtr doc, xmlNsPtr node) ;
+VALUE Nokogiri_wrap_xml_namespace2(VALUE document, xmlNsPtr node) ;
+
+#endif