libxml-ruby 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 865194cd65ca9ad9a3ccc047d89b5a68186ef97f
-  data.tar.gz: 7d29d8cb6cd5d40cba78f171ac92d61f3b48d1d1
+SHA256:
+  metadata.gz: 81e91ce08249acf16aa724c8aee17e94f86c384d8f9564d983dcd23f91ab9649
+  data.tar.gz: d3f48115d66b97da8a9cda69efc5ca261974795906a98d60256eddd1c5f4d8ec
 SHA512:
-  metadata.gz: 0b68eca1f0ff9241250a1d9ac28f9bd34e744493e50d1728f0da43568b2a478ca75ced18899e13483076fd6da88716c62a8485acda4bb84e1f42e7b018d91433
-  data.tar.gz: dcc1043a0033995c6c0be3fc2cae266f9be82d436dd92ad7db76e616e5442353f7515a3bdb0e1ae84701eb3cb912950abadf339613215256ac0a339d2391b536
+  metadata.gz: aafb9a7cead282d2219162b12117b15ac0504106054f71a5c86c88490bcfcfd0f347312482699bed03b87051378fc3997c270adab84dbf50523088177f86da79
+  data.tar.gz: bff4aa7c451552565e9cf2a6af287c249228e63c955ee2e3e0fe89f45f86d8c5ce454c617e27aee31ca778c1fa6c56f3cd53b20664209f8a011d14560616c17a

data/HISTORY

@@ -1,5 +1,23 @@
 = Release History
 
+== 3.1.0 / 2018-02-03 Charlie Savage
+
+* Fix segmentation fault when adding one node to another node (Charlie Savage)
+* Fix deprecated "assert_equal(nil, expected)" calls. #148 and #151. (utilum)
+* Remove assigned but unused variables. #150 (utilum)
+* Add Gemfile. #146. (Dorian Marié)
+* Remove duplicate hash key in setup.rb. #147. (Dorian Marié)
+* Fix gemspec by requiring Date. #149 (utilum)
+* Restore default internal encoding after tests are completed. #123 (Charlie Savage)
+* Remove duplicate method definitions. #145. (Charlie Savage)
+* Remove SchemaElement#minOccurs and SchemaElement#maxOccurs since they actually did not work (Charlie Savage)
+* Rename test files to follow Ruby conventions (Charlie Savage)
+* Fix handling of node returned by Reader#expand. #142. (Charlie Savage)
+* Add Travis Build support (Charlie Savage)
+* Fix Fixnum deprecation (Charlie Savage)
+* Cleanup schema code (Charlie Savage)
+* Update Visual Studio project to 2017 (Charlie Savage)
+
 == 3.0.0 / 2017-02-07 Charlie Savage
 
 * Revamp how libxml-ruby manages memory.  Instead of trying to return the same ruby object for each xmlnode,

data/MANIFEST

@@ -122,40 +122,40 @@ test/model/shiporder.xml
 test/model/shiporder.xsd
 test/model/soap.xml
 test/model/xinclude.xml
-test/tc_attr.rb
-test/tc_attr_decl.rb
-test/tc_attributes.rb
-test/tc_deprecated_require.rb
-test/tc_document.rb
-test/tc_document_write.rb
-test/tc_dtd.rb
-test/tc_error.rb
-test/tc_html_parser.rb
-test/tc_namespace.rb
-test/tc_namespaces.rb
-test/tc_node.rb
-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
-test/tc_parser.rb
-test/tc_parser_context.rb
-test/tc_properties.rb
-test/tc_reader.rb
-test/tc_relaxng.rb
-test/tc_sax_parser.rb
-test/tc_schema.rb
-test/tc_traversal.rb
-test/tc_xinclude.rb
-test/tc_xml.rb
-test/tc_xpath.rb
-test/tc_xpath_context.rb
-test/tc_xpath_expression.rb
-test/tc_xpointer.rb
+test/test_attr.rb
+test/test_attr_decl.rb
+test/test_attributes.rb
+test/test_deprecated_require.rb
+test/test_document.rb
+test/test_document_write.rb
+test/test_dtd.rb
+test/test_error.rb
+test/test_html_parser.rb
+test/test_namespace.rb
+test/test_namespaces.rb
+test/test_node.rb
+test/test_node_cdata.rb
+test/test_node_comment.rb
+test/test_node_copy.rb
+test/test_node_edit.rb
+test/test_node_pi.rb
+test/test_node_text.rb
+test/test_node_write.rb
+test/test_node_xlink.rb
+test/test_parser.rb
+test/test_parser_context.rb
+test/test_properties.rb
+test/test_reader.rb
+test/test_relaxng.rb
+test/test_sax_parser.rb
+test/test_schema.rb
+test/test_traversal.rb
+test/test_xinclude.rb
+test/test_xml.rb
+test/test_xpath.rb
+test/test_xpath_context.rb
+test/test_xpath_expression.rb
+test/test_xpointer.rb
 test/test_suite.rb
 Rakefile
 HISTORY.rdoc

