nokogiri 1.2.3-x86-mswin32-60 → 1.4.5-x86-mswin32-60

data/ext/nokogiri/xml_node.h

@@ -1,15 +1,13 @@
 #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 ;
 
-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

@@ -1,6 +1,8 @@
 #include <xml_node_set.h>
 #include <libxml/xpathInternals.h>
 
+static ID decorate ;
+
 /*
  * call-seq:
  *  dup
@@ -10,15 +12,13 @@
 static VALUE duplicate(VALUE self)
 {
   xmlNodeSetPtr node_set;
+  xmlNodeSetPtr dupl;
+
   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]);
-  }
+  dupl = xmlXPathNodeSetMerge(NULL, node_set);
 
-  return Nokogiri_wrap_xml_node_set(dupl);
+  return Nokogiri_wrap_xml_node_set(dupl, rb_iv_get(self, "@document"));
 }
 
 /*
@@ -49,8 +49,8 @@ static VALUE push(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");
+  if(!(rb_obj_is_kind_of(rb_node, cNokogiriXmlNode) || rb_obj_is_kind_of(rb_node, cNokogiriXmlNamespace)))
+    rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");
 
   Data_Get_Struct(self, xmlNodeSet, node_set);
   Data_Get_Struct(rb_node, xmlNode, node);
@@ -58,27 +58,218 @@ 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_obj_is_kind_of(rb_node, cNokogiriXmlNode) || rb_obj_is_kind_of(rb_node, cNokogiriXmlNamespace)))
+    rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");
+
+  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_obj_is_kind_of(rb_other, 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), rb_iv_get(self, "@document"));
+}
 
-  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_obj_is_kind_of(rb_node, cNokogiriXmlNode) || rb_obj_is_kind_of(rb_node, cNokogiriXmlNamespace)))
+    rb_raise(rb_eArgError, "node must be a Nokogiri::XML::Node or Nokogiri::XML::Namespace");
+
+  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)
+ *
+ * Returns a new set built by merging the set and the elements of the given
+ * set.
+ */
+static VALUE set_union(VALUE self, VALUE rb_other)
+{
+  xmlNodeSetPtr node_set;
+  xmlNodeSetPtr other;
+  xmlNodeSetPtr new;
+
+  if(!rb_obj_is_kind_of(rb_other, 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, rb_iv_get(self, "@document"));
+}
+
+/*
+ * 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_obj_is_kind_of(rb_other, 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, rb_iv_get(self, "@document"));
+}
+
+
+static VALUE index_at(VALUE self, long offset)
+{
+  xmlNodeSetPtr node_set;
+  Data_Get_Struct(self, xmlNodeSet, node_set);
+
+  if(offset >= node_set->nodeNr || abs((int)offset) > node_set->nodeNr) return Qnil;
+  if(offset < 0) offset = offset + node_set->nodeNr;
+
+  if (XML_NAMESPACE_DECL == node_set->nodeTab[offset]->type)
+    return Nokogiri_wrap_xml_namespace2(rb_iv_get(self, "@document"), (xmlNsPtr)(node_set->nodeTab[offset]));
+  return Nokogiri_wrap_xml_node(Qnil, node_set->nodeTab[offset]);
+}
+
+static VALUE subseq(VALUE self, long beg, long len)
+{
+  long 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 ;
+
+  if ((beg + len) > node_set->nodeNr) {
+    len = node_set->nodeNr - beg ;
+  }
+
+  new_set = xmlXPathNodeSetCreate(NULL);
+  for (j = beg ; j < beg+len ; ++j) {
+    xmlXPathNodeSetAddUnique(new_set, node_set->nodeTab[j]);
+  }
+  return Nokogiri_wrap_xml_node_set(new_set, rb_iv_get(self, "@document"));
+}
+
+/*
+ * 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, (long)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
@@ -88,21 +279,33 @@ static VALUE index_at(VALUE self, VALUE number)
 static VALUE to_array(VALUE self, VALUE rb_node)
 {
   xmlNodeSetPtr set;
+  VALUE *elts;
+  VALUE list;
+  int i;
+
   Data_Get_Struct(self, xmlNodeSet, set);
 
-  VALUE *elts = calloc((size_t)set->nodeNr, sizeof(VALUE *));
-  int i;
+  elts = calloc((size_t)set->nodeNr, sizeof(VALUE *));
   for(i = 0; i < set->nodeNr; i++) {
-    if(set->nodeTab[i]->_private) {
-      elts[i] = (VALUE)set->nodeTab[i]->_private;
+    if (XML_NAMESPACE_DECL == set->nodeTab[i]->type) {
+      elts[i] = Nokogiri_wrap_xml_namespace2(rb_iv_get(self, "@document"), (xmlNsPtr)(set->nodeTab[i]));
     } else {
-      elts[i] = Nokogiri_wrap_xml_node(set->nodeTab[i]);
+      xmlNodePtr node = set->nodeTab[i];
+
+      if(node->_private) {
+        if(node->type == XML_DOCUMENT_NODE || node->type == XML_HTML_DOCUMENT_NODE)
+          elts[i] = DOC_RUBY_OBJECT(node->doc);
+        else
+          elts[i] = (VALUE)node->_private;
+      } else {
+        elts[i] = Nokogiri_wrap_xml_node(Qnil, node);
+      }
     }
   }
 
-  VALUE list = rb_ary_new4(set->nodeNr, elts);
+  list = rb_ary_new4((long)set->nodeNr, elts);
 
-  free(elts);
+  /*free(elts); */
 
   return list;
 }
