nokogiri 1.2.3 → 1.3.0

data/ext/nokogiri/xml_node.h

@@ -1,15 +1,14 @@
 #ifndef NOKOGIRI_XML_NODE
 #define NOKOGIRI_XML_NODE
 
-#include <native.h>
+#include <nokogiri.h>
 
 void init_xml_node();
-VALUE Nokogiri_wrap_xml_node(xmlNodePtr root);
 
 extern VALUE cNokogiriXmlNode ;
 extern VALUE cNokogiriXmlElement ;
+extern VALUE cNokogiriXmlEntityDeclaration ;
 
-VALUE Nokogiri_wrap_xml_node(xmlNodePtr node) ;
+VALUE Nokogiri_wrap_xml_node(VALUE klass, xmlNodePtr node) ;
 void Nokogiri_xml_node_properties(xmlNodePtr node, VALUE attr_hash) ;
-void Nokogiri_xml_node_namespaces(xmlNodePtr node, VALUE attr_hash) ;
 #endif

data/ext/nokogiri/xml_node_set.c

@@ -7,16 +7,12 @@
  *
  * Duplicate this node set
  */
-static VALUE dup(VALUE self)
+static VALUE duplicate(VALUE self)
 {
   xmlNodeSetPtr node_set;
   Data_Get_Struct(self, xmlNodeSet, node_set);
 
-  xmlNodeSetPtr dupl = xmlXPathNodeSetCreate(NULL);
-  int i;
-  for(i = 0; i < node_set->nodeNr; i++) {
-    xmlXPathNodeSetAdd(dupl, node_set->nodeTab[i]);
-  }
+  xmlNodeSetPtr dupl = xmlXPathNodeSetMerge(NULL, node_set);
 
   return Nokogiri_wrap_xml_node_set(dupl);
 }
@@ -58,27 +54,212 @@ static VALUE push(VALUE self, VALUE rb_node)
   return self;
 }
 
+/*
+ *  call-seq:
+ *    delete(node)
+ *
+ *  Delete +node+ from the Nodeset, if it is a member. Returns the deleted node
+ *  if found, otherwise returns nil.
+ */
+static VALUE delete(VALUE self, VALUE rb_node)
+{
+  xmlNodeSetPtr node_set ;
+  xmlNodePtr node ;
+
+  if(! rb_funcall(rb_node, rb_intern("is_a?"), 1, cNokogiriXmlNode))
+    rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node");
+  
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(rb_node, xmlNode, node);
+
+  if (xmlXPathNodeSetContains(node_set, node)) {
+    xmlXPathNodeSetDel(node_set, node);
+    return rb_node ;
+  }
+
+  return Qnil ;
+}
+
+
 /*
  * call-seq:
- *  [](i)
+ *  &(node_set)
  *
- * Get the node at index +i+
+ * Set Intersection — Returns a new NodeSet containing nodes common to the two NodeSets.
  */
-static VALUE index_at(VALUE self, VALUE number)
+static VALUE intersection(VALUE self, VALUE rb_other)
 {
-  int i = NUM2INT(number);
   xmlNodeSetPtr node_set;
+  xmlNodeSetPtr other;
+
+  if(! rb_funcall(rb_other, rb_intern("is_a?"), 1, cNokogiriXmlNodeSet))
+    rb_raise(rb_eArgError, "node_set must be a Nokogiri::XML::NodeSet");
+
   Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(rb_other, xmlNodeSet, other);
 
-  if(i >= node_set->nodeNr || abs(i) > node_set->nodeNr)
-    return Qnil;
+  return Nokogiri_wrap_xml_node_set(xmlXPathIntersection(node_set, other));
+}
 
-  if(i < 0)
-    i = i + node_set->nodeNr;
 
-  return Nokogiri_wrap_xml_node(node_set->nodeTab[i]);
+/*
+ * call-seq:
+ *  include?(node)
+ *
+ *  Returns true if any member of node set equals +node+.
+ */
+static VALUE include_eh(VALUE self, VALUE rb_node)
+{
+  xmlNodeSetPtr node_set;
+  xmlNodePtr node;
+
+  if(! rb_funcall(rb_node, rb_intern("is_a?"), 1, cNokogiriXmlNode))
+    rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node");
+
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(rb_node, xmlNode, node);
+
+  return (xmlXPathNodeSetContains(node_set, node) ? Qtrue : Qfalse);
 }
 
