nokogiri 1.1.1 → 1.2.0

data/ext/nokogiri/xml_document_fragment.c

@@ -0,0 +1,38 @@
+#include <xml_document_fragment.h>
+
+/*
+ * call-seq:
+ *  new(document)
+ *
+ * Create a new DocumentFragment element on the +document+
+ */
+static VALUE new(VALUE klass, VALUE doc)
+{
+  xmlDocPtr xml_doc;
+  Data_Get_Struct(doc, xmlDoc, xml_doc);
+
+  xmlNodePtr node = xmlNewDocFragment(xml_doc);
+
+  VALUE rb_node = Nokogiri_wrap_xml_node(node);
+
+  if(rb_block_given_p()) rb_yield(rb_node);
+
+  return rb_node;
+}
+
+VALUE cNokogiriXmlDocumentFragment;
+void init_xml_document_fragment()
+{
+  VALUE nokogiri = rb_define_module("Nokogiri");
+  VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
+
+  /*
+   * DocumentFragment represents a DocumentFragment node in an xml document.
+   */
+  VALUE klass = rb_define_class_under(xml, "DocumentFragment", node);
+
+  cNokogiriXmlDocumentFragment = klass;
+
+  rb_define_singleton_method(klass, "new", new, 1);
+}

data/ext/nokogiri/xml_document_fragment.h

@@ -0,0 +1,10 @@
+#ifndef NOKOGIRI_XML_DOCUMENT_FRAGMENT
+#define NOKOGIRI_XML_DOCUMENT_FRAGMENT
+
+#include <native.h>
+
+void init_xml_document_fragment();
+
+extern VALUE cNokogiriXmlDocumentFragment;
+#endif
+

data/ext/nokogiri/xml_dtd.c

@@ -44,26 +44,6 @@ static VALUE entities(VALUE self)
   return hash;
 }
 
-/*
- * call-seq:
- *   attributes
- *
- * Get a hash of the attributes for this DTD.
- */
-static VALUE attributes(VALUE self)
-{
-  xmlDtdPtr dtd;
-  Data_Get_Struct(self, xmlDtd, dtd);
-
-  if(!dtd->attributes) return Qnil;
-
-  VALUE hash = rb_hash_new();
-
-  xmlHashScan((xmlHashTablePtr)dtd->attributes, element_copier, (void *)hash);
-
-  return hash;
-}
-
 /*
  * call-seq:
  *   notations
@@ -108,14 +88,14 @@ void init_xml_dtd()
 {
   VALUE nokogiri = rb_define_module("Nokogiri");
   VALUE xml = rb_define_module_under(nokogiri, "XML");
+  VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
 
   /*
    * Nokogiri::XML::DTD wraps DTD nodes in an XML document
    */
-  VALUE klass = rb_define_class_under(xml, "DTD", cNokogiriXmlNode);
+  VALUE klass = rb_define_class_under(xml, "DTD", node);
 
   rb_define_method(klass, "notations", notations, 0);
   rb_define_method(klass, "elements", elements, 0);
-  rb_define_method(klass, "attributes", attributes, 0);
   rb_define_method(klass, "entities", entities, 0);
 }

data/ext/nokogiri/xml_entity_reference.c

@@ -0,0 +1,41 @@
+#include <xml_entity_reference.h>
+
+/*
+ * call-seq:
+ *  new(document, content)
+ *
+ * Create a new EntityReference element on the +document+ with +name+
+ */
+static VALUE new(VALUE klass, VALUE doc, VALUE name)
+{
+  xmlDocPtr xml_doc;
+  Data_Get_Struct(doc, xmlDoc, xml_doc);
+
+  xmlNodePtr node = xmlNewReference(
+      xml_doc,
+      (const xmlChar *)StringValuePtr(name)
+  );
+
+  VALUE rb_node = Nokogiri_wrap_xml_node(node);
+
+  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, 2);
+}

data/ext/nokogiri/xml_entity_reference.h

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

data/ext/nokogiri/xml_io.c

@@ -5,11 +5,18 @@ int io_read_callback(void * ctx, char * buffer, int len) {
   VALUE string = rb_funcall(io, rb_intern("read"), 1, INT2NUM(len));
 
   if(Qnil == string) return 0;
-  VALUE length = rb_funcall(string, rb_intern("length"), 0);
 
-  memcpy(buffer, StringValuePtr(string), (unsigned int)NUM2INT(length));
+  memcpy(buffer, StringValuePtr(string), (unsigned int)RSTRING_LEN(string));
 
-  return NUM2INT(length);
+  return RSTRING_LEN(string);
+}
+
+int io_write_callback(void * ctx, char * buffer, int len) {
+  VALUE io = (VALUE)ctx;
+  VALUE string = rb_str_new(buffer, len);
+
+  rb_funcall(io, rb_intern("write"), 1, string);
+  return len;
 }
 
 int io_close_callback(void * ctx) {

data/ext/nokogiri/xml_io.h

@@ -4,6 +4,7 @@
 #include <native.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);
 
 #endif

data/ext/nokogiri/xml_node.c

@@ -84,12 +84,8 @@ static VALUE duplicate_node(int argc, VALUE *argv, VALUE self)
   xmlNodePtr node, dup;
   Data_Get_Struct(self, xmlNode, node);
 
-  dup = xmlCopyNode(node, NUM2INT(level));
+  dup = xmlDocCopyNode(node, node->doc, NUM2INT(level));
   if(dup == NULL) return Qnil;
-  dup->doc = node->doc;
-  assert(node->parent);
-
-  xmlAddChild(node->parent, dup);
 
   return Nokogiri_wrap_xml_node(dup);
 }