data/README.rdoc

@@ -11,7 +11,7 @@ We think libxml-ruby is the best XML library for Ruby because:
 * Conformance - It passes all 1800+ tests from the OASIS XML Tests Suite
 
 == Requirements
-libxml-ruby requires Ruby 1.8.4 or higher.  It depends on libxml2 to
+libxml-ruby requires Ruby 1.8.7 or higher.  It depends on libxml2 to
 function propoerly.  libxml2, in turn, depends on:
 
 * libm      (math routines: very standard)
@@ -118,6 +118,18 @@ libxml-ruby fully supports native, background Ruby threads.  This of course
 only applies to Ruby 1.9.x and higher since earlier versions of Ruby do not
 support native threads.
 
+== Tests
+
+To run tests you first need to build the shared libary:
+
+  rake compile
+
+Once you have build the shared libary, you can then run tests using rake:
+
+  rake test
+
++Travis build status: {<img src="https://travis-ci.org/xml4r/libxml-ruby.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/xml4r/libxml-ruby]
+
 == Performance
 In addition to being feature rich and conformation, the main reason
 people use libxml-ruby is for performance.  Here are the results 
@@ -186,3 +198,4 @@ and are no longer in scope (since if they were the document would not be freed).
 
 == License
 See LICENSE for license information.
+

data/Rakefile

@@ -16,13 +16,22 @@ spec = Gem::Specification.load("#{GEM_NAME}.gemspec")
 task :default => [:test]
 
 # Setup compile tasks
-Rake::ExtensionTask.new do |ext|
-  ext.gem_spec = spec
-  ext.name = SO_NAME
-  ext.ext_dir = "ext/libxml"
-  ext.lib_dir = "lib/#{RUBY_VERSION.sub(/\.\d$/, '')}"
-  ext.config_options << "--with-xml2-include=C:/msys64/mingw64/include/libxml2"
-  ext.config_options << "--with-zlib-dir=C:/msys64/mingw64"
+if RUBY_PLATFORM.match(/mswin32|mswin64|mingw32/)
+  Rake::ExtensionTask.new do |ext|
+    ext.gem_spec = spec
+    ext.name = SO_NAME
+    ext.ext_dir = "ext/libxml"
+    ext.lib_dir = "lib/#{RUBY_VERSION.sub(/\.\d$/, '')}"
+    ext.config_options << "--with-xml2-include=C:/msys64/mingw64/include/libxml2"
+  end
+else
+  Rake::ExtensionTask.new do |ext|
+    ext.gem_spec = spec
+    ext.name = SO_NAME
+    ext.ext_dir = "ext/libxml"
+    ext.lib_dir = "lib/#{RUBY_VERSION.sub(/\.\d$/, '')}"
+    ext.config_options << "--with-xml2-include=/usr/include/libxml2"
+  end
 end
 
 # Setup generic gem
@@ -32,7 +41,7 @@ Gem::PackageTask.new(spec) do |pkg|
 end
 
 # Setup Windows Gem
-if RUBY_PLATFORM.match(/win32|mingw32/)
+if RUBY_PLATFORM.match(/mswin32|mswin64|mingw32/)
   binaries = (FileList['lib/**/*.so',
                        'lib/**/*dll'])
 
@@ -77,5 +86,6 @@ end
 # Test Task
 Rake::TestTask.new do |t|
   t.libs << "test"
+  t.test_files = FileList['test/test*.rb'] - ['test/test_suite.rb']
   t.verbose = true
 end

data/ext/libxml/ruby_xml_error.c

@@ -158,7 +158,7 @@ static VALUE rxml_error_reset_handler(VALUE self)
   return self;
 }
 
