libxml-ruby 0.6.0-x86-mswin32-60 → 0.7.0-x86-mswin32-60

data/ext/libxml/ruby_xml_attr.h

@@ -1,4 +1,4 @@
-/* $Id: ruby_xml_attr.h 282 2008-07-01 06:44:30Z cfis $ */
+/* $Id: ruby_xml_attr.h 351 2008-07-09 19:55:21Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
@@ -7,13 +7,10 @@
 
 extern VALUE cXMLAttr;
 
-typedef struct ruby_xml_attr {
-  xmlAttrPtr attr;
-} ruby_xml_attr_t;
-
-VALUE ruby_xml_attr_new(VALUE class, xmlAttrPtr xnode);
-void ruby_xml_attr_free(ruby_xml_attr_t *rxn);
-VALUE ruby_xml_attr_wrap(VALUE class, xmlAttrPtr xnode);
 void ruby_init_xml_attr(void);
-VALUE ruby_xml_attr_name_get(VALUE self);
+VALUE ruby_xml_attr_new(xmlAttrPtr xattr);
+VALUE ruby_xml_attr_value_get(VALUE self);
+VALUE ruby_xml_attr_value_set(VALUE self, VALUE val);
+void ruby_xml_attr_free(xmlAttrPtr xattr);
+VALUE ruby_xml_attr_wrap(xmlAttrPtr xattr);
 #endif

data/ext/libxml/ruby_xml_attributes.c

@@ -0,0 +1,268 @@
+/* $Id: ruby_xml_attributes.c 300 2008-07-01 19:14:15Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+/*
+* Document-class: XML::Attributes
+*
+* Provides access to an elements attributes (XML::Attr).
+*
+* Basic Usage:
+*  require 'libxml'
+*
+*  doc = XML::Document.new(<some_file>)
+*  attributes = doc.root.attributes
+*
+*  attributes.each do |attribute|
+*    ..
+*  end
+* 
+*  attributes['foo'] = 'bar'
+*  attribute = attributes.get_attribute['foo']
+*  attribute.value == 'foo'
+*
+* To access a namespaced attribute:
+*
+*  XLINK_URI = 'http://www.w3.org/1999/xlink'
+*
+*  attribute = attributes.get_attribute_ns(XLINK_URI, 'title')
+*  attribute.value = 'My title'
+*/
+
+#include "ruby_libxml.h"
+#include "ruby_xml_attributes.h"
+
+VALUE cXMLAttributes;
+
+void
+ruby_xml_attributes_mark(xmlNodePtr xnode) {
+  ruby_xml_node_mark_common(xnode);
+}
+
+/*
+ * Creates a  new attributes instance.  Not exposed to ruby.
+ */
+VALUE
+ruby_xml_attributes_new(xmlNodePtr xnode)
+{
+  return Data_Wrap_Struct(cXMLAttributes,
+                          ruby_xml_attributes_mark, NULL,
+                          xnode);
+}
+
+/*
+ * call-seq:
+ *   attributes.node -> XML::Node
+ * 
+ * Return the node that owns this attributes list.
+ *
+ *  doc.root.attributes.node == doc.root
+ */
+VALUE
+ruby_xml_attributes_node_get(VALUE self) {
+  xmlNodePtr xnode;
+  Data_Get_Struct(self, xmlNode, xnode);
+  return(ruby_xml_node2_wrap(cXMLNode, xnode));
+}
+
+
+/*
+ * call-seq:
+ *    attributes.get_attribute("name") -> XML::Attr
+ * 
+ * Returns the specified attribute.
+ * 
+ * name: The name of the attribute, not including a namespace.
+ *
+ *  doc.root.attributes.get_attribute("foo")
+ */
+VALUE
+ruby_xml_attributes_get_attribute(VALUE self, VALUE name) {
+  xmlNodePtr xnode;
+  xmlAttrPtr xattr;
+
+  name = check_string_or_symbol(name);
+  
+  Data_Get_Struct(self, xmlNode, xnode);
+  
+  xattr = xmlHasProp(xnode, (xmlChar*)StringValuePtr(name));
+  
+  if (xattr)
+    return(ruby_xml_attr_wrap(xattr));
+  else
+    return(Qnil);
+}
+
+/*
+ * call-seq:
+ *    attributes.get_attribute_ns("namespace", "name") -> XML::Attr
+ * 
+ * Returns the specified attribute.
+ * 
+ * namespace: The URI of the attribute's namespace.
+ * name: The name of the attribute, not including a namespace.
+ *
+ *  doc.root.attributes.get_attribute_ns('http://www.w3.org/1999/xlink', 'href')
+ */
+VALUE
+ruby_xml_attributes_get_attribute_ns(VALUE self, VALUE namespace, VALUE name) {
+  xmlNodePtr xnode;
+  xmlAttrPtr xattr;
+
+  name = check_string_or_symbol(name);
+  
+  Data_Get_Struct(self, xmlNode, xnode);
+  
+  xattr = xmlHasNsProp(xnode, (xmlChar*)StringValuePtr(name), (xmlChar*)StringValuePtr(namespace));
+  
+  if (xattr)
+    return(ruby_xml_attr_wrap(xattr));
+  else
+    return(Qnil);
+}
+
+/*
+ * call-seq:
+ *    attributes["name"] -> String
+ * 
+ * Fetches an attribute value. If you want to access the underlying
+ * Attribute itself use get_attribute.  
+ *
+ * name: The name of the attribute, not including any namespaces.
+ *  
+ *  doc.root.attributes['att'] -> 'some value'
+ */
+VALUE
+ruby_xml_attributes_attribute_get(VALUE self, VALUE name) {
+  VALUE xattr = ruby_xml_attributes_get_attribute(self, name);
+  if NIL_P(xattr)
+    return(Qnil);
+  else
+    return ruby_xml_attr_value_get(xattr);
+}  
+
+/*
+ * call-seq:
+ *    attributes["name"] = "value"
+ * 
+ * Sets an attribute value. If you want to get the Attribute itself,
+ * use get_attribute.  
+ *
+ * name: The name of the attribute, not including any namespaces.
+ * value: The new value of the namespace.
+ *  
+ *  doc.root.attributes['att'] = 'some value'
+ */
+VALUE
+ruby_xml_attributes_attribute_set(VALUE self, VALUE name, VALUE value) {
+  VALUE xattr = ruby_xml_attributes_get_attribute(self, name);
+  if NIL_P(xattr)
+  {
+    VALUE args[3];
+
+    args[0] = ruby_xml_attributes_node_get(self);
+    args[1] = name;
+    args[2] = value;
+
+    return rb_class_new_instance(sizeof(args)/sizeof(VALUE), args, cXMLAttr);
+  }
+  else
+  {
+    return ruby_xml_attr_value_set(xattr, value);
+  }
+}  
+
+
+/*
+ * call-seq:
+ *    attributes.each {block} -> XML::Attr
+ * 
+ * Iterates over each attribute.
+ *  
+ *  doc.root.attributes.each {|attribute| puts attribute.name}
+ */
+VALUE
+ruby_xml_attributes_each(VALUE self) {
+  xmlNodePtr xnode;
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlNode, xnode);
+
+  xattr = xnode->properties;
+
+  while (xattr)
+  {
+     VALUE attr = ruby_xml_attr_wrap(xattr);
+     rb_yield(attr);
+     xattr = xattr->next;
+  }
+  
+  return self;
+}  
+  
+/*
+ * call-seq:
+ *    attributes.length -> Integer
+ * 
+ * Returns the number of attributes.
+ *
+ *  doc.root.attributes.length
+ */
+VALUE
+ruby_xml_attributes_length(VALUE self) {
+  int length = 0;
+  xmlNodePtr xnode;
+  xmlAttrPtr xattr;
+  Data_Get_Struct(self, xmlNode, xnode);
+
+  xattr = xnode->properties;
+
+  while (xattr)
+  {
+     length++;
+     xattr = xattr->next;
+  }
+  
+  return INT2NUM(length);
+}  
+
+/*
+ * call-seq:
+ *    attributes.first -> XML::Attr
+ * 
+ * Returns the first attribute.
+ *
+ *  doc.root.attributes.first
+ */
+VALUE
+ruby_xml_attributes_first(VALUE self) {
+  xmlNodePtr xnode;
+  Data_Get_Struct(self, xmlNode, xnode);
+
+  if (xnode->type == XML_ELEMENT_NODE) {
+    xmlAttrPtr xattr = xnode->properties;
+    
+    if (xattr) {
+      return(ruby_xml_attr_wrap(xattr));
+    }
+  } 
+  return(Qnil);
+}
+
+// Rdoc needs to know 
+#ifdef RDOC_NEVER_DEFINED
+  mXML = rb_define_module("XML");
+#endif
+    
+void
+ruby_init_xml_attributes(void) {
+  cXMLAttributes = rb_define_class_under(mXML, "Attributes", rb_cObject);
+  rb_include_module(cXMLAttributes, rb_const_get(rb_cObject, rb_intern("Enumerable")));
+  rb_define_method(cXMLAttributes, "node", ruby_xml_attributes_node_get, 0);
+  rb_define_method(cXMLAttributes, "get_attribute", ruby_xml_attributes_get_attribute, 1);
+  rb_define_method(cXMLAttributes, "get_attribute_ns", ruby_xml_attributes_get_attribute_ns, 2);
+  rb_define_method(cXMLAttributes, "[]", ruby_xml_attributes_attribute_get, 1);
+  rb_define_method(cXMLAttributes, "[]=", ruby_xml_attributes_attribute_set, 2);
+  rb_define_method(cXMLAttributes, "each", ruby_xml_attributes_each, 0);
+  rb_define_method(cXMLAttributes, "length", ruby_xml_attributes_length, 0);
+  rb_define_method(cXMLAttributes, "first", ruby_xml_attributes_first, 0);
+}