@@ -121,12 +324,14 @@ static VALUE unlink_nodeset(VALUE self)
   Data_Get_Struct(self, xmlNodeSet, node_set);
   nodeNr = node_set->nodeNr ;
   for (j = 0 ; j < nodeNr ; j++) {
-    VALUE node ;
-    xmlNodePtr node_ptr;
-    node = Nokogiri_wrap_xml_node(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 ;
+    if (XML_NAMESPACE_DECL != node_set->nodeTab[j]->type) {
+      VALUE node ;
+      xmlNodePtr node_ptr;
+      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 ;
+    }
   }
   return self ;
 }
@@ -173,12 +378,18 @@ static void deallocate(xmlNodeSetPtr node_set)
 
 static VALUE allocate(VALUE klass)
 {
-  return Nokogiri_wrap_xml_node_set(xmlXPathNodeSetCreate(NULL));
+  return Nokogiri_wrap_xml_node_set(xmlXPathNodeSetCreate(NULL), Qnil);
 }
 
-VALUE Nokogiri_wrap_xml_node_set(xmlNodeSetPtr node_set)
+VALUE Nokogiri_wrap_xml_node_set(xmlNodeSetPtr node_set, VALUE document)
 {
-  return Data_Wrap_Struct(cNokogiriXmlNodeSet, 0, deallocate, node_set);
+  VALUE new_set ;
+  new_set = Data_Wrap_Struct(cNokogiriXmlNodeSet, 0, deallocate, node_set);
+  if (document != Qnil) {
+    rb_iv_set(new_set, "@document", document);
+    rb_funcall(document, decorate, 1, new_set);
+  }
+  return new_set ;
 }
 
 VALUE cNokogiriXmlNodeSet ;
@@ -191,9 +402,17 @@ 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, "|", set_union, 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", duplicate, 0);
+  rb_define_method(klass, "delete", delete, 1);
+  rb_define_method(klass, "&", intersection, 1);
+  rb_define_method(klass, "include?", include_eh, 1);
+
+  decorate      = rb_intern("decorate");
 }

data/ext/nokogiri/xml_node_set.h

@@ -1,9 +1,9 @@
 #ifndef NOKOGIRI_XML_NODE_SET
 #define NOKOGIRI_XML_NODE_SET
 
-#include <native.h>
+#include <nokogiri.h>
 void init_xml_node_set();
 
 extern VALUE cNokogiriXmlNodeSet ;
-VALUE Nokogiri_wrap_xml_node_set(xmlNodeSetPtr node_set) ;
+VALUE Nokogiri_wrap_xml_node_set(xmlNodeSetPtr node_set, VALUE document) ;
 #endif

data/ext/nokogiri/xml_processing_instruction.c

@@ -7,18 +7,30 @@
  * 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);
+  xmlNodePtr node;
+  VALUE document;
+  VALUE name;
+  VALUE content;
+  VALUE rest;
+  VALUE rb_node;
 
-  xmlNodePtr node = xmlNewDocPI(
+  rb_scan_args(argc, argv, "3*", &document, &name, &content, &rest);
+
+  Data_Get_Struct(document, xmlDoc, xml_doc);
+
+  node = xmlNewDocPI(
       xml_doc,
       (const xmlChar *)StringValuePtr(name),
       (const xmlChar *)StringValuePtr(content)
   );
 
-  VALUE rb_node = Nokogiri_wrap_xml_node(node);
+  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);
 
@@ -40,5 +52,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();