+
+/*
+ * call-seq:
+ *  +(node_set)
+ *
+ *  Concatenation - returns a new NodeSet built by concatenating the node set
+ *  with +node_set+ to produce a third NodeSet
+ */
+static VALUE plus(VALUE self, VALUE rb_other)
+{
+  xmlNodeSetPtr node_set;
+  xmlNodeSetPtr other;
+  xmlNodeSetPtr new;
+
+  if(! rb_funcall(rb_other, rb_intern("is_a?"), 1, cNokogiriXmlNodeSet))
+    rb_raise(rb_eArgError, "node_set must be a Nokogiri::XML::NodeSet");
+
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(rb_other, xmlNodeSet, other);
+
+  new = xmlXPathNodeSetMerge(NULL, node_set);
+  new = xmlXPathNodeSetMerge(new, other);
+
+  return Nokogiri_wrap_xml_node_set(new);
+}
+
+/*
+ * call-seq:
+ *  -(node_set)
+ *
+ *  Difference - returns a new NodeSet that is a copy of this NodeSet, removing
+ *  each item that also appears in +node_set+
+ */
+static VALUE minus(VALUE self, VALUE rb_other)
+{
+  xmlNodeSetPtr node_set;
+  xmlNodeSetPtr other;
+  xmlNodeSetPtr new;
+  int j ;
+
+  if(! rb_funcall(rb_other, rb_intern("is_a?"), 1, cNokogiriXmlNodeSet))
+    rb_raise(rb_eArgError, "node_set must be a Nokogiri::XML::NodeSet");
+
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+  Data_Get_Struct(rb_other, xmlNodeSet, other);
+
+  new = xmlXPathNodeSetMerge(NULL, node_set);
+  for (j = 0 ; j < other->nodeNr ; ++j) {
+    xmlXPathNodeSetDel(new, other->nodeTab[j]);
+  }
+
+  return Nokogiri_wrap_xml_node_set(new);
+}
+
+
+static VALUE index_at(VALUE self, long offset)
+{
+  xmlNodeSetPtr node_set;
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+
+  if(offset >= node_set->nodeNr || abs(offset) > node_set->nodeNr) return Qnil;
+  if(offset < 0) offset = offset + node_set->nodeNr;
+
+  return Nokogiri_wrap_xml_node(Qnil, node_set->nodeTab[offset]);
+}
+
+static VALUE subseq(VALUE self, long beg, long len)
+{
+  int j;
+  xmlNodeSetPtr node_set;
+  xmlNodeSetPtr new_set ;
+
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+
+  if (beg > node_set->nodeNr) return Qnil ;
+  if (beg < 0 || len < 0) return Qnil ;
+
+  new_set = xmlXPathNodeSetCreate(NULL);
+  for (j = beg ; j < beg+len ; ++j) {
+    xmlXPathNodeSetAdd(new_set, node_set->nodeTab[j]);
+  }
+  return Nokogiri_wrap_xml_node_set(new_set);
+}
+
+/*
+ * call-seq:
+ *  [index] -> Node or nil
+ *  [start, length] -> NodeSet or nil
+ *  [range] -> NodeSet or nil
+ *  slice(index) -> Node or nil
+ *  slice(start, length) -> NodeSet or nil
+ *  slice(range) -> NodeSet or nil
+ *
+ * Element reference - returns the node at +index+, or returns a NodeSet
+ * containing nodes starting at +start+ and continuing for +length+ elements, or
+ * returns a NodeSet containing nodes specified by +range+. Negative +indices+
+ * count backward from the end of the +node_set+ (-1 is the last node). Returns
+ * nil if the +index+ (or +start+) are out of range.
+ */
+static VALUE slice(int argc, VALUE *argv, VALUE self)
+{
+  VALUE arg ;
+  long beg, len ;
+  xmlNodeSetPtr node_set;
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+
+  if (argc == 2) {
+    beg = NUM2LONG(argv[0]);
+    len = NUM2LONG(argv[1]);
+    if (beg < 0) {
+      beg += node_set->nodeNr ;
+    }
+    return subseq(self, beg, len);
+  }
+
+  if (argc != 1) {
+    rb_scan_args(argc, argv, "11", NULL, NULL);
+  }
+  arg = argv[0];
+
+  if (FIXNUM_P(arg)) {
+    return index_at(self, FIX2LONG(arg));
+  }
+  
+  /* if arg is Range */
+  switch (rb_range_beg_len(arg, &beg, &len, node_set->nodeNr, 0)) {
+  case Qfalse:
+    break;
+  case Qnil:
+    return Qnil;
+  default:
+    return subseq(self, beg, len);
+  }
+
+  return index_at(self, NUM2LONG(arg));
+}
+
+
 /*
  * call-seq:
  *  to_a
@@ -96,7 +277,7 @@ static VALUE to_array(VALUE self, VALUE rb_node)
     if(set->nodeTab[i]->_private) {
       elts[i] = (VALUE)set->nodeTab[i]->_private;
     } else {
-      elts[i] = Nokogiri_wrap_xml_node(set->nodeTab[i]);
+      elts[i] = Nokogiri_wrap_xml_node(Qnil, set->nodeTab[i]);
     }
   }
 
@@ -123,7 +304,7 @@ static VALUE unlink_nodeset(VALUE self)
   for (j = 0 ; j < nodeNr ; j++) {
     VALUE node ;
     xmlNodePtr node_ptr;
-    node = Nokogiri_wrap_xml_node(node_set->nodeTab[j]);
+    node = Nokogiri_wrap_xml_node(Qnil, node_set->nodeTab[j]);
     rb_funcall(node, rb_intern("unlink"), 0); /* modifies the C struct out from under the object */
     Data_Get_Struct(node, xmlNode, node_ptr);
     node_set->nodeTab[j] = node_ptr ;
