libxml-ruby 0.8.3-x86-mswin32-60 → 0.9.0-x86-mswin32-60

data/ext/libxml/ruby_xml_xpath.h

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_xpath.h 418 2008-07-14 16:44:59Z cfis $ */
+/* $Id: ruby_xml_xpath.h 528 2008-11-15 23:43:48Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -6,7 +6,6 @@
 #define __RUBY_XML_XPATH__
 
 extern VALUE mXPath;
-extern VALUE eXMLXPathInvalidPath;
 
 typedef struct ruby_xml_xpath {
   VALUE xd;

data/ext/libxml/ruby_xml_xpath_context.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_xpath_context.c 461 2008-07-15 21:35:56Z cfis $ */
+/* $Id: ruby_xml_xpath_context.c 566 2008-11-18 06:53:36Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -50,7 +50,7 @@ ruby_xml_xpath_context_alloc(VALUE klass) {
  */
 VALUE
 ruby_xml_xpath_context_initialize(VALUE self, VALUE node) {
-  ruby_xml_document_t *rxd;
+  xmlDocPtr xdoc;
   VALUE document;
   #ifndef LIBXML_XPATH_ENABLED
   rb_raise(rb_eTypeError, "libxml was not compiled with XPath support.");
@@ -60,7 +60,7 @@ ruby_xml_xpath_context_initialize(VALUE self, VALUE node) {
   {
     document = rb_funcall(node, rb_intern("doc"), 0);
     if NIL_P(document)
-     rb_raise(rb_eTypeError, "Supplied node must belong to a document.");
+      rb_raise(rb_eTypeError, "Supplied node must belong to a document.");
   }
   else if (rb_obj_is_kind_of(node, cXMLDocument) == Qtrue)
   {
@@ -71,8 +71,8 @@ ruby_xml_xpath_context_initialize(VALUE self, VALUE node) {
     rb_raise(rb_eTypeError, "Supplied argument must be a document or node.");
   }
   
-  Data_Get_Struct(document, ruby_xml_document_t, rxd);
-  DATA_PTR(self) = xmlXPathNewContext(rxd->doc);
+  Data_Get_Struct(document, xmlDoc, xdoc);
+  DATA_PTR(self) = xmlXPathNewContext(xdoc);
   
   /* Save the doc as an attribute, this will expose it to Ruby's GC. */
   rb_iv_set(self, "@doc", document);    
@@ -126,9 +126,9 @@ ruby_xml_xpath_context_register_namespaces_from_node(VALUE self, VALUE node) {
   
   if (rb_obj_is_kind_of(node, cXMLDocument) == Qtrue)
   {
-    ruby_xml_document_t *rdoc;
-    Data_Get_Struct(node, ruby_xml_document_t, rdoc);
-    xnode = xmlDocGetRootElement(rdoc->doc);
+    xmlDocPtr xdoc;
+    Data_Get_Struct(node, xmlDoc, xdoc);
+    xnode = xmlDocGetRootElement(xdoc);
   }
   else if (rb_obj_is_kind_of(node, cXMLNode) == Qtrue)
   {
@@ -253,31 +253,29 @@ ruby_xml_xpath_context_find(VALUE self, VALUE xpath_expr) {
   xobject = xmlXPathEval((xmlChar*)StringValuePtr(xpath_expr), xctxt);
   
   if (xobject == NULL)
-    rb_raise(eXMLXPathInvalidPath,
-	     "Invalid XPath expression (expr could not be evaluated)");
-
+  {
+    /* xmlLastError is differnet than xctxt->lastError.  Use 
+       xmlLastError since it has the message set while xctxt->lastError
+       does not. */
+    xmlErrorPtr xerror = xmlGetLastError();
+    ruby_xml_raise(xerror);
+  }
+    
   result = ruby_xml_xpath_object_wrap(xobject);
   rb_iv_set(result, "@context", self);
   return result;  
 }
 
 
-// Rdoc needs to know 
-#ifdef RDOC_NEVER_DEFINED
-  mLibXML = rb_define_module("LibXML");
-  mXML = rb_define_module_under(mLibXML, "XML");
-  mXPath = rb_define_module_under(mXML, "XPath");
-#endif
-
 void
 ruby_init_xml_xpath_context(void) {
   cXMLXPathContext = rb_define_class_under(mXPath, "Context", rb_cObject);
   rb_define_alloc_func(cXMLXPathContext, ruby_xml_xpath_context_alloc);
+  rb_define_attr(cXMLXPathContext, "doc", 1, 0);
   rb_define_method(cXMLXPathContext, "initialize", ruby_xml_xpath_context_initialize, 1);
   rb_define_method(cXMLXPathContext, "register_namespaces", ruby_xml_xpath_context_register_namespaces, 1);
   rb_define_method(cXMLXPathContext, "register_namespaces_from_node", ruby_xml_xpath_context_register_namespaces_from_node, 1);
   rb_define_method(cXMLXPathContext, "register_namespace", ruby_xml_xpath_context_register_namespace, 2);
   rb_define_method(cXMLXPathContext, "node=", ruby_xml_xpath_context_node_set, 1);
   rb_define_method(cXMLXPathContext, "find", ruby_xml_xpath_context_find, 1);
-  rb_define_attr(cXMLXPathContext, "doc", 1, 0);
 }

data/ext/libxml/ruby_xml_xpath_object.c

@@ -12,36 +12,41 @@
 VALUE cXMLXPathObject;
 
 
-static VALUE
-ruby_xml_xpath_object_tabref(xmlXPathObjectPtr xpop, int apos) {
+xmlDocPtr
+ruby_xml_xpath_object_doc(xmlXPathObjectPtr xpop)
+{
+  xmlDocPtr result = NULL;
+  xmlNodePtr *nodes = NULL;
 
-  if (apos < 0 )
-    apos=xpop->nodesetval->nodeNr+apos;
+  if (xpop->type != XPATH_NODESET)
+    return result;
 
-  if (apos < 0 || apos+1 > xpop->nodesetval->nodeNr )
-    return Qnil;
+  if (!xpop->nodesetval || !xpop->nodesetval->nodeTab)
+    return result;
 
-  switch(xpop->nodesetval->nodeTab[apos]->type) {
-  case XML_ATTRIBUTE_NODE:
-    return ruby_xml_attr_wrap((xmlAttrPtr)xpop->nodesetval->nodeTab[apos]);
-    break;
-  default:
-    return ruby_xml_node2_wrap(cXMLNode,
-			       xpop->nodesetval->nodeTab[apos]);
-  }
+  nodes = xpop->nodesetval->nodeTab;
+
+  if (!(*nodes))
+    return result;
+
+  return (*nodes)->doc;
 }
 
 void
 ruby_xml_xpath_object_mark(xmlXPathObjectPtr xpop)
 {
-  void * xnp;
   int i;
 
-  if ( xpop->type == XPATH_NODESET && xpop->nodesetval != NULL ) {
-    for (i=0; i<xpop->nodesetval->nodeNr; i++) {
-      xnp=xpop->nodesetval->nodeTab[i]->_private;
-      if (xnp != NULL)
-	rb_gc_mark((VALUE)xnp);
+  if ( xpop->type == XPATH_NODESET && xpop->nodesetval != NULL ) 
+  {
+    xmlDocPtr xdoc = ruby_xml_xpath_object_doc(xpop);
+    if (xdoc && xdoc->_private)
+      rb_gc_mark((VALUE)xdoc->_private);
+
+    for (i=0; i<xpop->nodesetval->nodeNr; i++) 
+    {
+      if (xpop->nodesetval->nodeTab[i]->_private)
+        rb_gc_mark((VALUE)xpop->nodesetval->nodeTab[i]->_private);
     }
   }
 }
@@ -49,12 +54,24 @@ ruby_xml_xpath_object_mark(xmlXPathObjectPtr xpop)
 void
 ruby_xml_xpath_object_free(xmlXPathObjectPtr xpop)
 {
+  /* Before freeing this xpath object, get the 
+     document it is dependent on if its a nodeset. */
+  xmlDocPtr xdoc = ruby_xml_xpath_object_doc(xpop);
+
+  /* Now free the xpath result */
   xmlXPathFreeObject(xpop);
+
+  /* Now decrement the document object if this was a 
+     XPATH_NODESET.  Note this could free the document,
+     which is why we do it after freeing xpop.*/
+  if (xdoc)
+    ruby_xml_document_decr(xdoc);
 }
 
 VALUE
 ruby_xml_xpath_object_wrap(xmlXPathObjectPtr xpop)
 {
+  xmlDocPtr xdoc;
   VALUE rval;
 
   if ( xpop==NULL )
@@ -62,6 +79,10 @@ ruby_xml_xpath_object_wrap(xmlXPathObjectPtr xpop)
 
   switch(xpop->type) {
   case XPATH_NODESET:
+    xdoc = ruby_xml_xpath_object_doc(xpop);
+    if (xdoc)
+      ruby_xml_document_incr(xdoc);
+    
     rval = Data_Wrap_Struct(cXMLXPathObject,
                             ruby_xml_xpath_object_mark,
                             ruby_xml_xpath_object_free,
@@ -93,6 +114,24 @@ ruby_xml_xpath_object_wrap(xmlXPathObjectPtr xpop)
   return rval;
 }
 
+static VALUE
+ruby_xml_xpath_object_tabref(xmlXPathObjectPtr xpop, int apos) {
+
+  if (apos < 0 )
+    apos=xpop->nodesetval->nodeNr+apos;
+
+  if (apos < 0 || apos+1 > xpop->nodesetval->nodeNr )
+    return Qnil;
+
+  switch(xpop->nodesetval->nodeTab[apos]->type) {
+  case XML_ATTRIBUTE_NODE:
+    return ruby_xml_attr_wrap((xmlAttrPtr)xpop->nodesetval->nodeTab[apos]);
+    break;
+  default:
+    return ruby_xml_node2_wrap(cXMLNode,
+			       xpop->nodesetval->nodeTab[apos]);
+  }
+}
 
 /*
  * call-seq:
@@ -120,29 +159,6 @@ ruby_xml_xpath_object_to_a(VALUE self)
   return(set_ary);
 }
 
-/*
- * call-seq:
- *    xpath_object.set -> Node::Set
- * 
- * Obtain the previous type object which is really
- * just a proxy back to this object. Unless the
- * type is not a NODESET, in which case it is nil.
- */
-VALUE
-ruby_xml_xpath_object_set(VALUE self)
-{
-  xmlXPathObjectPtr xpop;
-  VALUE r;
-
-  Data_Get_Struct(self,xmlXPathObject,xpop);
-  r=Qnil;
-
-  if (xpop->type == XPATH_NODESET)
-    r=ruby_xml_node_set_new2(self);
-
-  return r;
-}
-
 /*
  * call-seq:
  *    xpath_object.empty? -> (true|false)
@@ -300,19 +316,11 @@ ruby_xml_xpath_object_debug(VALUE self) {
   return Qnil;
 }
 
-
-// Rdoc needs to know
-#ifdef RDOC_NEVER_DEFINED
-  mLibXML = rb_define_module("LibXML");
-  mXML = rb_define_module_under(mLibXML, "XML");
-  mXPath = rb_define_module_under(mXML, "XPath");
-#endif
-
 void
 ruby_init_xml_xpath_object(void) {
   cXMLXPathObject = rb_define_class_under(mXPath, "Object", rb_cObject);
   rb_include_module(cXMLXPathObject, rb_mEnumerable);
-
+  rb_define_attr(cXMLXPathObject, "context", 1, 0);
   rb_define_method(cXMLXPathObject, "each", ruby_xml_xpath_object_each, 0);
   rb_define_method(cXMLXPathObject, "xpath_type", ruby_xml_xpath_object_get_type, 0);
   rb_define_method(cXMLXPathObject, "empty?", ruby_xml_xpath_object_empty_q, 0);
@@ -322,9 +330,5 @@ ruby_init_xml_xpath_object(void) {
   rb_define_method(cXMLXPathObject, "to_a", ruby_xml_xpath_object_to_a, 0);
   rb_define_method(cXMLXPathObject, "[]", ruby_xml_xpath_object_aref, 1);
   rb_define_method(cXMLXPathObject, "string", ruby_xml_xpath_object_string, 0);
-  rb_define_attr(cXMLXPathObject, "context", 1, 0);
   rb_define_method(cXMLXPathObject, "debug", ruby_xml_xpath_object_debug, 0);
-  
-  /* Give the NodeSet type, but it is pointless */
-  rb_define_method(cXMLXPathObject, "set", ruby_xml_xpath_object_set, 0);
 }

data/ext/libxml/ruby_xml_xpointer.c

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_xpointer.c 461 2008-07-15 21:35:56Z cfis $ */
+/* $Id: ruby_xml_xpointer.c 566 2008-11-18 06:53:36Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -6,7 +6,15 @@
 #include "ruby_xml_xpointer.h"
 
 VALUE cXMLXPointer;
-VALUE eXMLXPointerInvalidExpression;
+
+/*
+* Document-class: LibXML::XML::XPointer
+*
+* The XML::Pointer class provides a standards based API for searching an xml document.
+* XPointer is based on the XML Path Language (XML::XPath) and is documented
+* at http://www.w3.org/TR/WD-xptr.
+*/
+
 
 VALUE
 ruby_xml_xpointer_point(VALUE class, VALUE rnode, VALUE xptr_str) {
@@ -31,7 +39,7 @@ ruby_xml_xpointer_point(VALUE class, VALUE rnode, VALUE xptr_str) {
 
   xpop = xmlXPtrEval((xmlChar*)StringValuePtr(xptr_str), xctxt);
   if (!xpop)
-    rb_raise(eXMLXPointerInvalidExpression, "Invalid xpointer expression");
+    ruby_xml_raise(&xmlLastError);
 
   result = ruby_xml_xpath_object_wrap(xpop);
   rb_iv_set(result, "@context", context);
@@ -98,7 +106,5 @@ ruby_xml_xpointer_range(VALUE class, VALUE rstart, VALUE rend) {
 void
 ruby_init_xml_xpointer(void) {
   cXMLXPointer = rb_define_class_under(mXML, "XPointer", rb_cObject);
-  eXMLXPointerInvalidExpression = rb_define_class_under(cXMLXPointer, "InvalidExpression", eXMLError);
-
   rb_define_singleton_method(cXMLXPointer, "range", ruby_xml_xpointer_range, 2);
 }

data/ext/libxml/sax_parser_callbacks.inc

@@ -1,4 +1,4 @@
-/* $Id: sax_parser_callbacks.inc 120 2006-11-26 12:57:56Z roscopeco $ */
+/* $Id: sax_parser_callbacks.inc 544 2008-11-16 09:50:27Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -11,49 +11,51 @@ static void internal_subset_func(ruby_xml_sax_parser *cbp,
        const char *sysid) {
   VALUE handler = cbp->callbackHandler;
   
-  if (handler && handler != Qnil) {
-    rb_funcall(handler, cbidOnInternalSubset, 3, rb_str_new2(name),
-        rb_str_new2(extid), rb_str_new2(sysid));
+  if (handler != Qnil) {
+    VALUE rname = name ? rb_str_new2(name) : Qnil;
+    VALUE rextid = extid ? rb_str_new2(extid) : Qnil;
+    VALUE rsysid  = sysid ? rb_str_new2(sysid) : Qnil;
+  rb_funcall(handler, cbidOnInternalSubset, 3, rname, rextid, rsysid);
   }    
 }
 
 static void is_standalone_func(ruby_xml_sax_parser *cbp) {
   VALUE handler = cbp->callbackHandler;
   
-  if (handler && handler != Qnil) {
-    rb_funcall(handler,cbidOnIsStandalone,0);
+  if (handler != Qnil) {
+    rb_funcall(handler, cbidOnIsStandalone,0);
   }    
 }
 
 static void has_internal_subset_func(ruby_xml_sax_parser *cbp) {
   VALUE handler = cbp->callbackHandler;
   
-  if (handler && handler != Qnil) {
-    rb_funcall(handler,cbidOnHasInternalSubset,0);
+  if (handler != Qnil) {
+    rb_funcall(handler, cbidOnHasInternalSubset, 0);
   }    
 }
 
 static void has_external_subset_func(ruby_xml_sax_parser *cbp) {
   VALUE handler = cbp->callbackHandler;
   
-  if (handler && handler != Qnil) {
-    rb_funcall(handler,cbidOnHasExternalSubset,0);
+  if (handler != Qnil) {
+    rb_funcall(handler, cbidOnHasExternalSubset, 0);
   }    
 }
 
 static void start_document_func(ruby_xml_sax_parser *cbp) {
   VALUE handler = cbp->callbackHandler;
   
-  if (handler && handler != Qnil) {
-    rb_funcall(handler,cbidOnStartDocument,0);
+  if (handler != Qnil) {
+    rb_funcall(handler, cbidOnStartDocument, 0);
   }    
 }
 
 static void end_document_func(ruby_xml_sax_parser *cbp) {
   VALUE handler = cbp->callbackHandler;
   
-  if (handler && handler != Qnil) {
-    rb_funcall(handler,cbidOnEndDocument,0);
+  if (handler != Qnil) {
+    rb_funcall(handler, cbidOnEndDocument, 0);
   }    
 }
 
@@ -70,17 +72,16 @@ static void start_element_func(ruby_xml_sax_parser *cbp,
     }
   }    
   
-  if (handler && handler != Qnil) {
-    rb_funcall(handler,cbidOnStartElement,2,rb_str_new2(name),ahsh);
+  if (handler != Qnil) {
+    rb_funcall(handler, cbidOnStartElement, 2, rb_str_new2(name), ahsh);
   }    
 }        
 
-static void end_element_func(ruby_xml_sax_parser *cbp, 
-       const char *name) {
+static void end_element_func(ruby_xml_sax_parser *cbp, const char *name) {
   VALUE handler = cbp->callbackHandler;
   
-  if (handler && handler != Qnil) {
-    rb_funcall(handler,cbidOnEndElement,1,rb_str_new2(name));
+  if (handler != Qnil) {
+    rb_funcall(handler, cbidOnEndElement, 1, rb_str_new2(name));
   }    
 }
 
@@ -88,8 +89,8 @@ static void reference_func(ruby_xml_sax_parser *cbp,
        const char *name) {
   VALUE handler = cbp->callbackHandler;
   
-  if (handler && handler != Qnil) {
-    rb_funcall(handler,cbidOnReference,1,rb_str_new2(name));
+  if (handler != Qnil) {
+    rb_funcall(handler, cbidOnReference,1,rb_str_new2(name));
   }    
 }
 
@@ -97,8 +98,9 @@ static void characters_func(ruby_xml_sax_parser *cbp,
        const char *chars, int len) {
   VALUE handler = cbp->callbackHandler;
   
-  if (handler && handler != Qnil) {
-    rb_funcall(handler,cbidOnCharacters,1,rb_str_new(chars, len));
+  if (handler != Qnil) {
+    VALUE rchars = rb_str_new(chars, len);
+    rb_funcall(handler, cbidOnCharacters, 1, rchars);
   }    
 }
 
@@ -106,9 +108,10 @@ static void processing_instruction_func(ruby_xml_sax_parser *cbp,
        const char *target, const char *data) {
   VALUE handler = cbp->callbackHandler;
   
-  if (handler && handler != Qnil) {
-    rb_funcall(handler, cbidOnProcessingInstruction, 2,
-        rb_str_new2(target),rb_str_new2(data));
+  if (handler != Qnil) {
+    VALUE rtarget = target ? rb_str_new2(target) : Qnil;
+    VALUE rdata = data ? rb_str_new2(data) : Qnil;
+    rb_funcall(handler, cbidOnProcessingInstruction, 2, rtarget, rdata);
   }    
 }
 
@@ -116,8 +119,8 @@ static void comment_func(ruby_xml_sax_parser *cbp,
        const char *msg) {
   VALUE handler = cbp->callbackHandler;
   
-  if (handler && handler != Qnil) {
-    rb_funcall(handler,cbidOnComment,1,rb_str_new2(msg));
+  if (handler != Qnil) {
+    rb_funcall(handler, cbidOnComment,1,rb_str_new2(msg));
   }    
 }
 
@@ -137,7 +140,7 @@ static void warning_func(ruby_xml_sax_parser *cbp,
        const char *msg, ...) {
   VALUE handler = cbp->callbackHandler;
   
-  if (handler && handler != Qnil) {
+  if (handler != Qnil) {
     FORMAT_AND_CALL(cbidOnXmlParserWarning);
   }    
 }
@@ -146,7 +149,7 @@ static void error_func(ruby_xml_sax_parser *cbp,
        const char *msg, ...) {
   VALUE handler = cbp->callbackHandler;
   
-  if (handler && handler != Qnil) {
+  if (handler != Qnil) {
     FORMAT_AND_CALL(cbidOnXmlParserError);
   }    
 }
@@ -155,7 +158,7 @@ static void fatal_error_func(ruby_xml_sax_parser *cbp,
        const char *msg, ...) {
   VALUE handler = cbp->callbackHandler;
   
-  if (handler && handler != Qnil) {
+  if (handler != Qnil) {
     FORMAT_AND_CALL(cbidOnXmlParserFatalError);
   }    
 }
@@ -164,8 +167,8 @@ static void cdata_block_func(ruby_xml_sax_parser *cbp,
        const char *value, int len) {
   VALUE handler = cbp->callbackHandler;
   
-  if (handler && handler != Qnil) {
-    rb_funcall(handler,cbidOnCdataBlock,1,rb_str_new(value, len));
+  if (handler != Qnil) {
+    rb_funcall(handler, cbidOnCdataBlock,1,rb_str_new(value, len));
   }    
 }
 
@@ -175,9 +178,11 @@ static void external_subset_func(ruby_xml_sax_parser *cbp,
        const char *sysid) {
   VALUE handler = cbp->callbackHandler;
   
-  if (handler && handler != Qnil) {
-    rb_funcall(handler, cbidOnExternalSubset, 3, rb_str_new2(name),
-        rb_str_new2(extid), rb_str_new2(sysid));
+  if (handler != Qnil) {
+    VALUE rname = name ? rb_str_new2(name) : Qnil;
+    VALUE rextid = extid ? rb_str_new2(extid) : Qnil;
+    VALUE rsysid  = sysid ? rb_str_new2(sysid) : Qnil;
+    rb_funcall(handler, cbidOnExternalSubset, 3, rname, rextid, rsysid);
   }    
 }