@@ -211,9 +207,13 @@ static VALUE set(VALUE self, VALUE property, VALUE value)
 {
   xmlNodePtr node;
   Data_Get_Struct(self, xmlNode, node);
-  xmlSetProp(node, (xmlChar *)StringValuePtr(property),
+
+  xmlChar *buffer = xmlEncodeEntitiesReentrant(node->doc,
       (xmlChar *)StringValuePtr(value));
 
+  xmlSetProp(node, (xmlChar *)StringValuePtr(property), buffer);
+  xmlFree(buffer);
+
   return value;
 }
 
@@ -229,12 +229,35 @@ static VALUE get(VALUE self, VALUE attribute)
   xmlChar* propstr ;
   VALUE rval ;
   Data_Get_Struct(self, xmlNode, node);
+
+  if(attribute == Qnil) return Qnil;
+
   propstr = xmlGetProp(node, (xmlChar *)StringValuePtr(attribute));
+
+  if(NULL == propstr) return Qnil;
+
   rval = rb_str_new2((char *)propstr) ;
   xmlFree(propstr);
   return rval ;
 }
 
+/*
+ * call-seq:
+ *   attribute(name)
+ *
+ * Get the attribute node with +name+
+ */
+static VALUE attr(VALUE self, VALUE name)
+{
+  xmlNodePtr node;
+  xmlAttrPtr prop;
+  Data_Get_Struct(self, xmlNode, node);
+  prop = xmlHasProp(node, (xmlChar *)StringValuePtr(name));
+
+  if(! prop) return Qnil;
+  return Nokogiri_wrap_xml_node((xmlNodePtr)prop);
+}
+
 /*
  *  call-seq:
  *    attribute_nodes()
@@ -293,11 +316,11 @@ static VALUE namespaces(VALUE self)
 
 /*
  * call-seq:
- *  type
+ *  node_type
  *
- * Get the type for this node
+ * Get the type for this Node
  */