@@ -191,9 +372,15 @@ void init_xml_node_set(void)
 
   rb_define_alloc_func(klass, allocate);
   rb_define_method(klass, "length", length, 0);
-  rb_define_method(klass, "[]", index_at, 1);
+  rb_define_method(klass, "[]", slice, -1);
+  rb_define_method(klass, "slice", slice, -1);
   rb_define_method(klass, "push", push, 1);
+  rb_define_method(klass, "+", plus, 1);
+  rb_define_method(klass, "-", minus, 1);
   rb_define_method(klass, "unlink", unlink_nodeset, 0);
   rb_define_method(klass, "to_a", to_array, 0);
-  rb_define_method(klass, "dup", dup, 0);
+  rb_define_method(klass, "dup", duplicate, 0);
+  rb_define_method(klass, "delete", delete, 1);
+  rb_define_method(klass, "&", intersection, 1);
+  rb_define_method(klass, "include?", include_eh, 1);
 }

data/ext/nokogiri/xml_node_set.h

@@ -1,7 +1,7 @@
 #ifndef NOKOGIRI_XML_NODE_SET
 #define NOKOGIRI_XML_NODE_SET
 
-#include <native.h>
+#include <nokogiri.h>
 void init_xml_node_set();
 
 extern VALUE cNokogiriXmlNodeSet ;

data/ext/nokogiri/xml_processing_instruction.c

@@ -7,10 +7,17 @@
  * Create a new ProcessingInstruction element on the +document+ with +name+
  * and +content+
  */
-static VALUE new(VALUE klass, VALUE doc, VALUE name, VALUE content)
+static VALUE new(int argc, VALUE *argv, VALUE klass)
 {
   xmlDocPtr xml_doc;
-  Data_Get_Struct(doc, xmlDoc, xml_doc);
+  VALUE document;
+  VALUE name;
+  VALUE content;
+  VALUE rest;
+
+  rb_scan_args(argc, argv, "3*", &document, &name, &content, &rest);
+
+  Data_Get_Struct(document, xmlDoc, xml_doc);
 
   xmlNodePtr node = xmlNewDocPI(
       xml_doc,
@@ -18,7 +25,10 @@ static VALUE new(VALUE klass, VALUE doc, VALUE name, VALUE content)
       (const xmlChar *)StringValuePtr(content)
   );
 
-  VALUE rb_node = Nokogiri_wrap_xml_node(node);
+  NOKOGIRI_ROOT_NODE(node);
+
+  VALUE rb_node = Nokogiri_wrap_xml_node(klass, node);
+  rb_funcall2(rb_node, rb_intern("initialize"), argc, argv);
 
   if(rb_block_given_p()) rb_yield(rb_node);
 
@@ -40,5 +50,5 @@ void init_xml_processing_instruction()
 
   cNokogiriXmlProcessingInstruction = klass;
 
-  rb_define_singleton_method(klass, "new", new, 3);
+  rb_define_singleton_method(klass, "new", new, -1);
 }

data/ext/nokogiri/xml_processing_instruction.h

@@ -1,7 +1,7 @@
 #ifndef NOKOGIRI_XML_PROCESSING_INSTRUCTION
 #define NOKOGIRI_XML_PROCESSING_INSTRUCTION
 
-#include <native.h>
+#include <nokogiri.h>
 
 void init_xml_processing_instruction();
 

data/ext/nokogiri/xml_reader.c

@@ -25,6 +25,46 @@ static int has_attributes(xmlTextReaderPtr reader)
   return(0);
 }
 
