libxml-ruby 3.2.1 → 3.2.4

data/test/model/shiporder.rnc

@@ -5,9 +5,9 @@
 #
 namespace xsi = "http://www.w3.org/2001/XMLSchema-instance"
 
-start = shiporder
+start = shiporderType
 
-shiporder  = element shiporder { attribute orderid { text }, 
+shiporderType  = element shiporder { attribute orderid { text },
                                  attribute xsi:noNamespaceSchemaLocation { text }, 
                                orderperson, shipto, item* }
 

data/test/model/shiporder.rng

@@ -7,9 +7,9 @@
 -->
 <grammar xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://relaxng.org/ns/structure/1.0">
   <start>
-    <ref name="shiporder"/>
+    <ref name="shiporderType"/>
   </start>
-  <define name="shiporder">
+  <define name="shiporderType">
     <element name="shiporder">
       <attribute name="orderid"/>
       <attribute name="xsi:noNamespaceSchemaLocation"/>

data/test/model/shiporder.xsd

@@ -1,8 +1,12 @@
 <?xml version="1.0" encoding="iso-8859-1" ?>
 <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
-  <xs:element name="shiporder" type="shiporder"/>
 
-  <xs:complexType name="shiporder">
+  <xs:import namespace="http://xml4r.org/ibxml-ruby/test/shiporder"
+             schemaLocation="shiporder_import.xsd"/>
+
+  <xs:element name="shiporder" type="shiporderType"/>
+
+  <xs:complexType name="shiporderType">
     <xs:annotation>
       <xs:documentation>Shiporder type documentation</xs:documentation>
     </xs:annotation>
@@ -37,4 +41,4 @@
     <xs:attribute name="foo" default="1" type="xs:integer" use="optional"/>
     <xs:attribute name="bar" use="prohibited"/>
   </xs:complexType>
-</xs:schema>
+</xs:schema>

data/test/model/shiporder_bad.xsd

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="iso-8859-1" ?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+  <xs:element name="shiporder" type="shiporderType"/>
+
+  <xs:complexType name="shiporderType">
+    <xs:anntation>
+      <xs:documentation>Shiporder type documentation</xs:documentation>
+    </xs:anntation>
+    <xs:sequence>
+      <xs:element name="orderperson" type="xs:string">
+        <xs:annotation>
+          <xs:documentation>orderperson element documentation</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+      <xs:element name="shipto">
+        <xs:complexType>
+          <xs:sequence>
+            <xs:element name="name" type="xs:string"/>
+            <xs:element name="address" type="xs:string"/>
+            <xs:element name="city" type="xs:string"/>
+            <xs:element name="country" type="xs:string"/>
+          </xs:sequence>
+        </xs:complexType>
+      </xs:element>
+      <xs:element name="item" maxOccurs="unbounded">
+        <xs:complexType>
+          <xs:seq>
+            <xs:element name="title" type="xs:string"/>
+            <xs:element name="note" type="xs:string" minOccurs="0"/>
+            <xs:element name="quantity" type="xs:positiveInteger"/>
+            <xs:element name="price" type="xs:decimal"/>
+          </xs:seq>
+        </xs:complexType>
+      </xs:element>
+    </xs:sequence>
+    <xs:attribute name="orderid" type="xs:string" use="required"/>
+    <xs:attribute name="foo" default="1" type="xs:integer" use="optional"/>
+    <xs:attribute name="bar" use="prohibited"/>
+  </xs:complexType>
+</xs:schema>

data/test/model/shiporder_import.xsd

@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="iso-8859-1" ?>
+<xs:schema xmlns="http://xml4r.org/libxml-ruby/test/shiporder"
+           xmlns:xs="http://www.w3.org/2001/XMLSchema"
+           targetNamespace="http://xml4r.org/libxml-ruby/test/shiporder">
+
+  <xs:element name="shiporder" type="shiporderFooType"/>
+  <xs:complexType name="shiporderFooType">
+    <xs:annotation>
+      <xs:documentation>Shiporder type documentation for Testing of imported schema</xs:documentation>
+    </xs:annotation>
+    <xs:sequence>
+      <xs:element name="orderperson" type="xs:string">
+        <xs:annotation>
+          <xs:documentation>orderperson element documentation</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+      <xs:element name="shipto">
+        <xs:complexType>
+          <xs:sequence>
+            <xs:element name="name" type="xs:string"/>
+            <xs:element name="address" type="xs:string"/>
+            <xs:element name="city" type="xs:string"/>
+            <xs:element name="country" type="xs:string"/>
+            <xs:element name="phone" type="xs:string"/>
+          </xs:sequence>
+        </xs:complexType>
+      </xs:element>
+      <xs:element name="item" maxOccurs="unbounded">
+        <xs:complexType>
+          <xs:sequence>
+            <xs:element name="title" type="xs:string"/>
+            <xs:element name="note" type="xs:string" minOccurs="0"/>
+            <xs:element name="quantity" type="xs:positiveInteger"/>
+            <xs:element name="price" type="xs:decimal"/>
+            <xs:element name="discount" type="xs:decimal"/>
+          </xs:sequence>
+        </xs:complexType>
+      </xs:element>
+    </xs:sequence>
+    <xs:attribute name="orderid" type="xs:string" use="required"/>
+    <xs:attribute name="foo" default="1" type="xs:integer" use="optional"/>
+    <xs:attribute name="bar" type="xs:string" use="optional"/>
+    <xs:attribute name="xyzzy" type="xs:string" use="prohibited"/>
+  </xs:complexType>
+</xs:schema>

data/test/test_document.rb

@@ -126,6 +126,7 @@ class TestDocument < Minitest::Test
   def test_nonet
     xml_string = '<ruby_array uga="booga" foo="bar"><fixnum>one</fixnum><fixnum>two</fixnum></ruby_array>'
     xml = LibXML::XML::Document.string(xml_string, options: LibXML::XML::Parser::Options::NONET)
-    schema_document = LibXML::XML::Document.file('d:/src/libxml-ruby/test/model/atom.xml', options: LibXML::XML::Parser::Options::NONET)
+    file = File.join(File.dirname(__FILE__), 'model/atom.xml')
+    schema_document = LibXML::XML::Document.file(file, options: LibXML::XML::Parser::Options::NONET)
   end
 end

data/test/test_dtd.rb

@@ -84,7 +84,8 @@ class TestDtd < Minitest::Test
     assert_nil(error.file)
     assert_nil(error.line)
     assert_equal('invalid', error.str1)
-    assert_nil(error.str2)
+    # Different answers across operating systems
+    # assert_nil(error.str2)
     assert_nil(error.str3)
     assert_equal(0, error.int1)
     assert_equal(0, error.int2)

data/test/test_helper.rb

@@ -5,3 +5,9 @@
 require 'bundler/setup'
 require 'minitest/autorun'
 require 'libxml-ruby'
+
+def windows?
+  !(RbConfig::CONFIG['host_os'] =~ /mswin|mingw/).nil?
+end
+
+STDOUT.write "\nlibxml2: #{LibXML::XML::LIBXML_VERSION}\n#{RUBY_DESCRIPTION}\n\n"

data/test/test_parser.rb

@@ -271,7 +271,7 @@ class TestParser < Minitest::Test
     assert_equal('foz', error.str2)
     assert_nil(error.str3)
     assert_equal(1, error.int1)
-    assert_equal(20, error.int2)
+    assert([18, 20].include?(error.int2))
     assert_nil(error.node)
   end
 

data/test/test_parser_context.rb

@@ -127,12 +127,6 @@ class TestParserContext < Minitest::Test
     end
   end
 
-  if ENV['NOTWORKING']
-    def test_num_chars
-      assert_equal(17, context.num_chars)
-    end
-  end
-
   def test_replace_entities
     context = LibXML::XML::Parser::Context.new
     assert(!context.replace_entities?)
@@ -185,7 +179,7 @@ class TestParserContext < Minitest::Test
     assert_nil(context.name_node)
     assert_equal(0, context.name_depth)
     assert_equal(10, context.name_depth_max)
-    assert_equal(17, context.num_chars)
+    assert([0, 17].include?(context.num_chars))
     assert_equal(false, context.replace_entities?)
     assert_equal(1, context.space_depth)
     assert_equal(10, context.space_depth_max)

data/test/test_reader.rb

@@ -249,9 +249,10 @@ class TestReader < Minitest::Test
   end
 
   def test_bytes_consumed
+    ending_are_rn = File.binread(XML_FILE).include? "\r\n"
     reader = LibXML::XML::Reader.file(XML_FILE)
     reader.read
-    assert_equal(428, reader.byte_consumed)
+    assert_equal(ending_are_rn ? 428 : 416, reader.byte_consumed)
   end
 
   def test_node

data/test/test_sax_parser.rb

@@ -181,7 +181,7 @@ class TestSaxParser < Minitest::Test
     xml = File.read(saxtest_file)
     io = StringIO.new(xml)
     parser = LibXML::XML::SaxParser.io(io)
-    
+
     parser.callbacks = TestCaseCallbacks.new
     parser.parse
     verify(parser)
@@ -250,25 +250,32 @@ EOS
     result = parser.callbacks.result
 
     i = -1
+
+    base_err_msg = "Fatal error: (Premature end of data in tag Results line 1|EndTag: '<\\/' not found) at :2\\."
+    re_err_msg1 = /\A(error: )#{base_err_msg}\z/
+    re_err_msg2 = /\A#{base_err_msg}\z/
+
     assert_equal("startdoc", result[i+=1])
     assert_equal("start_element: Results, attr: {}", result[i+=1])
     assert_equal("start_element_ns: Results, attr: {}, prefix: , uri: , ns: {}", result[i+=1])
     assert_equal("characters: \n", result[i+=1])
-    assert_equal("error: Fatal error: EndTag: '</' not found at :2.", result[i+=1])
+    assert_match(re_err_msg1, result[i+=1])
     assert_equal("end_document", result[i+=1])
 
     refute_nil(error)
     assert_kind_of(LibXML::XML::Error, error)
-    assert_equal("Fatal error: EndTag: '</' not found at :2.", error.message)
+    assert_match(re_err_msg2, error.message)
     assert_equal(LibXML::XML::Error::PARSER, error.domain)
-    assert_equal(LibXML::XML::Error::LTSLASH_REQUIRED, error.code)
+
+    assert([LibXML::XML::Error::TAG_NOT_FINISHED, LibXML::XML::Error::LTSLASH_REQUIRED].include?(error.code))
     assert_equal(LibXML::XML::Error::FATAL, error.level)
     assert_nil(error.file)
     assert_equal(2, error.line)
-    assert_nil(error.str1)
+    # Sometimes this is nil and sometimes its not depending on OS and libxlm version
+    # assert_nil(error.str1)
     assert_nil(error.str2)
     assert_nil(error.str3)
-    assert_equal(0, error.int1)
+    assert([0, 1].include?(error.int1))
     assert_equal(1, error.int2)
     assert_nil(error.node)
   end

data/test/test_schema.rb

@@ -3,18 +3,19 @@
 require_relative './test_helper'
 
 class TestSchema < Minitest::Test
+  Import_NS = 'http://xml4r.org/libxml-ruby/test/shiporder'.freeze
+
   def setup
     file = File.join(File.dirname(__FILE__), 'model/shiporder.xml')
     @doc = LibXML::XML::Document.file(file)
+    schema_file = File.join(File.dirname(__FILE__), 'model/shiporder.xsd')
+    schema_doc = LibXML::XML::Document.file(schema_file)
+    @schema = LibXML::XML::Schema.document(schema_doc)
   end
 
   def teardown
     @doc = nil
-  end
-
-  def schema
-    document = LibXML::XML::Document.file(File.join(File.dirname(__FILE__), 'model/shiporder.xsd'))
-    LibXML::XML::Schema.document(document)
+    @schema = nil
   end
 
   def check_error(error)
@@ -33,11 +34,50 @@ class TestSchema < Minitest::Test
   end
 
   def test_load_from_doc
-    assert_instance_of(LibXML::XML::Schema, schema)
+    assert_instance_of(LibXML::XML::Schema, @schema)
+  end
+
+  def test_schema_load_from_uri
+    xlink_schema = LibXML::XML::Schema.new('http://www.w3.org/1999/xlink.xsd')
+    assert_instance_of(LibXML::XML::Schema, xlink_schema)
+    assert_instance_of(LibXML::XML::Schema::Element, xlink_schema.elements['title'])
+    assert_instance_of(LibXML::XML::Schema::Type, xlink_schema.types['titleEltType'])
+    assert_equal('http://www.w3.org/1999/xlink', xlink_schema.target_namespace)
+  end
+
+  def test_schema_from_string
+    schema_file = File.join(File.dirname(__FILE__), 'model/shiporder.xsd')
+    schema_from_str = LibXML::XML::Schema.from_string(File.read(schema_file))
+    assert_instance_of(LibXML::XML::Schema, schema_from_str)
+  end
+
+  def test_invalid_schema_doc
+    bad_schema_file = File.join(File.dirname(__FILE__), 'model/shiporder_bad.xsd')
+    bad_schema_doc = LibXML::XML::Document.file(bad_schema_file)
+    bad_schema = nil
+    ## Note: this type of error throws
+    begin
+      bad_schema = LibXML::XML::Schema.document(bad_schema_doc)
+    rescue LibXML::XML::Error => error
+      bad_schema = error
+      assert(error.message.match(/Error: Element '.*': The content is not valid. Expected is \(/))
+      assert_kind_of(LibXML::XML::Error, error)
+      assert_equal(LibXML::XML::Error::SCHEMASP, error.domain)
+      assert_equal(LibXML::XML::Error::SCHEMAP_S4S_ELEM_NOT_ALLOWED, error.code)
+      assert_equal(LibXML::XML::Error::ERROR, error.level)
+      assert(error.file.match(/shiporder_bad.xsd/))
+      assert_equal("Element '{http://www.w3.org/2001/XMLSchema}complexType'", error.str1)
+      refute_nil(error.str2)
+      assert_nil(error.str3)
+      assert_equal(0, error.int1)
+      assert_equal(0, error.int2)
+    end
+    ## Last but not least, make sure we threw an error
+    assert_instance_of(LibXML::XML::Error, bad_schema)
   end
 
   def test_doc_valid
-    assert(@doc.validate_schema(schema))
+    assert(@doc.validate_schema(@schema))
   end
 
   def test_doc_invalid
@@ -45,7 +85,7 @@ class TestSchema < Minitest::Test
     @doc.root << new_node
 
     error = assert_raises(LibXML::XML::Error) do
-      @doc.validate_schema(schema)
+      @doc.validate_schema(@schema)
     end
 
     check_error(error)
@@ -56,7 +96,7 @@ class TestSchema < Minitest::Test
 
   def test_reader_valid
     reader = LibXML::XML::Reader.string(@doc.to_s)
-    assert(reader.schema_validate(schema))
+    assert(reader.schema_validate(@schema))
 
     while reader.read
     end
@@ -74,7 +114,7 @@ class TestSchema < Minitest::Test
     reader = LibXML::XML::Reader.string(@doc.to_s)
 
     # Set a schema
-    assert(reader.schema_validate(schema))
+    assert(reader.schema_validate(@schema))
 
     while reader.read
     end
@@ -91,32 +131,55 @@ class TestSchema < Minitest::Test
 
   # Schema meta-data tests
   def test_elements
-    assert_instance_of(Hash, schema.elements)
-    assert_equal(1, schema.elements.length)
-    assert_instance_of(LibXML::XML::Schema::Element, schema.elements['shiporder'])
+    assert_instance_of(Hash, @schema.elements)
+    assert_equal(1, @schema.elements.length)
+    assert_instance_of(LibXML::XML::Schema::Element, @schema.elements['shiporder'])
   end
 
   def test_types
-    assert_instance_of(Hash, schema.types)
-    assert_equal(1, schema.types.length)
-    assert_instance_of(LibXML::XML::Schema::Type, schema.types['shiporder'])
+    assert_instance_of(Hash, @schema.types)
+    assert_equal(1, @schema.types.length)
+    assert_instance_of(LibXML::XML::Schema::Type, @schema.types['shiporderType'])
   end
 
   def test_imported_types
-    assert_instance_of(Hash, schema.imported_types)
-    assert_equal(1, schema.imported_types.length)
-    assert_instance_of(LibXML::XML::Schema::Type, schema.types['shiporder'])
+    assert_instance_of(Hash, @schema.imported_types)
+    assert_equal(2, @schema.imported_types.length)
+    assert_instance_of(LibXML::XML::Schema::Type, @schema.imported_types['shiporderType'])
+    assert_instance_of(LibXML::XML::Schema::Type, @schema.imported_types['shiporderFooType'])
+  end
+
+  def test_imported_ns_types
+    assert_instance_of(Hash, @schema.imported_ns_types)
+    assert_equal(2, @schema.imported_ns_types.length)
+    assert_equal(1, @schema.imported_ns_types[nil].length)
+    assert_equal(1, @schema.imported_ns_types[Import_NS].length)
+    assert_instance_of(LibXML::XML::Schema::Type, @schema.imported_ns_types[nil]['shiporderType'])
+    assert_instance_of(LibXML::XML::Schema::Type, @schema.imported_ns_types[Import_NS]['shiporderFooType'])
+  end
+
+  def test_imported_ns_elements
+    assert_instance_of(Hash, @schema.imported_ns_elements)
+    assert_equal(2, @schema.imported_ns_elements.length)
+    assert_equal(1, @schema.imported_ns_elements[nil].length)
+    assert_equal(1, @schema.imported_ns_elements[Import_NS].length)
+    assert_instance_of(LibXML::XML::Schema::Element, @schema.imported_ns_elements[nil]['shiporder'])
+    assert_instance_of(LibXML::XML::Schema::Element, @schema.imported_ns_elements[Import_NS]['shiporder'])
+    assert_equal('shiporderType', @schema.imported_ns_elements[nil]['shiporder'].type.name)
+    assert_equal('shiporderFooType', @schema.imported_ns_elements[Import_NS]['shiporder'].type.name)
   end
 
   def test_namespaces
-    assert_instance_of(Array, schema.namespaces)
-    assert_equal(1, schema.namespaces.length)
+    assert_instance_of(Array, @schema.namespaces)
+    ## For some reason, when importing another schema we end up with two xs->http://www.w3.org/2001/XMLSchema namespaces.
+    ## So, we expect 3 here (one for Import_NS and then two for the schema namespace.
+    assert_equal(3, @schema.namespaces.length)
   end
 
   def test_schema_type
-    type = schema.types['shiporder']
+    type = @schema.types['shiporderType']
 
-    assert_equal('shiporder', type.name)
+    assert_equal('shiporderType', type.name)
     assert_nil(type.namespace)
     assert_equal("Shiporder type documentation", type.annotation)
     assert_instance_of(LibXML::XML::Node, type.node)
@@ -130,22 +193,22 @@ class TestSchema < Minitest::Test
   end
 
   def test_schema_element
-    element = schema.types['shiporder'].elements['orderperson']
+    element = @schema.types['shiporderType'].elements['orderperson']
 
     assert_equal('orderperson', element.name)
     assert_nil(element.namespace)
     assert_equal("orderperson element documentation", element.annotation)
 
-    element = schema.types['shiporder'].elements['item']
+    element = @schema.types['shiporderType'].elements['item']
     assert_equal('item', element.name)
 
-    element = schema.types['shiporder'].elements['item'].type.elements['note']
+    element = @schema.types['shiporderType'].elements['item'].type.elements['note']
     assert_equal('note', element.name)
     assert_equal('string', element.type.name)
   end
 
   def test_schema_attributes
-    type = schema.types['shiporder']
+    type = @schema.types['shiporderType']
 
     assert_instance_of(Array, type.attributes)
     assert_equal(2, type.attributes.length)
@@ -153,14 +216,14 @@ class TestSchema < Minitest::Test
   end
 
   def test_schema_attribute
-    attribute = schema.types['shiporder'].attributes.first
+    attribute = @schema.types['shiporderType'].attributes.first
 
     assert_equal("orderid", attribute.name)
     assert_nil(attribute.namespace)
     assert_equal(1, attribute.occurs)
     assert_equal('string', attribute.type.name)
 
-    attribute = schema.types['shiporder'].attributes[1]
+    attribute = @schema.types['shiporderType'].attributes[1]
     assert_equal(2, attribute.occurs)
     assert_equal('1', attribute.default)
     assert_equal('integer', attribute.type.name)

data/test/test_xml.rb

@@ -167,11 +167,19 @@ class TestXml < Minitest::Test
   end
 
   def test_enabled_docbook
-    assert(LibXML::XML.enabled_docbook?)
+    if windows?
+      refute(LibXML::XML.enabled_docbook?)
+    else
+      assert(LibXML::XML.enabled_docbook?)
+    end
   end
 
   def test_enabled_ftp
-    assert(LibXML::XML.enabled_ftp?)
+    if windows?
+      refute(LibXML::XML.enabled_ftp?)
+    else
+      assert(LibXML::XML.enabled_ftp?)
+    end
   end
 
   def test_enabled_http
@@ -183,7 +191,8 @@ class TestXml < Minitest::Test
   end
 
   def test_enabled_iconv
-    assert(LibXML::XML.enabled_iconv?)
+    iconv_enabled = RUBY_PLATFORM !~ /darwin/
+    assert_equal(iconv_enabled, LibXML::XML.enabled_iconv?)
   end
 
   def test_enabled_memory_debug
@@ -241,7 +250,11 @@ class TestXml < Minitest::Test
   end
 
   def test_libxml_parser_features
-    assert_instance_of(Array, LibXML::XML.features)
+    if windows?
+      assert_nil(LibXML::XML.features)
+    else
+      assert_instance_of(Array, LibXML::XML.features)
+    end
   end
 
   def test_default_options

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: libxml-ruby
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.2.4
 platform: ruby
 authors:
 - Ross Bamform
@@ -11,10 +11,10 @@ authors:
 - Anurag Priyam
 - Charlie Savage
 - Ryan Johnson
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-05 00:00:00.000000000 Z
+date: 2022-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -50,7 +50,7 @@ description: |2
       Libxml-ruby's primary advantage over REXML is performance - if speed
       is your need, these are good libraries to consider, as demonstrated
       by the informal benchmark below.
-email: 
+email:
 executables: []
 extensions:
 - ext/libxml/extconf.rb
@@ -216,9 +216,10 @@ files:
 - test/model/shiporder.rng
 - test/model/shiporder.xml
 - test/model/shiporder.xsd
+- test/model/shiporder_bad.xsd
+- test/model/shiporder_import.xsd
 - test/model/soap.xml
 - test/model/xinclude.xml
-- test/test.xml
 - test/test_attr.rb
 - test/test_attr_decl.rb
 - test/test_attributes.rb
@@ -260,11 +261,11 @@ files:
 - test/test_xpath_context.rb
 - test/test_xpath_expression.rb
 - test/test_xpointer.rb
-homepage: http://xml4r.github.com/libxml-ruby
+homepage: https://xml4r.github.io/libxml-ruby/
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -279,14 +280,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.3.14
+signing_key:
 specification_version: 4
 summary: Ruby Bindings for LibXML2
 test_files:
 - test/test_attr.rb
-- test/test_attributes.rb
 - test/test_attr_decl.rb
+- test/test_attributes.rb
 - test/test_canonicalize.rb
 - test/test_deprecated_require.rb
 - test/test_document.rb

data/test/test.xml

@@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Name>François</Name>