libxml-ruby 0.9.8 → 0.9.9

data/ext/libxml/ruby_xml_input_cbg.h

@@ -1,7 +1,7 @@
 #ifndef _INPUT_CBG_
 #define _INPUT_CBG_
 
-void ruby_init_input_callbacks(void);
+void rxml_init_input_callbacks(void);
 
 typedef struct ic_doc_context {
     char *buffer;

data/ext/libxml/ruby_xml_namespace.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_namespace.c 740 2009-01-23 04:03:11Z cfis $ */
+/* $Id: ruby_xml_namespace.c 758 2009-01-25 20:36:03Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -158,13 +158,7 @@ static VALUE rxml_namespace_next(VALUE self)
     return (rxml_namespace_wrap(xns->next, NULL));
 }
 
-// Rdoc needs to know
-#ifdef RDOC_NEVER_DEFINED
-mLibXML = rb_define_module("LibXML");
-mXML = rb_define_module_under(mLibXML, "XML");
-#endif
-
-void ruby_init_xml_namespace(void)
+void rxml_init_namespace(void)
 {
   cXMLNamespace = rb_define_class_under(mXML, "Namespace", rb_cObject);
   rb_define_alloc_func(cXMLNamespace, rxml_namespace_alloc);

data/ext/libxml/ruby_xml_namespace.h

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_namespace.h 739 2009-01-23 03:42:09Z cfis $ */
+/* $Id: ruby_xml_namespace.h 758 2009-01-25 20:36:03Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -7,6 +7,6 @@
 
 extern VALUE cXMLNamespace;
 
-void ruby_init_xml_namespace(void);
+void rxml_init_namespace(void);
 VALUE rxml_namespace_wrap(xmlNsPtr xns, RUBY_DATA_FUNC freeFunc);
 #endif

data/ext/libxml/ruby_xml_namespaces.c

@@ -277,15 +277,7 @@ static VALUE rxml_namespaces_node_get(VALUE self)
   return rxml_node_wrap(xnode);
 }
 
-
-
-// Rdoc needs to know
-#ifdef RDOC_NEVER_DEFINED
-mLibXML = rb_define_module("LibXML");
-mXML = rb_define_module_under(mLibXML, "XML");
-#endif
-
-void ruby_init_xml_namespaces(void)
+void rxml_init_namespaces(void)
 {
   cXMLNamespaces = rb_define_class_under(mXML, "Namespaces", rb_cObject);
   rb_include_module(cXMLNamespaces, rb_mEnumerable);

data/ext/libxml/ruby_xml_namespaces.h

@@ -7,5 +7,5 @@
 
 extern VALUE cXMLNamespaces;
 
-void ruby_init_xml_namespaces(void);
+void rxml_init_namespaces(void);
 #endif

data/ext/libxml/ruby_xml_node.c

@@ -3,9 +3,6 @@
 
 VALUE cXMLNode;
 
-static VALUE kXMLStringText;
-static VALUE kXMLStringTextNoenc;
-
 /* Document-class: LibXML::XML::Node
  *
  * Nodes are the primary objects that make up an XML document.
@@ -29,23 +26,48 @@ VALUE check_string_or_symbol(VALUE val)
   return rb_obj_as_string(val);
 }
 
-/*
- * memory2 implementation: xmlNode->_private holds a reference
- * to the wrapping ruby object VALUE when there is one.
- * traversal for marking is upward, and top levels are marked
- * through and lower level mark entry.
+/* Memory management:
+ *
+ * The bindings create a one-to-one mapping between libxml nodes
+ * and Ruby nodes.  If a libxml node is wraped, its _private member
+ * is set with a reference to the Ruby object.
  *
- * All ruby retrieval for an xml
- * node will result in the same ruby instance. When all handles to them
- * go out of scope, then ruby_xfree gets called and _private is set to NULL.
- * If the xmlNode has no parent or document, then call xmlFree.
+ * When a libxml document or top level node is freed, it will free
+ * all its children.  Thus Ruby is responsible for:
+ *
+ *  * Using the mark function to keep alive any documents Ruby is
+ *    referencing via the document or child nodes.
+ *  * Using the mark function to keep alive any top level, free
+ *    standing nodes Ruby is referencing via the node or its children.
+ *
+ * Ruby will always set a free function when wrapping a node.  However,
+ * the bindings also register a callback that is invoked by libxml
+ * each time a node is freed.  When the callback is called, the node's
+ * dfree member is set to NULL since Ruby no longer should free the node.
  */
+
+void rxml_node_deregisterNode(xmlNodePtr xnode)
+{
+  /* Has the node been wrapped and exposed to Ruby? */
+  if (xnode->_private)
+  {
+    /* Node was wrapped.  Set the _private member to free and
+      then dislabe the dfree function so that Ruby will not
+      try to free the node a second time. */
+    VALUE node = (VALUE) xnode->_private;
+    RDATA(node)->dfree = NULL;
+    xnode->_private = NULL;
+  }
+}
+
 void rxml_node_free(xmlNodePtr xnode)
 {
-  /* Set _private to NULL so that we won't reuse the
-   same, freed, Ruby wrapper object later.*/
+  /* The Ruby object that wraps the node no longer exists. */
   xnode->_private = NULL;
 
+  /* Only free nodes that are stand-alone, top level nodes.
+     If a node belongs to a document, or a parent node, then
+     the document or parent node will free thsi node. */
   if (xnode->doc == NULL && xnode->parent == NULL)
     xmlFreeNode(xnode);
 }
@@ -96,6 +118,9 @@ VALUE rxml_node_wrap(xmlNodePtr xnode)
   }
   else
   {
+    /* Assume Ruby is responsible for freeing this node.  If libxml frees it
+       instead, the rxml_node_deregisterNode callback is executed, and
+       we set the free function to NULL. */
     VALUE node = Data_Wrap_Struct(cXMLNode, rxml_node_mark, rxml_node_free, xnode);
     xnode->_private = (void*) node;
     return node;
@@ -104,6 +129,7 @@ VALUE rxml_node_wrap(xmlNodePtr xnode)
 
 static VALUE rxml_node_alloc(VALUE klass)
 {
+  /* Ruby is responsible for freeing this node not libxml. */
   return Data_Wrap_Struct(klass, rxml_node_mark, rxml_node_free, NULL);
 }
 
@@ -381,34 +407,26 @@ static VALUE rxml_node_first_get(VALUE self)
  * underlying for child_set and child_add, difference being
  * former raises on implicit copy, latter does not.
  */
-static VALUE rxml_node_child_set_aux(VALUE self, VALUE rnode)
+static VALUE rxml_node_child_set_aux(VALUE self, VALUE child)
 {
-  xmlNodePtr pnode, chld, ret;
+  xmlNodePtr xnode, xchild, xresult;
 
-  if (rb_obj_is_kind_of(rnode, cXMLNode) == Qfalse)
+  if (rb_obj_is_kind_of(child, cXMLNode) == Qfalse)
     rb_raise(rb_eTypeError, "Must pass an XML::Node object");
 
-  Data_Get_Struct(self, xmlNode, pnode);
-  Data_Get_Struct(rnode, xmlNode, chld);
+  Data_Get_Struct(self, xmlNode, xnode);
+  Data_Get_Struct(child, xmlNode, xchild);
 
-  if (chld->parent != NULL || chld->doc != NULL)
-    rb_raise(
-        rb_eRuntimeError,
-        "Cannot move a node from one document to another with child= or <<.  First copy the node before moving it.");
+  if (xchild->parent != NULL || xchild->doc != NULL)
+    rb_raise(rb_eRuntimeError,
+            "Cannot move a node from one document to another with child= or <<.  First copy the node before moving it.");
 
-  ret = xmlAddChild(pnode, chld);
-  if (ret == NULL)
-  {
+  xresult = xmlAddChild(xnode, xchild);
+
+  if (!xresult)
     rxml_raise(&xmlLastError);
-  }
-  else if (ret == chld)
-  {
-    /* child was added whole to parent and we need to return it as a new object */
-    return rxml_node_wrap(chld);
-  }
-  /* else */
-  /* If it was a text node, then ret should be parent->last, so we will just return ret. */
-  return rxml_node_wrap(ret);
+
+  return rxml_node_wrap(xresult);
 }
 
 /*
@@ -603,15 +621,19 @@ static VALUE rxml_node_to_s(int argc, VALUE *argv, VALUE self)
 static VALUE rxml_node_each(VALUE self)
 {
   xmlNodePtr xnode;
-  xmlNodePtr xchild;
+  xmlNodePtr xcurrent;
   Data_Get_Struct(self, xmlNode, xnode);
 
-  xchild = xnode->children;
+  xcurrent = xnode->children;
 
-  while (xchild)
+  while (xcurrent)
   {
-    rb_yield(rxml_node_wrap(xchild));
-    xchild = xchild->next;
+    /* The user could remove this node, so first stache
+       away the next node. */
+    xmlNodePtr xnext = xcurrent->next;
+
+    rb_yield(rxml_node_wrap(xcurrent));
+    xcurrent = xnext;
   }
   return Qnil;
 }
