libxml-ruby 2.2.2 → 2.3.0

data/HISTORY

@@ -1,6 +1,18 @@
 = Release History
 
-== 2.2.2 / 2011-08-13 Charlie Savage
+== 2.3.0 / 2012-02-22 Ryan Johnson
+
+* Add ability to insert new PI-nodes into the xmltree (Axel Struebing).
+
+* Added full pass-through access to libxml2 xmlC14NDocDumpMemory method via
+  LibXML::XML::Document#canonicalize method with optional arguments.
+
+* Added full test data for C14N based off of W3C spec. 
+  (http://www.w3.org/TR/xml-c14n#Examples)
+
+* Update sax handler to support encodings on Ruby 1.9 and higher.
+
+== 2.2.2 / 2011-08-29 Charlie Savage
 
 * ++API CHANGE+++
 
@@ -24,7 +36,7 @@ Fixes GitHub issue #30.
 * Fixed bug where Node#inner_xml caused an error when it had no child nodes.
   Fixes GitHub issues #31
 
-* Don't require 'rake' in the gemspec to avoid annoying Bunlder bugs
+* Don't require 'rake' in the gemspec to avoid annoying Bundler bugs
 
 == 2.2.1 / 2011-08-13 Charlie Savage
 

data/MANIFEST

@@ -138,6 +138,7 @@ test/tc_node_cdata.rb
 test/tc_node_comment.rb
 test/tc_node_copy.rb
 test/tc_node_edit.rb
+test/tc_node_pi.rb
 test/tc_node_text.rb
 test/tc_node_write.rb
 test/tc_node_xlink.rb

data/README.rdoc

@@ -94,12 +94,12 @@ namespace, in which case you can either write your code like this:
   require 'libxml'
   document = LibXML::XML::Document.new
 
-Or you can utilize a namespace for you own work and include LibXML into it.
+Or you can utilize a namespace for your own work and include LibXML into it.
 For example:
 
   require 'libxml'
 
-  mdoule MyApplication
+  module MyApplication
     include LibXML
 
     class MyClass

data/ext/libxml/ruby_xml_document.c

@@ -58,7 +58,7 @@ VALUE cXMLDocument;
 void rxml_document_mark_node_list(xmlNodePtr xnode)
 {
   if (xnode == NULL) return;
-  
+
   while (xnode != NULL)
   {
     rxml_document_mark_node_list(xnode->children);
@@ -149,28 +149,183 @@ static VALUE rxml_document_initialize(int argc, VALUE *argv, VALUE self)
 #endif
 
 /*
-  * call-seq:
-  *    document.canonicalize(comments) -> String 
+  * :call-seq:
+  *   document.canonicalize -> String
+  *   document.canonicalize(options) -> String
   *
-  * 	Returns a string containing the canonicalized form of the document.
+  * Returns a string containing the canonicalized form of the document.
+  * Implemented to include all of the functionality of the libxml2
+  * {xmlC14NDocDumpMemory}[http://xmlsoft.org/html/libxml-c14n.html#xmlC14NDocDumpMemory]
+  * method.
   *
-  *  :comments - Specifies if comments should be output.  This is an optional
-  *              parameter whose default value is false.
+  * === Options
+  * [comments]
+  *   * *Type:* Boolean
+  *   * *Default:* false
+  *   Specifies if comments should be output.
+  *   * Must be boolean, otherwise defaults to false.
+  * [inclusive_ns_prefixes]
+  *   * *Type:* Array of strings
+  *   * *Default:* empty array
+  *   Array of namespace prefixes to include in exclusive canonicalization only.
+  *   * The last item in the list is reserved for a NULL value because the C method demands it, therefore
+  *     up to the first 255 valid entries will be used.
+  *   * <em>Only used for *XML_C14N_EXCLUSIVE_1_0* mode. Ignored otherwise.</em>
+  * [mode]
+  *   * *Type:* XML::Document Constant
+  *   * *Default:* XML_C14N_1_0
+  *   Specifies the mode of canonicalization.
+  *   * *NOTE:* XML_C14N_1_1 may not be fully implemented upon compilation due to C library compatibility.
+  *     Please check if XML_C14N_1_0 and XML_C14N_1_1 are the same value prior to using XML_C14N_1_1.
+  * [nodes]
+  *   * *Type:* Array of XML::Node objects
+  *   * *Default:* empty array
+  *   XML::Nodes to include in the canonicalization process
+  *   * For large lists of more than 256 valid namespaces, up to the first 256 valid entries will be used.
   */
-static VALUE rxml_document_canonicalize(int argc, VALUE *argv, VALUE self)
+#define C14N_NS_LIMIT 256
+#define C14N_NODESET_LIMIT 256
+
+static VALUE
+rxml_document_canonicalize(int argc, VALUE *argv, VALUE self)
 {
   VALUE result = Qnil;
-  VALUE comments = Qnil ;
+  int length;
   xmlDocPtr xdoc;
   xmlChar *buffer = NULL;
-  int length;
+  VALUE option_hash = Qnil;
+  VALUE o_nodes = Qnil;
+
+  // :comments option
+  VALUE comments = Qfalse;
+  // :mode option
+  int c14n_mode = XML_C14N_1_0;
+  // :inclusive_ns_prefixes option (ARRAY)
+
+  xmlChar * inc_ns_prefixes_ptr[C14N_NS_LIMIT];
+
+  // :nodes option (ARRAY)
+  xmlNodePtr  node_ptr_array[C14N_NODESET_LIMIT];
+  xmlNodeSet nodeset = {
+    0, C14N_NODESET_LIMIT, NULL
+  };
+
+  /* At least one NULL value must be defined in the array or the extension will
+   * segfault when using XML_C14N_EXCLUSIVE_1_0 mode.
+   * API docs: "list of inclusive namespace prefixes ended with a NULL"
+   */
+  inc_ns_prefixes_ptr[0] = NULL;
+
+  rb_scan_args(argc, argv, "01", &option_hash);
+  // Do stuff if ruby hash passed as argument
+  if (!NIL_P(option_hash)) 
+  {
+	VALUE o_comments = Qnil;
+	VALUE o_mode = Qnil;
+	VALUE o_i_ns_prefixes = Qnil;
+	VALUE * list_in = NULL;
+	
+    Check_Type(option_hash, T_HASH);
+
+    o_comments = rb_hash_aref(option_hash, ID2SYM(rb_intern("comments")));
+    comments = (RTEST(o_comments) ? 1 : 0);
+
+    o_mode = rb_hash_aref(option_hash, ID2SYM(rb_intern("mode")));
+    if (!NIL_P(o_mode)) 
+	{
+      Check_Type(o_mode, T_FIXNUM);
+      c14n_mode = NUM2INT(o_mode);
+      //TODO: clean this up
+      //if (c14n_mode > 2) { c14n_mode = 0; }
+      //mode_int = (NUM2INT(o_mode) > 2 ? 0 : NUM2INT(o_mode));
+    }
+
+    o_i_ns_prefixes = rb_hash_aref(option_hash, ID2SYM(rb_intern("inclusive_ns_prefixes")));
+    if (!NIL_P(o_i_ns_prefixes)) 
+	{
+      int i;
+      int p = 0; //pointer array index
+      VALUE *list_in = NULL;
+      int list_size = 0;
+
+	  Check_Type(o_i_ns_prefixes, T_ARRAY);
+      list_in = RARRAY_PTR(o_i_ns_prefixes);
+      list_size = RARRAY_LEN(o_i_ns_prefixes);
+
+      if (list_size > 0) 
+	  {
+        for(i=0; i < list_size; ++i) {
+          if (p >= C14N_NS_LIMIT) { break; }
+
+          if (RTEST(list_in[i])) 
+		  {
+            if (TYPE(list_in[i]) == T_STRING) 
+			{
+              inc_ns_prefixes_ptr[p] = (xmlChar *)StringValueCStr(list_in[i]);
+              p++;
+            }
+          }
+        }
+      }
+
+      // ensure p is not out of bound
+      p = (p >= C14N_NS_LIMIT ? (C14N_NS_LIMIT-1) : p);
+
+      // API docs: "list of inclusive namespace prefixes ended with a NULL"
+      // Set last element to NULL
+      inc_ns_prefixes_ptr[p] = NULL;
+    }
+    //o_ns_prefixes will free at end of block
+
+    o_nodes = rb_hash_aref(option_hash, ID2SYM(rb_intern("nodes")));
+    if (!NIL_P(o_nodes)) 
+	{
+      int i;
+      int p = 0; // index of pointer array
+      VALUE * list_in = NULL;
+      int node_list_size = 0;
+
+	  if (CLASS_OF(o_nodes) == cXMLXPathObject)
+	  {
+		  o_nodes = rb_funcall(o_nodes, rb_intern("to_a"), 0);
+	  }
+	  else
+	  {
+		  Check_Type(o_nodes, T_ARRAY);
+	  }
+      list_in = RARRAY_PTR(o_nodes);
+      node_list_size = RARRAY_LEN(o_nodes);
+
+      for (i=0; i < node_list_size; ++i)
+	  {
+        if (p >= C14N_NODESET_LIMIT) { break; }
+
+        if (RTEST(list_in[i])) 
+		{
+          xmlNodePtr node_ptr;
+          Data_Get_Struct(list_in[i], xmlNode, node_ptr);
+          node_ptr_array[p] = node_ptr;
+          p++;
+        }
+      }
+
+      // Need to set values in nodeset struct
+      nodeset.nodeNr = (node_list_size > C14N_NODESET_LIMIT ?
+                        C14N_NODESET_LIMIT :
+                        node_list_size);
+      nodeset.nodeTab = node_ptr_array;
+    }
+  }//option_hash
 
-  rb_scan_args(argc, argv, "01", &comments);
-  
   Data_Get_Struct(self, xmlDoc, xdoc);
-  length = xmlC14NDocDumpMemory(xdoc, NULL, XML_C14N_1_1, NULL, 
-                                (comments == Qtrue ? 1 : 0),
-                                &buffer);
+  length = xmlC14NDocDumpMemory(
+    xdoc,
+    (nodeset.nodeNr == 0 ? NULL : &nodeset),
+    c14n_mode,
+    &inc_ns_prefixes_ptr,
+    comments,
+    &buffer
+  );
 
   if (buffer)
   {
@@ -180,8 +335,8 @@ static VALUE rxml_document_canonicalize(int argc, VALUE *argv, VALUE self)
 
   return result;
 }
-  
- 
+
+
 /*
  * call-seq:
  *    document.compression -> num
@@ -356,7 +511,7 @@ static VALUE rxml_document_rb_encoding_get(VALUE self)
   rbencoding = rxml_xml_encoding_to_rb_encoding(mXMLEncoding, xmlParseCharEncoding(xencoding));
   return rb_enc_from_encoding(rbencoding);
 }
-#endif 
+#endif
 
 /*
  * call-seq:
@@ -615,7 +770,7 @@ static VALUE rxml_document_root_set(VALUE self, VALUE node)
  *
  * Saves a document to a file.  You may provide an optional hash table
  * to control how the string is generated.  Valid options are:
- * 
+ *
  * :indent - Specifies if the string should be indented.  The default value
  * is true.  Note that indentation is only added if both :indent is
  * true and XML.indent_tree_output is true.  If :indent is set to false,
@@ -626,7 +781,7 @@ static VALUE rxml_document_root_set(VALUE self, VALUE node)
  * #encoding.  To override the orginal encoding, use one of the
  * XML::Encoding encoding constants. */
 static VALUE rxml_document_save(int argc, VALUE *argv, VALUE self)
-{ 
+{
   VALUE options = Qnil;
   VALUE filename = Qnil;
   xmlDocPtr xdoc;
@@ -665,7 +820,7 @@ static VALUE rxml_document_save(int argc, VALUE *argv, VALUE self)
 
   if (length == -1)
     rxml_raise(&xmlLastError);
-  
+
   return (INT2NUM(length));
 }
 
@@ -692,9 +847,9 @@ static VALUE rxml_document_standalone_q(VALUE self)
  *    document.to_s(:indent => true, :encoding => XML::Encoding::UTF_8) -> "string"
  *
  * Converts a document, and all of its children, to a string representation.
- * You may provide an optional hash table to control how the string is 
+ * You may provide an optional hash table to control how the string is
  * generated.  Valid options are:
- * 
+ *
  * :indent - Specifies if the string should be indented.  The default value
  * is true.  Note that indentation is only added if both :indent is
  * true and XML.indent_tree_output is true.  If :indent is set to false,
@@ -704,13 +859,13 @@ static VALUE rxml_document_standalone_q(VALUE self)
  * defaults to XML::Encoding::UTF8.  To change it, use one of the
  * XML::Encoding encoding constants. */
 static VALUE rxml_document_to_s(int argc, VALUE *argv, VALUE self)
-{ 
+{
   VALUE result;
   VALUE options = Qnil;
   xmlDocPtr xdoc;
   int indent = 1;
   const char *xencoding = "UTF-8";
-  xmlChar *buffer; 
+  xmlChar *buffer;
   int length;
 
   rb_scan_args(argc, argv, "01", &options);
@@ -826,10 +981,10 @@ static VALUE rxml_document_xinclude(VALUE self)
 
 /*
  * call-seq:
- *    document.order_elements! 
- * 
+ *    document.order_elements!
+ *
  * Call this routine to speed up XPath computation on static documents.
- * This stamps all the element nodes with the document order. 
+ * This stamps all the element nodes with the document order.
  */
 static VALUE rxml_document_order_elements(VALUE self)
 {
@@ -841,7 +996,7 @@ static VALUE rxml_document_order_elements(VALUE self)
 
 /*
  * call-seq:
- *    document.validate_schema(schema) 
+ *    document.validate_schema(schema)
  *
  * Validate this document against the specified XML::Schema.
  * If the document is valid the method returns true.  Otherwise an
@@ -874,7 +1029,7 @@ static VALUE rxml_document_validate_schema(VALUE self, VALUE schema)
 
 /*
  * call-seq:
- *    document.validate_relaxng(relaxng) 
+ *    document.validate_relaxng(relaxng)
  *
  * Validate this document against the specified XML::RelaxNG.
  * If the document is valid the method returns true.  Otherwise an
@@ -941,6 +1096,13 @@ void rxml_init_document(void)
   cXMLDocument = rb_define_class_under(mXML, "Document", rb_cObject);
   rb_define_alloc_func(cXMLDocument, rxml_document_alloc);
 
+  /* Original C14N 1.0 spec */
+  rb_define_const(cXMLDocument, "XML_C14N_1_0", INT2NUM(XML_C14N_1_0));
+  /* Exclusive C14N 1.0 spec */
+  rb_define_const(cXMLDocument, "XML_C14N_EXCLUSIVE_1_0", INT2NUM(XML_C14N_EXCLUSIVE_1_0));
+  /* C14N 1.1 spec */
+  rb_define_const(cXMLDocument, "XML_C14N_1_1", INT2NUM(XML_C14N_1_1));
+
   rb_define_method(cXMLDocument, "initialize", rxml_document_initialize, -1);
   rb_define_method(cXMLDocument, "canonicalize", rxml_document_canonicalize, -1);
   rb_define_method(cXMLDocument, "child", rxml_document_child_get, 0);

data/ext/libxml/ruby_xml_document.h

@@ -7,4 +7,5 @@ extern VALUE cXMLDocument;
 void rxml_init_document();
 VALUE rxml_document_wrap(xmlDocPtr xnode);
 
+typedef xmlChar * xmlCharPtr;
 #endif

data/ext/libxml/ruby_xml_encoding.c

@@ -164,27 +164,41 @@ VALUE rxml_encoding_to_rb_encoding(VALUE klass, VALUE encoding)
   rb_encoding* rbencoding = rxml_xml_encoding_to_rb_encoding(klass, xmlEncoding);
   return rb_enc_from_encoding(rbencoding);
 }
-#endif
-
 
-VALUE rxml_new_cstr(const char* xstr, const char* xencoding)
+rb_encoding* rxml_figure_encoding(const char* xencoding)
 {
-#ifdef HAVE_RUBY_ENCODING_H
-  rb_encoding* rbencoding;
+  rb_encoding* result;
   if (xencoding)
   {
     xmlCharEncoding xmlEncoding = xmlParseCharEncoding(xencoding);
-    rbencoding = rxml_xml_encoding_to_rb_encoding(mXMLEncoding, xmlEncoding);
+    result = rxml_xml_encoding_to_rb_encoding(mXMLEncoding, xmlEncoding);
   }
   else
   {
-    rbencoding = rb_utf8_encoding();
+    result = rb_utf8_encoding();
   }
+  return result;
+}
+#endif
+
+VALUE rxml_new_cstr(const char* xstr, const char* xencoding)
+{
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *rbencoding = rxml_figure_encoding(xencoding);
   return rb_external_str_new_with_enc(xstr, strlen(xstr), rbencoding);
 #endif
   return rb_str_new2(xstr);
 }
 
+VALUE rxml_new_cstr_len(const char* xstr, const int length, const char* xencoding)
+{
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *rbencoding = rxml_figure_encoding(xencoding);
+  return rb_external_str_new_with_enc(xstr, length, rbencoding);
+#endif
+  return rb_str_new(xstr, length);
+}
+
 void rxml_init_encoding(void)
 {
   mXMLEncoding = rb_define_module_under(mXML, "Encoding");

data/ext/libxml/ruby_xml_encoding.h

@@ -9,6 +9,7 @@ void rxml_init_encoding();
 
 // Ruby 1.8/1.9 encoding compatibility
 VALUE rxml_new_cstr(const char* xstr, const char* xencoding);
+VALUE rxml_new_cstr_len(const char* xstr, const int length, const char* xencoding);
 
 #ifdef HAVE_RUBY_ENCODING_H
 rb_encoding* rxml_xml_encoding_to_rb_encoding(VALUE klass, xmlCharEncoding xmlEncoding);

data/ext/libxml/ruby_xml_node.c

@@ -188,6 +188,43 @@ static VALUE rxml_node_new_comment(int argc, VALUE *argv, VALUE klass)
   return rxml_node_wrap(xnode);
 }
 
+/*
+ * call-seq:
+ *    XML::Node.new_pi(name, content = nil) -> XML::Node
+ *
+ * Create a new pi node, optionally setting
+ * the node's content.
+ *
+ */
+static VALUE rxml_node_new_pi(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE name = Qnil;
+  VALUE content = Qnil;
+  xmlNodePtr xnode;
+
+  rb_scan_args(argc, argv, "11", &name, &content);
+
+  if (NIL_P(name))
+  {
+    rb_raise(rb_eRuntimeError, "You must provide me with a name for a PI.");
+  }
+  name = rb_obj_as_string(name);
+  if (NIL_P(content))
+  {
+    xnode = xmlNewPI((xmlChar*) StringValuePtr(name), NULL);
+  }
+  else
+  {
+    content = rb_obj_as_string(content);
+    xnode = xmlNewPI((xmlChar*) StringValuePtr(name), (xmlChar*) StringValueCStr(content));
+  }
+
+  if (xnode == NULL)
+    rxml_raise(&xmlLastError);
+
+  return rxml_node_wrap(xnode);
+}
+
 /*
  * call-seq:
  *    XML::Node.new_text(content) -> XML::Node
@@ -1342,6 +1379,7 @@ void rxml_init_node(void)
 
   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_pi", rxml_node_new_pi, -1);
   rb_define_singleton_method(cXMLNode, "new_text", rxml_node_new_text, 1);
 
   /* Initialization */