data/ext/libxml/ruby_xml_attributes.h

@@ -0,0 +1,17 @@
+/* $Id: ruby_xml_attributes.h 282 2008-07-01 06:44:30Z cfis $ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_XML_ATTRIBUTES__
+#define __RUBY_XML_ATTRIBUTES__
+
+extern VALUE cXMLAttributesibutes;
+
+void ruby_init_xml_attributes(void);
+VALUE ruby_xml_attributes_new(xmlNodePtr xnode);
+
+VALUE ruby_xml_attributes_attribute_get(VALUE self, VALUE name);
+VALUE ruby_xml_attributes_attribute_set(VALUE self, VALUE name, VALUE value);
+
+
+#endif

data/ext/libxml/ruby_xml_document.c

@@ -1,16 +1,36 @@
-/* $Id: ruby_xml_document.c 300 2008-07-01 19:14:15Z cfis $ */
+/* $Id: ruby_xml_document.c 359 2008-07-09 20:24:21Z cfis $ */
 
 /* Please see the LICENSE file for copyright and distribution information */
 
+/*
+* Document-class: XML::Document
+*
+* Reads or writes an XML document:
+*
+* Reading:
+*  require 'libxml'
+*
+*  doc = XML::Document.new()
+*  doc.root = XML::Node.new('root_node')
+*  doc.root << XML::Node.new('elem1')
+*  doc.save('output.xml', format)
+* 
+* Writing:
+*  require 'libxml'
+*  doc = XML::Document.file('output.xml')
+*  root = doc.root
+*/
+
 #include <stdarg.h>
 #include "ruby_libxml.h"
 #include "ruby_xml_document.h"
 