@@ -868,10 +890,6 @@ static VALUE rxml_node_name_get(VALUE self)
 
   if (xnode->name == NULL)
     return (Qnil);
-	else if (name == xmlStringText)
-		return (kXMLStringText);
-	else if (name == xmlStringTextNoenc)
-		return (kXMLStringTextNoenc);
   else
     return (rb_str_new2((const char*) name));
 }
@@ -891,14 +909,9 @@ static VALUE rxml_node_name_set(VALUE self, VALUE name)
   Data_Get_Struct(self, xmlNode, xnode);
   xname = (const xmlChar*)StringValuePtr(name);
 
-	if (xnode->type != XML_TEXT_NODE)
-  	xmlNodeSetName(xnode, xname);
-	else if (xname == xmlStringText)			/* compare addresses instead of string contents. */
-		xnode->name = xmlStringText;
-	else if (xname == xmlStringTextNoenc)	/* compare addresses instead of string contents. */
-		xnode->name = xmlStringTextNoenc;
-
 	/* Note: calling xmlNodeSetName() for a text node is ignored by libXML. */
+  xmlNodeSetName(xnode, xname);
+
   return (Qtrue);
 }
 
@@ -926,21 +939,21 @@ static VALUE rxml_node_next_get(VALUE self)
  *
  * Insert the specified node as this node's next sibling.
  */