-static VALUE type(VALUE self)
+static VALUE node_type(VALUE self)
 {
   xmlNodePtr node;
   Data_Get_Struct(self, xmlNode, node);
@@ -479,55 +502,72 @@ static VALUE add_previous_sibling(VALUE self, VALUE rb_node)
 
 /*
  * call-seq:
- *  to_html
+ *  native_write_to(io, encoding, options)
  *
- * Returns this node as HTML
+ * Write this Node to +io+ with +encoding+ and +options+
  */
-static VALUE to_html(VALUE self)
+static VALUE native_write_to(VALUE self, VALUE io, VALUE encoding, VALUE options)
 {
-  xmlBufferPtr buf ;
-  xmlNodePtr node ;
+  xmlNodePtr node;
+
   Data_Get_Struct(self, xmlNode, node);
 
-  VALUE html;
+  xmlSaveCtxtPtr savectx = xmlSaveToIO(
+      (xmlOutputWriteCallback)io_write_callback,
+      (xmlOutputCloseCallback)io_close_callback,
+      (void *)io,
+      RTEST(encoding) ? StringValuePtr(encoding) : NULL,
+      NUM2INT(options)
+  );
 
-  if(node->doc->type == XML_DOCUMENT_NODE)
-    return rb_funcall(self, rb_intern("to_xml"), 0);
+  xmlSaveTree(savectx, node);
+  xmlSaveClose(savectx);
+  return io;
+}
 
-  buf = xmlBufferCreate() ;
-  htmlNodeDump(buf, node->doc, node);
-  html = rb_str_new2((char*)buf->content);
-  xmlBufferFree(buf);
-  return html ;
+/*
+ * call-seq:
+ *  line
+ *
+ * Returns the line for this Node
+ */
+static VALUE line(VALUE self)
+{
+  xmlNodePtr node;
+  Data_Get_Struct(self, xmlNode, node);
+
+  return INT2NUM(node->line);
 }
 
 /*
  * call-seq:
- *  to_xml
+ *  add_namespace(prefix, href)
  *
- * Returns this node as XML
+ * Add a namespace with +prefix+ using +href+
  */
-static VALUE to_xml(int argc, VALUE *argv, VALUE self)
+static VALUE add_namespace(VALUE self, VALUE prefix, VALUE href)
 {
-  xmlBufferPtr buf ;
-  xmlNodePtr node ;
-  VALUE xml, level;
+  xmlNodePtr node;
+  Data_Get_Struct(self, xmlNode, node);
 
-  if(rb_scan_args(argc, argv, "01", &level) == 0)
-    level = INT2NUM(1);
+  xmlNsPtr ns = xmlNewNs(
+      node,
+      (const xmlChar *)StringValuePtr(href),
+      (const xmlChar *)StringValuePtr(prefix)
+  );
 
-  Check_Type(level, T_FIXNUM);
+  if(NULL == ns) return self;
 
-  Data_Get_Struct(self, xmlNode, node);
+  xmlNewNsProp(
+      node,
+      ns,
+      (const xmlChar *)StringValuePtr(href),
+      (const xmlChar *)StringValuePtr(prefix)
+  );
 
-  buf = xmlBufferCreate() ;
-  xmlNodeDump(buf, node->doc, node, 2, NUM2INT(level));
-  xml = rb_str_new2((char*)buf->content);
-  xmlBufferFree(buf);
-  return xml ;
+  return self;
 }
 
-
 /*
  * call-seq:
  *   new(name)
@@ -550,30 +590,28 @@ static VALUE new(VALUE klass, VALUE name, VALUE document)
   return rb_node;
 }
 
-
 /*
  * call-seq:
- *   new_from_str(string)
+ *  dump_html
  *
- * Create a new node by parsing +string+
+ * Returns the Node as html.
  */
-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 ;
+static VALUE dump_html(VALUE self)
+{
+  xmlBufferPtr buf ;
+  xmlNodePtr node ;
+  Data_Get_Struct(self, xmlNode, 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 */
-    node->doc = doc;
+  VALUE html;
 
-    return Nokogiri_wrap_xml_node(node);
+  if(node->doc->type == XML_DOCUMENT_NODE)
+    return rb_funcall(self, rb_intern("to_xml"), 0);
+
+  buf = xmlBufferCreate() ;
+  htmlNodeDump(buf, node->doc, node);
+  html = rb_str_new2((char*)buf->content);
+  xmlBufferFree(buf);
+  return html ;
 }
 
 VALUE Nokogiri_wrap_xml_node(xmlNodePtr node)
@@ -598,16 +636,28 @@ VALUE Nokogiri_wrap_xml_node(xmlNodePtr node)
       klass = rb_const_get(mNokogiriXml, rb_intern("Text"));
       rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
       break;
+    case XML_ENTITY_REF_NODE:
+      klass = cNokogiriXmlEntityReference;
+      rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
+      break;
     case XML_COMMENT_NODE:
       klass = cNokogiriXmlComment;
       rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
       break;
+    case XML_DOCUMENT_FRAG_NODE:
+      klass = cNokogiriXmlDocumentFragment;
+      rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
+      break;
+    case XML_PI_NODE:
+      klass = cNokogiriXmlProcessingInstruction;
+      rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
+      break;
     case XML_ELEMENT_NODE:
       klass = rb_const_get(mNokogiriXml, rb_intern("Element"));
       rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
       break;
     case XML_ATTRIBUTE_NODE:
-      klass = rb_const_get(mNokogiriXml, rb_intern("Attr"));
+      klass = cNokogiriXmlAttr;
       rb_node = Data_Wrap_Struct(klass, 0, debug_node_dealloc, node) ;
       break;
     case XML_ENTITY_DECL:
@@ -684,43 +734,43 @@ void Nokogiri_xml_node_namespaces(xmlNodePtr node, VALUE attr_hash)
 VALUE cNokogiriXmlNode ;
 void init_xml_node()
 {
-  /*
   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"));
+  cNokogiriXmlNode = klass;
 
   rb_define_singleton_method(klass, "new", new, 2);
-  rb_define_singleton_method(klass, "new_from_str", new_from_str, 1);
 
-  rb_define_method(klass, "name", get_name, 0);
-  rb_define_method(klass, "name=", set_name, 1);
+  rb_define_method(klass, "add_namespace", add_namespace, 2);
+  rb_define_method(klass, "node_name", get_name, 0);
+  rb_define_method(klass, "node_name=", set_name, 1);
   rb_define_method(klass, "add_child", add_child, 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, "type", type, 0);
+  rb_define_method(klass, "node_type", node_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, "attribute_nodes", attribute_nodes, 0);
+  rb_define_method(klass, "attribute", attr, 1);
   rb_define_method(klass, "namespace", namespace, 0);
   rb_define_method(klass, "namespaces", namespaces, 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, -1);
-  rb_define_method(klass, "to_html", to_html, 0);
   rb_define_method(klass, "dup", duplicate_node, -1);
   rb_define_method(klass, "unlink", unlink_node, 0);
   rb_define_method(klass, "internal_subset", internal_subset, 0);
   rb_define_method(klass, "pointer_id", pointer_id, 0);
+  rb_define_method(klass, "line", line, 0);
 
+  rb_define_private_method(klass, "dump_html", dump_html, 0);
+  rb_define_private_method(klass, "native_write_to", native_write_to, 3);
   rb_define_private_method(klass, "replace_with_node", replace, 1);
   rb_define_private_method(klass, "native_content=", set_content, 1);
   rb_define_private_method(klass, "get", get, 1);