+
 VALUE cXMLDocument;
 
 /*
  * call-seq:
- *    document.compression => num
+ *    document.compression -> num
  * 
  * Obtain this document's compression mode identifier.
  */
@@ -67,7 +87,7 @@ ruby_xml_document_compression_set(VALUE self, VALUE num) {
 
 /*
  * call-seq:
- *    document.compression? => (true|false)
+ *    document.compression? -> (true|false)
  * 
  * Determine whether this document is compressed.
  */
@@ -90,7 +110,7 @@ ruby_xml_document_compression_q(VALUE self) {
 
 /*
  * call-seq:
- *    document.child => node
+ *    document.child -> node
  * 
  * Get this document's child node.
  */
@@ -109,7 +129,7 @@ ruby_xml_document_child_get(VALUE self) {
 
 /*
  * call-seq:
- *    document.child? => (true|false)
+ *    document.child? -> (true|false)
  * 
  * Determine whether this document has a child node.
  */
@@ -127,7 +147,7 @@ ruby_xml_document_child_q(VALUE self) {
 
 /*
  * call-seq:
- *    document.dump([stream]) => true
+ *    document.dump([stream]) -> true
  * 
  * Dump this document's XML to the specified IO stream.
  * If no stream is specified, stdout is used.
@@ -166,7 +186,7 @@ ruby_xml_document_dump(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *    document.debug_dump([stream]) => true
+ *    document.debug_dump([stream]) -> true
  * 
  * Debug version of dump.
  */
@@ -209,7 +229,7 @@ ruby_xml_document_debug_dump(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *    document.debug_dump_head([stream]) => true
+ *    document.debug_dump_head([stream]) -> true
  * 
  * Debug-dump this document's header to the specified IO stream.
  * If no stream is specified, stdout is used.
@@ -253,7 +273,7 @@ ruby_xml_document_debug_dump_head(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *    document.format_dump([stream], [spacing]) => true
+ *    document.format_dump([stream], [spacing]) -> true
  * 
  * Dump this document's formatted XML to the specified IO stream.
  * If no stream is specified, stdout is used. If spacing is 
@@ -310,7 +330,7 @@ ruby_xml_document_format_dump(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *    document.debug_format_dump([stream]) => true
+ *    document.debug_format_dump([stream]) -> true
  * 
  * *Deprecated* in favour of format_dump.
  */
@@ -323,7 +343,7 @@ ruby_xml_document_debug_format_dump(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *    document.encoding => "encoding"
+ *    document.encoding -> "encoding"
  * 
  * Obtain the encoding specified by this document.
  */
@@ -357,7 +377,7 @@ ruby_xml_document_encoding_set(VALUE self, VALUE encoding) {
 
 /*
  * call-seq:
- *    document.filename => "filename"
+ *    document.filename -> "filename"
  * 
  * Obtain the filename this document was read from.
  */
@@ -386,10 +406,31 @@ ruby_xml_document_filename_get(VALUE self) {
 
 /*
  * call-seq:
- *    document.find(xpath_expr, [namespace]) => nodeset
+ *    document.find(xpath_expr, [namespace]) -> XML::Node::Set
  * 
  * Find nodes matching the specified xpath expression, optionally
- * using the specified namespace. Returns an XML::Node::Set.
+ * using the specified namespace. Returns an XML::Node::Set.  For
+ * more information about working with namespaces, please refer
+ * to the XML::XPath documentation.
+ *
+ * IMPORTANT - The returned XML::Node::Set must be freed before
+ * its associated document.  In a running Ruby program this will
+ * happen automatically via Ruby's mark and sweep garbage collector.
+ * However, if the program exits, Ruby does not guarantee the order
+ * in which objects are freed
+ * (see http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/17700).
+ * As a result, the associated document may be freed before the node
+ * list, which will cause a segmentation fault.
+ *
+ * To avoid this, use the following (non-ruby like) coding style:
+ *
+ *  nodes = doc.find('/header')
+ *  nodes.each do |node|
+ *    ... do stuff ...
+ *  end
+ *
+ *  nodes = nil
+ *  GC.start
  */
 VALUE
 ruby_xml_document_find(int argc, VALUE *argv, VALUE self) {
@@ -438,12 +479,12 @@ void
 ruby_xml_document_mark(ruby_xml_document_t *rxd) {
   // will mark parsers and source types
   // I do not thing doc->parent has anything useful in it.
-  ruby_xml_state_marker();
+  rb_gc_mark(LIBXML_STATE);
 }
 
 /*
  * call-seq:
- *    XML::Document.new(xml_version = 1.0) => document
+ *    XML::Document.new(xml_version = 1.0) -> document
  * 
  * Create a new XML::Document, optionally specifying the
  * XML version.
@@ -470,7 +511,7 @@ ruby_xml_document_new(int argc, VALUE *argv, VALUE class) {
 
 /*
  * call-seq:
- *    document.last => node
+ *    document.last -> node
  * 
  * Obtain the last node.
  */
@@ -489,7 +530,7 @@ ruby_xml_document_last_get(VALUE self) {
 
 /*
  * call-seq:
- *    document.last? => (true|false)
+ *    document.last? -> (true|false)
  * 
  * Determine whether there is a last node.
  */
@@ -541,7 +582,7 @@ ruby_xml_document_new_native(VALUE class, VALUE xmlver) {
 
 /*
  * call-seq:
- *    XML::Document.file(filename) => document
+ *    XML::Document.file(filename) -> document
  * 
  * Create a new XML::Document by parsing the specified
  * file.
@@ -558,7 +599,7 @@ ruby_xml_document_new_file(VALUE class, VALUE filename) {
 
 /*
  * call-seq:
- *    document.next => node
+ *    document.next -> node
  * 
  * Obtain the next node.
  */
@@ -577,7 +618,7 @@ ruby_xml_document_next_get(VALUE self) {
 
 /*
  * call-seq:
- *    document.next? => (true|false)
+ *    document.next? -> (true|false)
  * 
  * Determine whether there is a next node.
  */
@@ -595,7 +636,7 @@ ruby_xml_document_next_q(VALUE self) {
 
 /*
  * call-seq:
- *    document.parent => node
+ *    document.parent -> node
  * 
  * Obtain the parent node.
  */
@@ -614,7 +655,7 @@ ruby_xml_document_parent_get(VALUE self) {
 
 /*
  * call-seq:
- *    document.parent? => (true|false)
+ *    document.parent? -> (true|false)
  * 
  * Determine whether there is a parent node.
  */
@@ -632,7 +673,7 @@ ruby_xml_document_parent_q(VALUE self) {
 
 /*
  * call-seq:
- *    document.prev => node
+ *    document.prev -> node
  * 
  * Obtain the previous node.
  */
@@ -651,7 +692,7 @@ ruby_xml_document_prev_get(VALUE self) {
 
 /*
  * call-seq:
- *    document.prev? => (true|false)
+ *    document.prev? -> (true|false)
  * 
  * Determine whether there is a previous node.
  */
@@ -669,31 +710,7 @@ ruby_xml_document_prev_q(VALUE self) {
 
 /*
  * call-seq:
- *    document["key"] => "value"
- * 
- * Obtain the named property.
- */
-VALUE
-ruby_xml_document_property_get(VALUE self, VALUE key) {
-  return(ruby_xml_node_property_get(ruby_xml_document_root_get(self), key));
-}
-
-
-/*
- * call-seq:
- *    document["key"] = "value"
- * 
- * Set the named property.
- */
-VALUE
-ruby_xml_document_property_set(VALUE self, VALUE key, VALUE val) {
-  return(ruby_xml_node_property_set(ruby_xml_document_root_get(self), key, val));
-}
-
-
-/*
- * call-seq:
- *    document.root => node
+ *    document.root -> node
  * 
  * Obtain the root node.
  */
@@ -721,19 +738,18 @@ ruby_xml_document_root_get(VALUE self) {
 VALUE
 ruby_xml_document_root_set(VALUE self, VALUE node) {
   ruby_xml_document_t *rxd;
-  ruby_xml_node *rxn;
-  xmlNodePtr root;
+  xmlNodePtr xroot, xnode;
 
   if (rb_obj_is_kind_of(node, cXMLNode) == Qfalse)
     rb_raise(rb_eTypeError, "must pass an XML::Node type object");
 
   Data_Get_Struct(self, ruby_xml_document_t, rxd);
-  Data_Get_Struct(node, ruby_xml_node, rxn);
-  root = xmlDocSetRootElement(rxd->doc, rxn->node);
-  if (root == NULL)
+  Data_Get_Struct(node, xmlNode, xnode);
+  xroot = xmlDocSetRootElement(rxd->doc, xnode);
+  if (xroot == NULL)
     return(Qnil);
 
-  return ruby_xml_node2_wrap(cXMLNode, root);
+  return ruby_xml_node2_wrap(cXMLNode, xroot);
 }
 
 
@@ -780,7 +796,7 @@ ruby_xml_document_save(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *    document.standalone? => (true|false)
+ *    document.standalone? -> (true|false)
  * 
  * Determine whether this is a standalone document.
  */
@@ -797,7 +813,7 @@ ruby_xml_document_standalone_q(VALUE self) {
 
 /*
  * call-seq:
- *    document.to_s({format=true,encoding) => "xml"
+ *    document.to_s({format=true,encoding) -> "xml"
  * 
  * Coerce this document to a string representation
  * of it's XML. The default is to pretty format, but this
@@ -858,7 +874,7 @@ ruby_xml_document_to_s(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *    document.url => "url"
+ *    document.url -> "url"
  * 
  * Obtain this document's source URL, if any.
  */
@@ -875,7 +891,7 @@ ruby_xml_document_url_get(VALUE self) {
 
 /*
  * call-seq:
- *    document.version => "version"
+ *    document.version -> "version"
  * 
  * Obtain the XML version specified by this document.
  */
@@ -892,7 +908,7 @@ ruby_xml_document_version_get(VALUE self) {
 
 /*
  * call-seq:
- *    document.xinclude => num
+ *    document.xinclude -> num
  * 
  * Process xinclude directives in this document. 
  */
@@ -942,7 +958,7 @@ LibXML_validity_warning(void * ctxt, const char * msg, va_list ap)
 
 /*
  * call-seq:
- *    document.validate(schema) => (true|false)
+ *    document.validate_schema(schema) -> (true|false)
  * 
  * Validate this document against the specified XML::Schema.
  */
@@ -973,7 +989,7 @@ ruby_xml_document_validate_schema(VALUE self, VALUE schema) {
 
 /*
  * call-seq:
- *    document.validate(schema) => (true|false)
+ *    document.validate(dtd) -> (true|false)
  * 
  * Validate this document against the specified XML::DTD.
  */
@@ -1048,7 +1064,7 @@ validate(self, ...)
 
 /*
  * call-seq:
- *    document.reader => reader
+ *    document.reader -> reader
  * 
  * Create a XML::Reader from the document. This is a shortcut to
  * XML::Reader.walker().
@@ -1073,8 +1089,6 @@ ruby_init_xml_document(void) {
   //rb_raise(eXMLNodeFailedModify, "unable to add a child to the document");
   //eDTDValidityWarning = rb_define_class_under(cXMLNode, "ValidityWarning", eXMLError);
   //eDTDValidityError   = rb_define_class_under(cXMLNode, "ValidityWarning", eXMLError);
-  rb_define_method(cXMLDocument, "[]", ruby_xml_document_property_get, 1);
-  rb_define_method(cXMLDocument, "[]=", ruby_xml_document_property_set, 2);
   rb_define_method(cXMLDocument, "child", ruby_xml_document_child_get, 0);
   rb_define_method(cXMLDocument, "child?", ruby_xml_document_child_q, 0);
   rb_define_method(cXMLDocument, "compression", ruby_xml_document_compression_get, 0);