tenderlove-nokogiri 0.0.0.20081001111445

data/ext/nokogiri/xml_cdata.c

@@ -0,0 +1,36 @@
+#include <xml_cdata.h>
+
+static void dealloc(xmlNodePtr node)
+{
+  if(node->doc == NULL) xmlFreeNode(node);
+}
+
+static VALUE new(VALUE klass, VALUE doc, VALUE content)
+{
+  xmlDocPtr xml_doc;
+  Data_Get_Struct(doc, xmlDoc, xml_doc);
+
+  xmlNodePtr node = xmlNewCDataBlock(
+      xml_doc,
+      (const xmlChar *)StringValuePtr(content),
+      NUM2INT(rb_funcall(content, rb_intern("length"), 0))
+  );
+
+  VALUE rb_node = Data_Wrap_Struct(klass, NULL, dealloc, node);
+  node->_private = (void *)rb_node;
+
+  if(rb_block_given_p()) rb_yield(rb_node);
+
+  return rb_node;
+}
+
+VALUE cNokogiriXmlCData;
+void init_xml_cdata()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE klass = rb_define_class_under(xml, "CData", cNokogiriXmlNode);
+  cNokogiriXmlCData = klass;
+
+  rb_define_singleton_method(klass, "new", new, 2);
+}

data/ext/nokogiri/xml_cdata.h

@@ -0,0 +1,9 @@
+#ifndef NOKOGIRI_XML_CDATA
+#define NOKOGIRI_XML_CDATA
+
+#include <native.h>
+
+void init_xml_cdata();
+
+extern VALUE cNokogiriXmlCData;
+#endif

data/ext/nokogiri/xml_document.c