-static VALUE rxml_node_next_set(VALUE self, VALUE rnode)
+static VALUE rxml_node_next_set(VALUE self, VALUE next)
 {
-  xmlNodePtr cnode, pnode, ret;
+  xmlNodePtr xnode, xnext, xresult;
 
-  if (rb_obj_is_kind_of(rnode, cXMLNode) == Qfalse)
+  if (rb_obj_is_kind_of(next, cXMLNode) == Qfalse)
     rb_raise(rb_eTypeError, "Must pass an XML::Node object");
 
-  Data_Get_Struct(self, xmlNode, pnode);
-  Data_Get_Struct(rnode, xmlNode, cnode);
+  Data_Get_Struct(self, xmlNode, xnode);
+  Data_Get_Struct(next, xmlNode, xnext);
 
-  ret = xmlAddNextSibling(pnode, cnode);
-  if (ret == NULL)
+  xresult = xmlAddNextSibling(xnode, xnext);
+  if (xresult == NULL)
     rxml_raise(&xmlLastError);
 
-  return (rxml_node_wrap(ret));
+  return rxml_node_wrap(xresult);
 }
 
 /*
@@ -1037,21 +1050,21 @@ static VALUE rxml_node_prev_get(VALUE self)
  *
  * Insert the specified node as this node's previous sibling.
  */
-static VALUE rxml_node_prev_set(VALUE self, VALUE rnode)
+static VALUE rxml_node_prev_set(VALUE self, VALUE prev)
 {
-  xmlNodePtr cnode, pnode, ret;
+  xmlNodePtr xnode, xprev, xresult;
 
-  if (rb_obj_is_kind_of(rnode, cXMLNode) == Qfalse)
+  if (rb_obj_is_kind_of(prev, cXMLNode) == Qfalse)
     rb_raise(rb_eTypeError, "Must pass an XML::Node object");
 
-  Data_Get_Struct(self, xmlNode, pnode);
-  Data_Get_Struct(rnode, xmlNode, cnode);
+  Data_Get_Struct(self, xmlNode, xnode);
+  Data_Get_Struct(prev, xmlNode, xprev);
 
-  ret = xmlAddPrevSibling(pnode, cnode);
-  if (ret == NULL)
+  xresult = xmlAddPrevSibling(xnode, xprev);
+  if (xresult == NULL)
     rxml_raise(&xmlLastError);
 
-  return (rxml_node_wrap(ret));
+  return rxml_node_wrap(xresult);
 }
 
 /*
@@ -1108,8 +1121,10 @@ static VALUE rxml_node_remove_ex(VALUE self)
 {
   xmlNodePtr xnode;
   Data_Get_Struct(self, xmlNode, xnode);
+
   /* Unlink the node from its parent. */
   xmlUnlinkNode(xnode);