+#define XMLNS_PREFIX "xmlns"
+#define XMLNS_PREFIX_LEN 6 /* including either colon or \0 */
+#define XMLNS_BUFFER_LEN 128
+static void Nokogiri_xml_node_namespaces(xmlNodePtr node, VALUE attr_hash)
+{
+  xmlNsPtr ns;
+  static char buffer[XMLNS_BUFFER_LEN] ;
+  char *key ;
+  size_t keylen ;
+
+  if (node->type != XML_ELEMENT_NODE) return ;
+
+  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,
+        NOKOGIRI_STR_NEW2(key, node->doc->encoding),
+        (ns->href ? NOKOGIRI_STR_NEW2(ns->href, node->doc->encoding) : Qnil)
+    );
+    if (key != buffer) {
+      free(key);
+    }
+    ns = ns->next ;
+  }
+}
+
+
 /*
  * call-seq:
  *   default?
@@ -127,11 +167,8 @@ static VALUE attribute_nodes(VALUE self)
   // at this document, but I have to because of the assertions in
   // the node wrapping code.
   if(! DOC_RUBY_OBJECT_TEST(ptr->doc)) {
-    VALUE rb_doc = Data_Wrap_Struct(cNokogiriXmlDocument, 0, 0, ptr->doc);
-    ptr->doc->_private = malloc(sizeof(nokogiriTuple));
-    rb_iv_set(rb_doc, "@decorators", Qnil);
-    ((nokogiriTuplePtr)(ptr->doc->_private))->doc = (void *)rb_doc;
-    ((nokogiriTuplePtr)(ptr->doc->_private))->unlinkedNodes = xmlXPathNodeSetCreate(NULL);
+    VALUE rb_doc = Nokogiri_wrap_xml_document(cNokogiriXmlDocument, ptr->doc);
+    RDATA(rb_doc)->dfree = NULL;
   }
   VALUE enc = rb_iv_get(self, "@encoding");
 
@@ -430,7 +467,7 @@ static VALUE from_memory(int argc, VALUE *argv, VALUE klass)
 
   rb_scan_args(argc, argv, "13", &rb_buffer, &rb_url, &encoding, &rb_options);
 
-  rb_buffer = StringValue(rb_buffer) ;
+  if (!RTEST(rb_buffer)) rb_raise(rb_eArgError, "string cannot be nil");
   if (RTEST(rb_url)) c_url = StringValuePtr(rb_url);
   if (RTEST(encoding)) c_encoding = StringValuePtr(encoding);
   if (RTEST(rb_options)) c_options = NUM2INT(rb_options);
@@ -449,7 +486,48 @@ static VALUE from_memory(int argc, VALUE *argv, VALUE klass)
   }
 
   VALUE rb_reader = Data_Wrap_Struct(klass, NULL, dealloc, reader);
-  rb_funcall(rb_reader, rb_intern("initialize"), 2, rb_url, encoding);
+  rb_funcall(rb_reader, rb_intern("initialize"), 3, rb_buffer, rb_url, encoding);
+
+  return rb_reader;
+}
+
+/*
+ * call-seq:
+ *   from_io(io, url = nil, encoding = nil, options = 0)
+ *
+ * Create a new reader that parses +io+
+ */
+static VALUE from_io(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE rb_io, rb_url, encoding, rb_options;
+
+  const char * c_url      = NULL;
+  const char * c_encoding = NULL;
+  int c_options           = 0; 
+
+  rb_scan_args(argc, argv, "13", &rb_io, &rb_url, &encoding, &rb_options);
+
+  if (!RTEST(rb_io)) rb_raise(rb_eArgError, "io cannot be nil");
+  if (RTEST(rb_url)) c_url = StringValuePtr(rb_url);
+  if (RTEST(encoding)) c_encoding = StringValuePtr(encoding);
+  if (RTEST(rb_options)) c_options = NUM2INT(rb_options);
+
+  xmlTextReaderPtr reader = xmlReaderForIO(
+      (xmlInputReadCallback)io_read_callback,
+      (xmlInputCloseCallback)io_close_callback,
+      (void *)rb_io,
+      c_url,
+      c_encoding,
+      c_options
+  );
+
+  if(reader == NULL) {
+    xmlFreeTextReader(reader);
+    rb_raise(rb_eRuntimeError, "couldn't create a parser");
+  }
+
+  VALUE rb_reader = Data_Wrap_Struct(klass, NULL, dealloc, reader);
+  rb_funcall(rb_reader, rb_intern("initialize"), 3, rb_io, rb_url, encoding);
 
   return rb_reader;
 }
@@ -471,6 +549,8 @@ void init_xml_reader()
   cNokogiriXmlReader = klass;
 
   rb_define_singleton_method(klass, "from_memory", from_memory, -1);
+  rb_define_singleton_method(klass, "from_io", from_io, -1);
+
   rb_define_method(klass, "read", read_more, 0);
   rb_define_method(klass, "state", state, 0);
   rb_define_method(klass, "name", name, 0);