@@ -0,0 +1,159 @@
+#include <xml_document.h>
+
+/*
+ *  note that xmlDocPtr is being cast as an xmlNodePtr, which is legal for the
+ *  "common part" struct header which contains only node pointers. casting like
+ *  this allows us to recurse through the tree with a single function.
+ */
+static void gc_mark(xmlNodePtr doc)
+{
+  xmlNodePtr j ;
+  j = doc->children ;
+  while (j != NULL) {
+    if (j->_private)
+      rb_gc_mark((VALUE)j->_private);
+    gc_mark(j); /* recurse */
+    j = j->next ;
+  }
+}
+
+static void dealloc(xmlDocPtr doc)
+{
+  xmlFreeDoc(doc);
+}
+
+/*
+ * call-seq:
+ *  serialize
+ *
+ * Serialize this document
+ */
+static VALUE serialize(VALUE self)
+{
+  xmlDocPtr doc;
+  xmlChar *buf;
+  int size;
+  Data_Get_Struct(self, xmlDoc, doc);
+
+  xmlDocDumpMemory(doc, &buf, &size);
+  VALUE rb_str = rb_str_new((char *)buf, (long)size);
+  free(buf);
+  return rb_str;
+}
+
+/*
+ * call-seq:
+ *  root=
+ *
+ * Set the root element on this document
+ */
+static VALUE set_root(VALUE self, VALUE root)
+{
+  xmlDocPtr doc;
+  xmlNodePtr new_root;
+
+  Data_Get_Struct(self, xmlDoc, doc);
+  Data_Get_Struct(root, xmlNode, new_root);
+
+  xmlDocSetRootElement(doc, new_root);
+  return root;
+}
+
+/*
+ * call-seq:
+ *  root
+ *
+ * Get the root node for this document.
+ */
+static VALUE root(VALUE self)
+{
+  xmlDocPtr doc;
+  Data_Get_Struct(self, xmlDoc, doc);
+
+  xmlNodePtr root = xmlDocGetRootElement(doc);
+
+  if(!root) return Qnil;
+  return Nokogiri_wrap_xml_node(root) ;
+}
+
+static VALUE read_memory( VALUE klass,
+                          VALUE string,
+                          VALUE url,
+                          VALUE encoding,
+                          VALUE options )
+{
+  const char * c_buffer = StringValuePtr(string);
+  const char * c_url    = (url == Qnil) ? NULL : StringValuePtr(url);
+  const char * c_enc    = (encoding == Qnil) ? NULL : StringValuePtr(encoding);
+  int len               = RSTRING(string)->len ;
+
+  xmlInitParser();
+  xmlDocPtr doc = xmlReadMemory(c_buffer, len, c_url, c_enc, NUM2INT(options));
+
+  if(doc == NULL) {
+    xmlFreeDoc(doc);
+    rb_raise(rb_eRuntimeError, "Couldn't create a document");
+  }
+
+  return Nokogiri_wrap_xml_document(klass, doc);
+}
+
+static VALUE new(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE version;
+  if(rb_scan_args(argc, argv, "01", &version) == 0)
+    version = rb_str_new2("1.0");
+
+  xmlDocPtr doc = xmlNewDoc((xmlChar *)StringValuePtr(version));
+  return Nokogiri_wrap_xml_document(klass, doc);
+}
+
+/*
+ *  call-seq:
+ *    substitute_entities_set bool)
+ *
+ *  Set the global XML default for substitute entities.
+ */
+static VALUE substitute_entities_set(VALUE klass, VALUE value)
+{
+    xmlSubstituteEntitiesDefault(NUM2INT(value));
+    return Qnil ;
+}
+
+/*
+ *  call-seq:
+ *    substitute_entities_set bool)
+ *
+ *  Set the global XML default for load external subsets.
+ */
+static VALUE load_external_subsets_set(VALUE klass, VALUE value)
+{
+    xmlLoadExtDtdDefaultValue = NUM2INT(value);
+    return Qnil ;
+}
+
+VALUE cNokogiriXmlDocument ;
+void init_xml_document()
+{
+  VALUE klass = cNokogiriXmlDocument = rb_const_get(mNokogiriXml, rb_intern("Document"));
+
+  rb_define_singleton_method(klass, "read_memory", read_memory, 4);
+  rb_define_singleton_method(klass, "new", new, -1);
+  rb_define_singleton_method(klass, "substitute_entities=", substitute_entities_set, 1);
+  rb_define_singleton_method(klass, "load_external_subsets=", load_external_subsets_set, 1);
+
+  rb_define_method(klass, "root", root, 0);
+  rb_define_method(klass, "root=", set_root, 1);
+  rb_define_method(klass, "serialize", serialize, 0);
+}
+
+
+/* this takes klass as a param because it's used for HtmlDocument, too. */
+VALUE Nokogiri_wrap_xml_document(VALUE klass, xmlDocPtr doc)
+{
+  if (doc->_private)
+    return (VALUE)doc->_private ;
+  VALUE rb_doc = Data_Wrap_Struct(klass ? klass : cNokogiriXmlDocument, gc_mark, dealloc, doc) ;
+  doc->_private = (void*)rb_doc ;
+  return rb_doc ;
+}

data/ext/nokogiri/xml_document.h

@@ -0,0 +1,10 @@
+#ifndef NOKOGIRI_XML_DOCUMENT
+#define NOKOGIRI_XML_DOCUMENT
+
+#include <native.h>
+
+void init_xml_document();
+VALUE Nokogiri_wrap_xml_document(VALUE klass, xmlDocPtr doc);
+
+extern VALUE cNokogiriXmlDocument ;
+#endif

data/ext/nokogiri/xml_node.c