-void rxml_raise(xmlErrorPtr xerror)
+NORETURN(void rxml_raise(xmlErrorPtr xerror))
 {
   /* Wrap error up as Ruby object and send it off to ruby */
   VALUE error = rxml_error_wrap(xerror);

data/ext/libxml/ruby_xml_error.h

@@ -7,6 +7,6 @@ extern VALUE eXMLError;
 
 void rxml_init_error();
 VALUE rxml_error_wrap(xmlErrorPtr xerror);
-void rxml_raise(xmlErrorPtr xerror);
+NORETURN(void rxml_raise(xmlErrorPtr xerror));
 
 #endif

data/ext/libxml/ruby_xml_node.c

@@ -57,7 +57,7 @@ static void rxml_node_free(xmlNodePtr xnode)
 
 void rxml_node_manage(xmlNodePtr xnode, VALUE node)
 {
-  RDATA(node)->dfree = rxml_node_free;
+  RDATA(node)->dfree = (RUBY_DATA_FUNC)rxml_node_free;
   xnode->_private = (void*)node;
 }
 
@@ -83,8 +83,11 @@ void rxml_node_mark(xmlNodePtr xnode)
 {
    if (xnode->doc)
    {
-     VALUE doc = (VALUE)xnode->doc->_private;
-     rb_gc_mark(doc);
+     if (xnode->doc->_private)
+	 {
+	   VALUE doc = (VALUE)xnode->doc->_private;
+	   rb_gc_mark(doc);
+	 }
    }
    else if (xnode->parent)
    {
@@ -120,8 +123,7 @@ VALUE rxml_node_wrap(xmlNodePtr xnode)
 
 static VALUE rxml_node_alloc(VALUE klass)
 {
-  /* Ruby is responsible for freeing this node not libxml but don't set
-     up mark and free yet until we assign the node. */
+  // This node was created from Ruby so we are responsible for freeing it not libxml
   return Data_Wrap_Struct(klass, rxml_node_mark, rxml_node_free, NULL);
 }
 
@@ -312,21 +314,18 @@ static VALUE rxml_node_modify_dom(VALUE self, VALUE target,
 
   xmlUnlinkNode(xtarget);
 
-  /* This target node could be freed here. */  
+  // Target is about to have a parent, so stop having ruby manage it.
+  rxml_node_unmanage(xtarget, target);
+
+  // This target node could be freed here and be replaced by a different node 
   xresult = xmlFunc(xnode, xtarget);
 
   if (!xresult)
-    rxml_raise(&xmlLastError);
-
-  /* Was the target freed? If yes, then wrap the new node */
-  if (xresult != xtarget)
-  {
-    RDATA(target)->data = xresult;
-  }
+	  rxml_raise(&xmlLastError);
 
-  // Target now has a parent so ruby should no longer manage its memory
-  rxml_node_unmanage(xresult, target);
-  xtarget->_private = NULL;
+  /* Assume the target was freed, we need to fix up the ruby object to point to the
+     newly returned node. */
+  RDATA(target)->data = xresult;
 
   return target;
 }

data/ext/libxml/ruby_xml_reader.c

@@ -23,7 +23,7 @@
  *  reader = XML::Reader.string("<foo><bar>1</bar><bar>2</bar><bar>3</bar></foo>")
  *  reader.read
  *  assert_equal('foo', reader.name)
- *  assert_equal(nil, reader.value)
+ *  assert_nil(reader.value)
  *
  *  3.times do |i|
  *    reader.read
@@ -995,7 +995,12 @@ static VALUE rxml_reader_expand(VALUE self)
   }
   else
   {
-    return rxml_node_wrap(xnode);
+	  /* We cannot call rxml_node_wrap here because its sets up a mark function
+	   for the node. But according to the libxml docs (http://xmlsoft.org/html/libxml-xmlreader.html#xmlTextReaderExpand)
+	   this is only valid until the next xmlTextReaderRead call.  At that point the node is freed (from reading
+	   the libxml2 source code.  So don't set a mark or free function, because they will get called in the next
+	   garbage collection run and cause a segfault.*/
+	return Data_Wrap_Struct(cXMLNode, NULL, NULL, xnode);
   }
 }
 

data/ext/libxml/ruby_xml_schema.c

@@ -8,7 +8,6 @@
 #include "ruby_xml_schema_attribute.h"
 #include "ruby_xml_schema_facet.h"
 
-
 /*
  * Document-class: LibXML::XML::Schema
  *
@@ -152,7 +151,6 @@ static VALUE rxml_schema_id(VALUE self)
   QNIL_OR_STRING(xschema->id)
 }
 
-
 static VALUE rxml_schema_document(VALUE self)
 {
   xmlSchemaPtr xschema;
@@ -162,21 +160,20 @@ static VALUE rxml_schema_document(VALUE self)
   return rxml_node_wrap(xmlDocGetRootElement(xschema->doc));
 }
 
-static void storeNs(xmlSchemaImportPtr import, VALUE self, xmlChar *nsname)
+static void scan_namespaces(xmlSchemaImportPtr ximport, VALUE array, xmlChar *nsname)
 {
-  VALUE schemas;
   xmlNodePtr xnode;
   xmlNsPtr xns;
 
-  schemas = rb_iv_get(self, "@namespaces");
-  if (import->doc) {
-    xnode = xmlDocGetRootElement(import->doc);
-
+  if (ximport->doc)
+  {
+    xnode = xmlDocGetRootElement(ximport->doc);
     xns = xnode->nsDef;
 
-    while (xns) {
-      VALUE anamespace = rxml_namespace_wrap(xns);
-      rb_ary_push(schemas, anamespace);
+    while (xns)
+	{
+      VALUE namespace = rxml_namespace_wrap(xns);
+      rb_ary_push(array, namespace);
       xns = xns->next;
     }
   }
@@ -184,95 +181,76 @@ static void storeNs(xmlSchemaImportPtr import, VALUE self, xmlChar *nsname)
 
 static VALUE rxml_schema_namespaces(VALUE self)
 {
-  VALUE schemas;
+  VALUE result;
   xmlSchemaPtr xschema;
 
   Data_Get_Struct(self, xmlSchema, xschema);
 
-  if (rb_iv_get(self, "@namespaces") == Qnil) {
-    schemas = rb_ary_new();
-    rb_iv_set(self, "@namespaces", schemas);
-    xmlHashScan(xschema->schemasImports, (xmlHashScanner) storeNs, (void *)self);
-  }
+  result = rb_ary_new();
+  xmlHashScan(xschema->schemasImports, (xmlHashScanner)scan_namespaces, (void *)result);
 
-  return rb_iv_get(self, "@namespaces");
+  return result;
 }
 
-static void storeType(xmlSchemaTypePtr type, VALUE self, xmlChar *name)
+static void scan_element(xmlSchemaElementPtr xelement, VALUE hash, xmlChar *name)
 {
-  VALUE types;
-  VALUE rtype;
-
-  types = rb_iv_get(self, "@types");
-  rtype = rxml_wrap_schema_type(type);
-
-  rb_hash_aset(types, rb_str_new2((const char*)name), rtype);
+  VALUE element = rxml_wrap_schema_element(xelement);
+  rb_hash_aset(hash, rb_str_new2((const char*)name), element);
 }
 
-static VALUE rxml_schema_collect_types(VALUE self);
-
-static VALUE rxml_schema_types(VALUE self)
+static VALUE rxml_schema_elements(VALUE self)
 {
-  VALUE types;
+  VALUE result = rb_hash_new();
   xmlSchemaPtr xschema;
 
   Data_Get_Struct(self, xmlSchema, xschema);
+  xmlHashScan(xschema->elemDecl, (xmlHashScanner)scan_element, (void *)result);
 
-  if (rb_iv_get(self, "@types") == Qnil) {
-    types = rb_hash_new();
-    rb_iv_set(self, "@types", types);
-    rxml_schema_collect_types(self);
-    if(xschema != NULL && xschema->typeDecl != NULL)
-      xmlHashScan(xschema->typeDecl, (xmlHashScanner) storeType, (void *)self);
-  }
-
-  return rb_iv_get(self, "@types");
+  return result;
 }
 
-static void storeElement(xmlSchemaElementPtr element, VALUE self, xmlChar *name)
+static void scan_type(xmlSchemaTypePtr xtype, VALUE hash, xmlChar *name)
 {
-  VALUE elements;
-  VALUE relement;
-
-  elements = rb_iv_get(self, "@elements");
-  relement = rxml_wrap_schema_element(element);
-  rb_hash_aset(elements, rb_str_new2((const char*)name), relement);
+	VALUE type = rxml_wrap_schema_type(xtype);
+	rb_hash_aset(hash, rb_str_new2((const char*)name), type);
 }
 
-static VALUE rxml_schema_elements(VALUE self)
+static VALUE rxml_schema_types(VALUE self)
 {
-  VALUE elements;
-  xmlSchemaPtr xschema;
+	VALUE result = rb_hash_new();
+	xmlSchemaPtr xschema;
 
-  Data_Get_Struct(self, xmlSchema, xschema);
+	Data_Get_Struct(self, xmlSchema, xschema);
 
-  if (rb_iv_get(self, "@elements") == Qnil) {
-    elements = rb_hash_new();
-    rb_iv_set(self, "@elements", elements);
-    xmlHashScan(xschema->elemDecl, (xmlHashScanner) storeElement, (void *)self);
-  }
+	if (xschema != NULL && xschema->typeDecl != NULL)
+	{
+		xmlHashScan(xschema->typeDecl, (xmlHashScanner)scan_type, (void *)result);
+	}
 
-  return rb_iv_get(self, "@elements");
+	return result;
 }
 
-static void collectSchemaTypes(xmlSchemaImportPtr import, VALUE self)
+static void collect_imported_types(xmlSchemaImportPtr import, VALUE result)
 {
-  if (import->imported && import->schema) {
-    xmlHashScan(import->schema->typeDecl, (xmlHashScanner) storeType, (void *)self);
+  if (import->imported && import->schema)
+  {
+    xmlHashScan(import->schema->typeDecl, (xmlHashScanner)scan_type, (void *)result);
   }
 }
 
-static VALUE rxml_schema_collect_types(VALUE self)
+static VALUE rxml_schema_imported_types(VALUE self)
 {
   xmlSchemaPtr xschema;
+  VALUE result = rb_hash_new();
 
   Data_Get_Struct(self, xmlSchema, xschema);
 
-  if(xschema){
-    xmlHashScan(xschema->schemasImports, (xmlHashScanner) collectSchemaTypes, (void *)self);
+  if (xschema)
+  {
+	  xmlHashScan(xschema->schemasImports, (xmlHashScanner)collect_imported_types, (void *)result);
   }
 
-  return Qnil;
+  return result;
 }
 
 void rxml_init_schema(void)
@@ -288,10 +266,10 @@ void rxml_init_schema(void)
   rb_define_method(cXMLSchema, "version", rxml_schema_version, 0);
   rb_define_method(cXMLSchema, "document", rxml_schema_document, 0);
 
-  rb_define_method(cXMLSchema, "_namespaces", rxml_schema_namespaces, 0);
-  rb_define_method(cXMLSchema, "_collect_types", rxml_schema_collect_types, 0);
-  rb_define_method(cXMLSchema, "types", rxml_schema_types, 0);
   rb_define_method(cXMLSchema, "elements", rxml_schema_elements, 0);
+  rb_define_method(cXMLSchema, "imported_types", rxml_schema_imported_types, 0);
+  rb_define_method(cXMLSchema, "namespaces", rxml_schema_namespaces, 0);
+  rb_define_method(cXMLSchema, "types", rxml_schema_types, 0);
 
   rxml_init_schema_facet();
   rxml_init_schema_element();