+
   /* Now set the nodes parent to nil so it can
    be freed if the reference to it goes out of scope*/
   xmlSetTreeDoc(xnode, NULL);
@@ -1125,27 +1140,111 @@ static VALUE rxml_node_remove_ex(VALUE self)
  *
  * Add the specified node as a sibling of this node.
  */
-static VALUE rxml_node_sibling_set(VALUE self, VALUE rnode)
+static VALUE rxml_node_sibling_set(VALUE self, VALUE sibling)
 {
-  xmlNodePtr cnode, pnode, ret;
-  VALUE obj;
+  xmlNodePtr xnode, xsibling, xresult;
 
-  if (rb_obj_is_kind_of(rnode, cXMLNode) == Qfalse)
+  if (rb_obj_is_kind_of(sibling, cXMLNode) == Qfalse)
     rb_raise(rb_eTypeError, "Must pass an XML::Node object");
 
-  Data_Get_Struct(self, xmlNode, pnode);
-  Data_Get_Struct(rnode, xmlNode, cnode);
+  Data_Get_Struct(self, xmlNode, xnode);
+  Data_Get_Struct(sibling, xmlNode, xsibling);
 
-  ret = xmlAddSibling(pnode, cnode);
-  if (ret == NULL)
+  xresult = xmlAddSibling(xnode, xsibling);
+  if (xresult == NULL)
     rxml_raise(&xmlLastError);
 
-  if (ret->_private == NULL)
-    obj = rxml_node_wrap(ret);
-  else
-    obj = (VALUE) ret->_private;
+  return rxml_node_wrap(xresult);
+}
 