@@ -0,0 +1,573 @@
+#include <xml_node.h>
+
+/*
+ * call-seq:
+ *  encode_special_chars(string)
+ *
+ * Encode any special characters in +string+
+ */
+static VALUE encode_special_chars(VALUE self, VALUE string)
+{
+  xmlNodePtr node;
+  Data_Get_Struct(self, xmlNode, node);
+  xmlChar * encoded = xmlEncodeSpecialChars(
+      node->doc,
+      (const xmlChar *)StringValuePtr(string)
+  );
+
+  VALUE encoded_str = rb_str_new2((const char *)encoded);
+  free(encoded);
+
+  return encoded_str;
+}
+
+/*
+ * call-seq:
+ *  dup
+ *
+ * Copy this node
+ */
+static VALUE dup(VALUE self)
+{
+  xmlNodePtr node, dup;
+  Data_Get_Struct(self, xmlNode, node);
+
+  dup = xmlCopyNode(node, 1);
+  if(dup == NULL) return Qnil;
+
+  return Nokogiri_wrap_xml_node(dup);
+}
+
+/*
+ * call-seq:
+ *  blank?
+ *
+ * Is this node blank?
+ */
+static VALUE blank_eh(VALUE self)
+{
+  xmlNodePtr node;
+  Data_Get_Struct(self, xmlNode, node);
+  if(1 == xmlIsBlankNode(node))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ * call-seq:
+ *  next_sibling
+ *
+ * Returns the next sibling node
+ */
+static VALUE next_sibling(VALUE self)
+{
+  xmlNodePtr node, sibling;
+  Data_Get_Struct(self, xmlNode, node);
+
+  sibling = node->next;
+  if(!sibling) return Qnil;
+
+  return Nokogiri_wrap_xml_node(sibling) ;
+}
+
+/*
+ * call-seq:
+ *  previous_sibling
+ *
+ * Returns the previous sibling node
+ */
+static VALUE previous_sibling(VALUE self)
+{
+  xmlNodePtr node, sibling;
+  Data_Get_Struct(self, xmlNode, node);
+
+  sibling = node->prev;
+  if(!sibling) return Qnil;
+
+  return Nokogiri_wrap_xml_node(sibling);
+}
+
+/*
+ *  call-seq:
+ *    replace(new_node)
+ *
+ *  replace node with the new node in the document.
+ */
+static VALUE replace(VALUE self, VALUE _new_node)
+{
+  xmlNodePtr node, new_node;
+  Data_Get_Struct(self, xmlNode, node);
+  Data_Get_Struct(_new_node, xmlNode, new_node);
+
+  xmlReplaceNode(node, new_node);
+  return self ;
+}
+
+
+/*
+ * call-seq:
+ *  child
+ *
+ * Returns the child node
+ */
+static VALUE child(VALUE self)
+{
+  xmlNodePtr node, child;
+  Data_Get_Struct(self, xmlNode, node);
+
+  child = node->children;
+  if(!child) return Qnil;
+
+  return Nokogiri_wrap_xml_node(child);
+}
+
+/*
+ * call-seq:
+ *  key?(attribute)
+ *
+ * Returns true if +attribute+ is set
+ */
+static VALUE key_eh(VALUE self, VALUE attribute)
+{
+  xmlNodePtr node;
+  Data_Get_Struct(self, xmlNode, node);
+  if(xmlHasProp(node, (xmlChar *)StringValuePtr(attribute)))
+    return Qtrue;
+  return Qfalse;
+}
+
+/*
+ * call-seq:
+ *  []=(property, value)
+ *
+ * Set the +property+ to +value+
+ */
+static VALUE set(VALUE self, VALUE property, VALUE value)
+{
+  xmlNodePtr node;
+  Data_Get_Struct(self, xmlNode, node);
+  xmlSetProp(node, (xmlChar *)StringValuePtr(property),
+      (xmlChar *)StringValuePtr(value));
+
+  return value;
+}
+
+/*
+ *  call-seq:
+ *    remove(property)
+ *
+ *  remove the property +property+
+ */
+static VALUE remove_prop(VALUE self, VALUE property)
+{
+  xmlNodePtr node;
+  xmlAttrPtr attr ;
+  Data_Get_Struct(self, xmlNode, node);
+  attr = xmlHasProp(node, (xmlChar *)StringValuePtr(property));
+  if (attr) { xmlRemoveProp(attr); }
+  return Qnil;
+}
+
+/*
+ * call-seq
+ *   get(attribute)
+ *
+ * Get the value for +attribute+
+ */
+static VALUE get(VALUE self, VALUE attribute)
+{
+  xmlNodePtr node;
+  xmlChar* propstr ;
+  VALUE rval ;
+  Data_Get_Struct(self, xmlNode, node);
+  propstr = xmlGetProp(node, (xmlChar *)StringValuePtr(attribute));
+  rval = rb_str_new2((char *)propstr) ;
+  xmlFree(propstr);
+  return rval ;
+}
+
+/*
+ *  call-seq
+ *    attributes()
+ *
+ *  returns a hash containing the node's attributes.
+ */
+static VALUE attributes(VALUE self)
+{
+    /* this code in the mode of xmlHasProp() */
+    xmlNodePtr node ;
+    VALUE attr ;
+
+    attr = rb_hash_new() ;
+    Data_Get_Struct(self, xmlNode, node);
+
+    Nokogiri_xml_node_properties(node, attr);
+
+    return attr ;
+}
+
+/*
+ * call-seq:
+ *  type
+ *
+ * Get the type for this node
+ */
+static VALUE type(VALUE self)
+{
+  xmlNodePtr node;
+  Data_Get_Struct(self, xmlNode, node);
+  return INT2NUM((int)node->type);
+}
+
+/*
+ * call-seq:
+ *  content=
+ *
+ * Set the content for this Node
+ */
+static VALUE set_content(VALUE self, VALUE content)
+{
+  xmlNodePtr node;
+  Data_Get_Struct(self, xmlNode, node);
+  xmlNodeSetContent(node, (xmlChar *)StringValuePtr(content));
+  return content;
+}
+
+/*
+ * call-seq:
+ *  content
+ *
+ * Returns the content for this Node
+ */
+static VALUE get_content(VALUE self)
+{
+  xmlNodePtr node;
+  Data_Get_Struct(self, xmlNode, node);
+
+  xmlChar * content = xmlNodeGetContent(node);
+  if(content) {
+    VALUE rval = rb_str_new2((char *)content);
+    xmlFree(content);
+    return rval;
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *  parent=(parent_node)
+ *
+ * Set the parent Node for this Node
+ */
+static VALUE set_parent(VALUE self, VALUE parent_node)
+{
+  xmlNodePtr node, parent;
+  Data_Get_Struct(self, xmlNode, node);
+  Data_Get_Struct(parent_node, xmlNode, parent);
+
+  xmlAddChild(parent, node);
+  return parent_node;
+}
+
+/*
+ * call-seq:
+ *  parent
+ *
+ * Get the parent Node for this Node
+ */
+static VALUE get_parent(VALUE self)
+{
+  xmlNodePtr node, parent;
+  Data_Get_Struct(self, xmlNode, node);
+
+  parent = node->parent;
+  if(!parent) return Qnil;
+
+  return Nokogiri_wrap_xml_node(parent) ;
+}
+
+/*
+ * call-seq:
+ *  name=(new_name)
+ *
+ * Set the name for this Node
+ */
+static VALUE set_name(VALUE self, VALUE new_name)
+{
+  xmlNodePtr node;
+  Data_Get_Struct(self, xmlNode, node);
+  xmlNodeSetName(node, (xmlChar*)StringValuePtr(new_name));
+  return new_name;
+}
+
+/*
+ * call-seq:
+ *  name
+ *
+ * Returns the name for this Node
+ */
+static VALUE get_name(VALUE self)
+{
+  xmlNodePtr node;
+  Data_Get_Struct(self, xmlNode, node);
+  return rb_str_new2((const char *)node->name);
+}
+
+/*
+ * call-seq:
+ *  path
+ *
+ * Returns the path associated with this Node
+ */
+static VALUE path(VALUE self)
+{
+  xmlNodePtr node;
+  xmlChar *path ;
+  VALUE rval ;
+  Data_Get_Struct(self, xmlNode, node);
+  
+  path = xmlGetNodePath(node);
+  rval = rb_str_new2((char *)path);
+  xmlFree(path);
+  return rval ;
+}
+
+/*
+ * call-seq:
+ *  document
+ *
+ * Returns the Nokogiri::XML::Document associated with this Node
+ */
+static VALUE document(VALUE self)
+{
+  xmlNodePtr node;
+  Data_Get_Struct(self, xmlNode, node);
+
+  if(!node->doc) return Qnil;
+  return (VALUE)node->doc->_private;
+}
+
+/*
+ *  call-seq:
+ *    add_next_sibling(node)
+ *
+ *  Insert +node+ after this node (as a sibling).
+ */
+static VALUE add_next_sibling(VALUE self, VALUE rb_node)
+{
+  xmlNodePtr node, new_sibling;
+  Data_Get_Struct(self, xmlNode, node);
+  Data_Get_Struct(rb_node, xmlNode, new_sibling);
+  xmlAddNextSibling(node, new_sibling);
+
+  rb_funcall(rb_node, rb_intern("decorate!"), 0);
+
+  return rb_node;
+}
+
+/*
+ * call-seq:
+ *  add_previous_sibling(node)
+ *
+ * Insert +node+ before this node (as a sibling).
+ */
+static VALUE add_previous_sibling(VALUE self, VALUE rb_node)
+{
+  xmlNodePtr node, new_sibling;
+  Data_Get_Struct(self, xmlNode, node);
+  Data_Get_Struct(rb_node, xmlNode, new_sibling);
+  xmlAddPrevSibling(node, new_sibling);
+
+  rb_funcall(rb_node, rb_intern("decorate!"), 0);
+
+  return rb_node;
+}
+
+/*
+ * call-seq:
+ *  to_xml
+ *
+ * Returns this node as XML
+ */
+static VALUE to_xml(VALUE self)
+{
+  xmlBufferPtr buf ;
+  xmlNodePtr node ;
+  VALUE xml ;
+
+  Data_Get_Struct(self, xmlNode, node);
+
+  buf = xmlBufferCreate() ;
+  xmlNodeDump(buf, node->doc, node, 2, 1);
+  xml = rb_str_new2((char*)buf->content);
+  xmlBufferFree(buf);
+  return xml ;
+}
+
+
+/*
+ * call-seq
+ *   new(name, namespace=nil)
+ *
+ * Create a new node with +name+ and options +namespace+
+ */
+static VALUE new(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE name, ns;
+  xmlNsPtr xml_ns = NULL;
+
+  rb_scan_args(argc, argv, "11", &name, &ns);
+
+  if (RTEST(ns))
+    Data_Get_Struct(ns, xmlNs, xml_ns);
+
+  xmlNodePtr node = xmlNewNode(xml_ns, (xmlChar *)StringValuePtr(name));
+  VALUE rb_node = Nokogiri_wrap_xml_node(node) ;
+
+  if(rb_block_given_p()) rb_yield(rb_node);
+
+  return rb_node;
+}
+
+
+/*
+ * call-seq
+ *   new_from_str(string)
+ *
+ * Create a new node by parsing +string+
+ */
+static VALUE new_from_str(VALUE klass, VALUE xml)
+{
+    /*
+     *  I couldn't find a more efficient way to do this. So we create a new
+     *  document and copy (recursively) the root node.
+     */
+    VALUE rb_doc ;
+    xmlDocPtr doc ;
+    xmlNodePtr node ;
+
+    rb_doc = rb_funcall(cNokogiriXmlDocument, rb_intern("read_memory"), 4,
+                        xml, Qnil, Qnil, INT2NUM(0));
+    Data_Get_Struct(rb_doc, xmlDoc, doc);
+    node = xmlCopyNode(xmlDocGetRootElement(doc), 1); /* 1 => recursive */
+    return Nokogiri_wrap_xml_node(node);
+}
+
+static void deallocate(xmlNodePtr node)
+{
+  if (node && !node->doc) {
+    node->_private = NULL;
+    xmlFreeNode(node);
+  }
+}
+
+static void gc_mark_node(xmlNodePtr node)
+{
+  if (node && node->doc && node->doc->_private)
+    rb_gc_mark((VALUE)node->doc->_private);
+}
+
+VALUE Nokogiri_wrap_xml_node(xmlNodePtr node)
+{
+  if (node->_private)
+    return (VALUE)node->_private ;
+  VALUE rb_node = Data_Wrap_Struct(cNokogiriXmlNode, gc_mark_node, deallocate, node) ;
+  node->_private = (void*)rb_node ;
+  rb_funcall(rb_node, rb_intern("decorate!"), 0);
+  return rb_node ;
+}
+
+
+void Nokogiri_xml_node_properties(xmlNodePtr node, VALUE attr_hash)
+{
+  xmlAttrPtr prop;
+  xmlChar* propstr ;
+  prop = node->properties ;
+  while (prop != NULL) {
+    propstr = xmlGetProp(node, prop->name) ;
+    rb_hash_aset(attr_hash, rb_str_new2((const char*)prop->name),
+                 rb_str_new2((char*)propstr));
+    xmlFree(propstr);
+    prop = prop->next ;
+  }
+}
+
+
+#define XMLNS_PREFIX "xmlns"
+#define XMLNS_PREFIX_LEN 6 /* including either colon or \0 */
+#define XMLNS_BUFFER_LEN 128
+void Nokogiri_xml_node_namespaces(xmlNodePtr node, VALUE attr_hash)
+{
+  xmlNsPtr ns;
+  static char buffer[XMLNS_BUFFER_LEN] ;
+  char *key ;
+  size_t keylen ;
+
+  ns = node->nsDef;
+  while (ns != NULL) {
+
+    keylen = XMLNS_PREFIX_LEN + (ns->prefix ? (strlen((const char*)ns->prefix) + 1) : 0) ;
+    if (keylen > XMLNS_BUFFER_LEN) {
+      key = (char*)malloc(keylen) ;
+    } else {
+      key = buffer ;
+    }
+
+    if (ns->prefix) {
+      sprintf(key, "%s:%s", XMLNS_PREFIX, ns->prefix);
+    } else {
+      sprintf(key, "%s", XMLNS_PREFIX);
+    }
+
+    rb_hash_aset(attr_hash, rb_str_new2(key), rb_str_new2((const char*)ns->href)) ;
+    if (key != buffer) {
+      free(key);
+    }
+    ns = ns->next ;
+  }
+}
+
+
+VALUE cNokogiriXmlNode ;
+void init_xml_node()
+{
+  /*
+   * HACK.  This is so that rdoc will work with this C file.
+   */
+  /*
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE klass = rb_define_class_under(xml, "Node", rb_cObject);
+  */
+
+  VALUE klass = cNokogiriXmlNode = rb_const_get(mNokogiriXml, rb_intern("Node"));
+
+  rb_define_singleton_method(klass, "new", new, -1);
+  rb_define_singleton_method(klass, "new_from_str", new_from_str, 1);
+
+  rb_define_method(klass, "document", document, 0);
+  rb_define_method(klass, "name", get_name, 0);
+  rb_define_method(klass, "name=", set_name, 1);
+  rb_define_method(klass, "parent=", set_parent, 1);
+  rb_define_method(klass, "parent", get_parent, 0);
+  rb_define_method(klass, "child", child, 0);
+  rb_define_method(klass, "next_sibling", next_sibling, 0);
+  rb_define_method(klass, "previous_sibling", previous_sibling, 0);
+  rb_define_method(klass, "replace", replace, 1);
+  rb_define_method(klass, "type", type, 0);
+  rb_define_method(klass, "content", get_content, 0);
+  rb_define_method(klass, "path", path, 0);
+  rb_define_method(klass, "key?", key_eh, 1);
+  rb_define_method(klass, "blank?", blank_eh, 0);
+  rb_define_method(klass, "[]=", set, 2);
+  rb_define_method(klass, "remove", remove_prop, 1);
+  rb_define_method(klass, "attributes", attributes, 0);
+  rb_define_method(klass, "add_previous_sibling", add_previous_sibling, 1);
+  rb_define_method(klass, "add_next_sibling", add_next_sibling, 1);
+  rb_define_method(klass, "encode_special_chars", encode_special_chars, 1);
+  rb_define_method(klass, "to_xml", to_xml, 0);
+  rb_define_method(klass, "dup", dup, 0);
+
+  rb_define_private_method(klass, "native_content=", set_content, 1);
+  rb_define_private_method(klass, "get", get, 1);
+}