-  return obj;
+/*
+ * call-seq:
+ *    text_node.output_escaping?      -> (true|false)
+ *    element_node.output_escaping?   -> (true|false|nil)
+ *    attribute_node.output_escaping? -> (true|false|nil)
+ *    other_node.output_escaping?     -> (nil)
+ *
+ * Determine whether this node escapes it's output or not.
+ *
+ * Text nodes return only +true+ or +false+.  Element and attribute nodes
+ * examine their immediate text node children to determine the value.
+ * Any other type of node always returns +nil+.
+ *
+ * If an element or attribute node has at least one immediate child text node 
+ * and all the immediate text node children have the same +output_escaping?+
+ * value, that value is returned.  Otherwise, +nil+ is returned.
+ */
+static VALUE rxml_node_output_escaping_q(VALUE self)
+{
+  xmlNodePtr xnode;
+  Data_Get_Struct(self, xmlNode, xnode);
+
+  switch (xnode->type) {
+  case XML_TEXT_NODE:
+    return xnode->name==xmlStringTextNoenc ? Qfalse : Qtrue;
+  case XML_ELEMENT_NODE:
+  case XML_ATTRIBUTE_NODE:
+    {
+      xmlNodePtr tmp = xnode->children;
+      const xmlChar *match = NULL;
+
+      /* Find the first text node and use it as the reference. */
+      while (tmp && tmp->type != XML_TEXT_NODE)
+        tmp = tmp->next;
+      if (! tmp)
+        return Qnil;
+      match = tmp->name;
+
+      /* Walk the remaining text nodes until we run out or one doesn't match. */
+      while (tmp && (tmp->type != XML_TEXT_NODE || match == tmp->name))
+        tmp = tmp->next;
+
+      /* We're left with either the mismatched node or the aggregate result. */
+      return tmp ? Qnil : (match==xmlStringTextNoenc ? Qfalse : Qtrue);
+    }
+    break;
+  default:
+    return Qnil;
+  }
+}
+
+/*
+ * call-seq:
+ *    text_node.output_escaping = true|false
+ *    element_node.output_escaping = true|false
+ *    attribute_node.output_escaping = true|false
+ *
+ * Controls whether this text node or the immediate text node children of an
+ * element or attribute node escapes their output.  Any other type of node
+ * will simply ignore this operation.
+ *
+ * Text nodes which are added to an element or attribute node will be affected
+ * by any previous setting of this property.
+ */
+static VALUE rxml_node_output_escaping_set(VALUE self, VALUE bool)
+{
+  xmlNodePtr xnode;
+  Data_Get_Struct(self, xmlNode, xnode);
+
+  switch (xnode->type) {
+  case XML_TEXT_NODE:
+    xnode->name = (bool!=Qfalse && bool!=Qnil) ? xmlStringText : xmlStringTextNoenc;
+    break;
+  case XML_ELEMENT_NODE:
+  case XML_ATTRIBUTE_NODE:
+    {
+      const xmlChar *name = (bool!=Qfalse && bool!=Qnil) ? xmlStringText : xmlStringTextNoenc;
+      xmlNodePtr tmp;
+      for (tmp = xnode->children; tmp; tmp = tmp->next)
+        if (tmp->type == XML_TEXT_NODE)
+          tmp->name = name;
+    }
+    break;
+  default:
+    return Qnil;
+  }
+
+  return (bool!=Qfalse && bool!=Qnil) ? Qtrue : Qfalse;
 }
 
 /*
@@ -1219,47 +1318,10 @@ static VALUE rxml_node_copy(VALUE self, VALUE deep)
     return Qnil;
 }
 
-void rxml_node_registerNode(xmlNodePtr node)
-{
-  node->_private = NULL;
-}
-
-void rxml_node_deregisterNode(xmlNodePtr xnode)
-{
-  VALUE node;
-
-  if (xnode->_private == NULL)
-    return;
-  node = (VALUE) xnode->_private;
-  DATA_PTR( node) = NULL;
-}
-
-// Rdoc needs to know
-#ifdef RDOC_NEVER_DEFINED
-mLibXML = rb_define_module("LibXML");
-mXML = rb_define_module_under(mLibXML, "XML");
-#endif
-
-static VALUE rxml_constant_stringref(const xmlChar *ptr)
-{
-  VALUE str = rb_str_new("", 0);
-  FL_SET(str, ELTS_SHARED | FL_USER3);
-  xfree(RSTRING_PTR(str));
-  RSTRING_PTR(str) = (void*)ptr;
-  RSTRING_LEN(str) = strlen(ptr);
-  RSTRING(str)->aux.capa = 0;
-  OBJ_FREEZE(str);
-  return str;
-}
-
-void ruby_init_xml_node(void)
+void rxml_init_node(void)
 {
-  xmlRegisterNodeDefault(rxml_node_registerNode);
   xmlDeregisterNodeDefault(rxml_node_deregisterNode);
 
-  kXMLStringText = rxml_constant_stringref(xmlStringText);
-  kXMLStringTextNoenc = rxml_constant_stringref(xmlStringTextNoenc);
-
   cXMLNode = rb_define_class_under(mXML, "Node", rb_cObject);
 
   rb_define_const(cXMLNode, "SPACE_DEFAULT", INT2NUM(0));
@@ -1304,9 +1366,6 @@ void ruby_init_xml_node(void)
   rb_define_const(cXMLNode, "DOCB_DOCUMENT_NODE", Qnil);
 #endif
 
-  rb_define_const(cXMLNode, "XML_STRING_TEXT", kXMLStringText);
-  rb_define_const(cXMLNode, "XML_STRING_TEXT_NOENC", kXMLStringTextNoenc);
-
   rb_define_singleton_method(cXMLNode, "new_cdata", rxml_node_new_cdata, -1);
   rb_define_singleton_method(cXMLNode, "new_comment", rxml_node_new_comment, -1);
   rb_define_singleton_method(cXMLNode, "new_text", rxml_node_new_text, 1);
@@ -1353,6 +1412,8 @@ void ruby_init_xml_node(void)
   rb_define_method(cXMLNode, "name", rxml_node_name_get, 0);
   rb_define_method(cXMLNode, "name=", rxml_node_name_set, 1);
   rb_define_method(cXMLNode, "node_type", rxml_node_type, 0);
+  rb_define_method(cXMLNode, "output_escaping?", rxml_node_output_escaping_q, 0);
+  rb_define_method(cXMLNode, "output_escaping=", rxml_node_output_escaping_set, 1);
   rb_define_method(cXMLNode, "path", rxml_node_path, 0);
   rb_define_method(cXMLNode, "pointer", rxml_node_pointer, 1);
   rb_define_method(cXMLNode, "remove!", rxml_node_remove_ex, 0);