libxml-ruby 2.9.0-x64-mingw32

data/test/model/shiporder.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shiporder orderid="889923"
+           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+           xsi:noNamespaceSchemaLocation="shiporder.xsd">
+  <orderperson>John Smith</orderperson>
+  <shipto>
+    <name>Ola Nordmann</name>
+    <address>Langgt 23</address>
+    <city>4000 Stavanger</city>
+    <country>Norway</country>
+  </shipto>
+  <item>
+    <title>Empire Burlesque</title>
+    <note>Special Edition</note>
+    <quantity>1</quantity>
+    <price>10.90</price>
+  </item>
+  <item>
+    <title>Hide your heart</title>
+    <quantity>1</quantity>
+    <price>9.90</price>
+  </item>
+</shiporder>

data/test/model/shiporder.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="shiporder"/>
+
+  <xs:complexType name="shiporder">
+    <xs:annotation>
+      <xs:documentation>Shiporder type documentation</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: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: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" use="prohibited"/>
+  </xs:complexType>
+</xs:schema>

data/test/model/soap.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<soap:Envelope
+      xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
+      xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+      soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">
+  <soap:Body>
+    <getManufacturerNamesResponse name="widgestRus" xmlns="http://services.somewhere.com">
+      <IDAndNameList xmlns="http://services.somewhere.com">
+        <ns1:IdAndName xmlns:ns1="http://domain.somewhere.com">
+          <id xmlns="http://domain.somewhere.com">1</id>
+          <name xmlns="http://domain.somewhere.com">man1</name>
+
+        </ns1:IdAndName>
+        <ns1:IdAndName xmlns:ns1="http://domain.somewhere.com">
+          <id xmlns="http://domain.somewhere.com">2</id>
+          <name xmlns="http://domain.somewhere.com">man2</name>
+
+        </ns1:IdAndName>
+        <ns1:IdAndName xmlns:ns1="http://domain.somewhere.com">
+          <id xmlns="http://domain.somewhere.com">3</id>
+          <name xmlns="http://domain.somewhere.com">man3</name>
+        </ns1:IdAndName>
+      </IDAndNameList>
+    </getManufacturerNamesResponse>
+  </soap:Body>
+</soap:Envelope>

data/test/model/xinclude.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0"?>
+<document xmlns:xi="http://www.w3.org/2001/XInclude">
+  <p>This libxml2 binding has the following project information:
+   <code><xi:include href="rubynet_project" parse="text"/></code></p>
+</document>

data/test/tc_attr.rb

@@ -0,0 +1,181 @@
+# encoding: UTF-8
+
+require './test_helper'
+
+class AttrNodeTest < Minitest::Test
+  def setup
+    xp = XML::Parser.string(<<-EOS)
+    <CityModel
+      xmlns="http://www.opengis.net/examples"
+      xmlns:city="http://www.opengis.net/examples"
+      xmlns:gml="http://www.opengis.net/gml"
+      xmlns:xlink="http://www.w3.org/1999/xlink"
+      xmlns:xsi="http://www.w3.org/2000/10/XMLSchema-instance"
+      xsi:schemaLocation="http://www.opengis.net/examples city.xsd">
+      <type>City</type>
+      <cityMember name="Cambridge" 
+                  xlink:type="simple"
+                  xlink:title="Trinity Lane"
+                  xlink:href="http://www.foo.net/cgi-bin/wfs?FeatureID=C10239"
+                  gml:remoteSchema="city.xsd#xpointer(//complexType[@name='RoadType'])"/>
+    </CityModel>
+    EOS
+    
+    @doc = xp.parse
+  end
+  
+  def teardown
+    @doc = nil
+  end
+  
+  def city_member
+    @doc.find('/city:CityModel/city:cityMember').first
+  end
+
+  def test_doc
+    refute_nil(@doc)
+    assert_equal(XML::Encoding::NONE, @doc.encoding)
+  end
+
+  def test_types
+    attribute = city_member.attributes.get_attribute('name')
+    assert_instance_of(XML::Attr, attribute)
+    assert_equal('attribute', attribute.node_type_name)
+  end
+
+  def test_name
+    attribute = city_member.attributes.get_attribute('name')
+    assert_equal('name', attribute.name)
+    assert_equal(Encoding::UTF_8, attribute.name.encoding) if defined?(Encoding)
+
+    attribute = city_member.attributes.get_attribute('href')
+    assert_equal('href', attribute.name)
+    assert_equal('xlink', attribute.ns.prefix)
+    assert_equal('http://www.w3.org/1999/xlink', attribute.ns.href)
+
+    attribute = city_member.attributes.get_attribute_ns('http://www.w3.org/1999/xlink', 'href')
+    assert_equal('href', attribute.name)
+    assert_equal('xlink', attribute.ns.prefix)
+    assert_equal('http://www.w3.org/1999/xlink', attribute.ns.href)
+  end
+
+  def test_value
+    attribute = city_member.attributes.get_attribute('name')
+    assert_equal('Cambridge', attribute.value)
+    assert_equal(Encoding::UTF_8, attribute.value.encoding) if defined?(Encoding)
+
+    attribute = city_member.attributes.get_attribute('href')
+    assert_equal('http://www.foo.net/cgi-bin/wfs?FeatureID=C10239', attribute.value)
+  end
+
+  def test_set_value
+    attribute = city_member.attributes.get_attribute('name')
+    attribute.value = 'London'
+    assert_equal('London', attribute.value)
+    assert_equal(Encoding::UTF_8, attribute.value.encoding) if defined?(Encoding)
+
+    attribute = city_member.attributes.get_attribute('href')
+    attribute.value = 'http://i.have.changed'
+    assert_equal('http://i.have.changed', attribute.value)
+    assert_equal(Encoding::UTF_8, attribute.value.encoding) if defined?(Encoding)
+  end
+
+  def test_set_nil
+    attribute = city_member.attributes.get_attribute('name')
+    assert_raises(TypeError) do
+      attribute.value = nil
+    end
+  end
+
+  def test_create
+    attributes = city_member.attributes
+    assert_equal(5, attributes.length)
+
+    attr = XML::Attr.new(city_member, 'size', '50,000')
+    assert_instance_of(XML::Attr, attr)
+
+    attributes = city_member.attributes
+    assert_equal(6, attributes.length)
+
+    assert_equal(attributes['size'], '50,000')
+  end
+
+  def test_create_on_node
+    attributes = city_member.attributes
+    assert_equal(5, attributes.length)
+
+    attributes['country'] = 'England'
+
+    attributes = city_member.attributes
+    assert_equal(6, attributes.length)
+
+    assert_equal(attributes['country'], 'England')
+  end
+
+  def test_create_ns
+    assert_equal(5, city_member.attributes.length)
+
+    ns = XML::Namespace.new(city_member, 'my_namepace', 'http://www.mynamespace.com')
+    attr = XML::Attr.new(city_member, 'rating', 'rocks', ns)
+    assert_instance_of(XML::Attr, attr)
+    assert_equal('rating', attr.name)
+    assert_equal('rocks', attr.value)
+
+    attributes = city_member.attributes
+    assert_equal(6, attributes.length)
+
+    assert_equal('rocks', city_member['rating'])
+  end
+
+  def test_remove
+    attributes = city_member.attributes
+    assert_equal(5, attributes.length)
+
+    attribute = attributes.get_attribute('name')
+    refute_nil(attribute.parent)
+    assert(attribute.parent?)
+
+    attribute.remove!
+    assert_equal(4, attributes.length)
+
+    attribute = attributes.get_attribute('name')
+    assert_nil(attribute)
+  end
+
+  def test_first
+    attribute = city_member.attributes.first
+    assert_instance_of(XML::Attr, attribute)
+    assert_equal('name', attribute.name)
+    assert_equal('Cambridge', attribute.value)
+
+    attribute = attribute.next
+    assert_instance_of(XML::Attr, attribute)
+    assert_equal('type', attribute.name)
+    assert_equal('simple', attribute.value)
+
+    attribute = attribute.next
+    assert_instance_of(XML::Attr, attribute)
+    assert_equal('title', attribute.name)
+    assert_equal('Trinity Lane', attribute.value)
+
+    attribute = attribute.next
+    assert_instance_of(XML::Attr, attribute)
+    assert_equal('href', attribute.name)
+    assert_equal('http://www.foo.net/cgi-bin/wfs?FeatureID=C10239', attribute.value)
+
+    attribute = attribute.next
+    assert_instance_of(XML::Attr, attribute)
+    assert_equal('remoteSchema', attribute.name)
+    assert_equal("city.xsd#xpointer(//complexType[@name='RoadType'])", attribute.value)
+
+    attribute = attribute.next
+    assert_nil(attribute)
+  end
+
+  def test_no_attributes
+    element = @doc.find('/city:CityModel/city:type').first
+
+    refute_nil(element.attributes)
+    assert_equal(0, element.attributes.length)
+  end
+end

data/test/tc_attr_decl.rb

@@ -0,0 +1,132 @@
+# encoding: UTF-8
+
+require './test_helper'
+
+class AttrDeclTest < Minitest::Test
+  def setup
+    xp = XML::Parser.string(<<-EOS)
+	<!DOCTYPE test [
+	  <!ELEMENT root (property*)>
+	  <!ELEMENT property EMPTY>
+	  <!ATTLIST property name       NMTOKEN          #REQUIRED>
+	  <!ATTLIST property access     (r | w | rw)    "rw">
+	]>
+	<root>
+	  <property name="readonly" access="r" />
+	  <property name="readwrite" />
+	</root>
+    EOS
+    @doc = xp.parse
+  end
+  
+  def teardown
+    @doc = nil
+  end
+
+  def test_attributes
+    # Get a element with an access attribute
+    elem = @doc.find_first('/root/property[@name="readonly"]')
+    assert_equal(2, elem.attributes.length)
+    refute_nil(elem['access'])
+
+    # Get a element node without a access attribute
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    assert_equal(1, elem.attributes.length)
+    assert_nil(elem['access'])
+  end
+
+  def test_attr
+    # Get a property node without a access attribute
+    elem = @doc.find_first('/root/property[@name="readonly"]')
+
+    # Get the attr_decl
+    attr = elem.attributes.get_attribute('access')
+    refute_nil(attr)
+    assert_equal(XML::Node::ATTRIBUTE_NODE, attr.node_type)
+    assert_equal('attribute', attr.node_type_name)
+
+    # Get its value
+    assert_equal('r', attr.value)
+  end
+
+  def test_attr_decl
+    # Get a property node without a access attribute
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+
+    # Get the attr_decl
+    attr_decl = elem.attributes.get_attribute('access')
+    refute_nil(attr_decl)
+    assert_equal(XML::Node::ATTRIBUTE_DECL, attr_decl.node_type)
+    assert_equal('attribute declaration', attr_decl.node_type_name)
+
+    # Get its value
+    assert_equal('rw', attr_decl.value)
+  end
+
+  def test_type
+    # Get a property node without a access attribute
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    attr_decl = elem.attributes.get_attribute('access')
+
+    refute_nil(attr_decl)
+    assert_equal(XML::Node::ATTRIBUTE_DECL, attr_decl.node_type)
+    assert_equal('attribute declaration', attr_decl.node_type_name)
+  end
+  
+  def test_name
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    attr_decl = elem.attributes.get_attribute('access')
+
+    assert_equal('access', attr_decl.name)
+  end
+
+  def test_value
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    attr_decl = elem.attributes.get_attribute('access')
+
+    assert_equal('rw', attr_decl.value)
+  end
+
+  def test_to_s
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    attr_decl = elem.attributes.get_attribute('access')
+
+    assert_equal('access = rw', attr_decl.to_s)
+  end
+
+  def test_prev
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    attr_decl = elem.attributes.get_attribute('access')
+
+    first_decl = attr_decl.prev
+    assert_equal(XML::Node::ATTRIBUTE_DECL, first_decl.node_type)
+    assert_equal('name', first_decl.name)
+    assert_nil(first_decl.value)
+
+    elem_decl = first_decl.prev
+    assert_equal(XML::Node::ELEMENT_DECL, elem_decl.node_type)
+  end
+
+  def test_next
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    attr_decl = elem.attributes.get_attribute('access')
+
+    next_decl = attr_decl.next
+    assert_nil(next_decl)
+  end
+
+  def test_doc
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    attr_decl = elem.attributes.get_attribute('access')
+
+    assert_same(@doc, attr_decl.doc)
+  end
+
+  def test_parent
+    elem = @doc.find_first('/root/property[@name="readwrite"]')
+    attr_decl = elem.attributes.get_attribute('access')
+
+    parent = attr_decl.parent
+    assert_instance_of(XML::Dtd, parent)
+  end
+end

data/test/tc_attributes.rb

@@ -0,0 +1,142 @@
+# encoding: UTF-8
+
+require './test_helper'
+
+class AttributesTest < Minitest::Test
+  def setup
+    xp = XML::Parser.string(<<-EOS)
+    <CityModel name="value"
+      xmlns="http://www.opengis.net/examples"
+      xmlns:city="http://www.opengis.net/examples"
+      xmlns:gml="http://www.opengis.net/gml"
+      xmlns:xlink="http://www.w3.org/1999/xlink"
+      xmlns:xsi="http://www.w3.org/2000/10/XMLSchema-instance"
+      xsi:schemaLocation="http://www.opengis.net/examples city.xsd">
+     <cityMember name="Cambridge" 
+                 xlink:type="simple"
+                 xlink:title="Trinity Lane"
+                 xlink:href="http://www.foo.net/cgi-bin/wfs?FeatureID=C10239"
+                 gml:remoteSchema="city.xsd#xpointer(//complexType[@name='RoadType'])"/>
+    </CityModel>
+    EOS
+    
+    @doc = xp.parse
+  end
+  
+  def teardown
+    @doc = nil
+  end
+  
+  def city_member
+    @doc.find('/city:CityModel/city:cityMember').first
+  end
+
+  def test_attributes
+    attributes = city_member.attributes
+    assert_instance_of(XML::Attributes, attributes)
+    assert_equal(5, attributes.length)
+  end
+
+  def test_each
+    attributes = city_member.attributes
+    length = attributes.inject(0) do |result, attr|
+      assert_instance_of(XML::Attr, attr)
+      result + 1
+    end
+    assert_equal(5, length)
+  end
+
+  def test_get_attribute
+    attributes = city_member.attributes
+
+    attr = attributes.get_attribute('name')
+    assert_instance_of(XML::Attr, attr)
+
+    attr = attributes.get_attribute('does_not_exist')
+    assert_nil(attr)
+
+    attr = attributes.get_attribute('name')
+    assert_instance_of(XML::Attr, attr)
+
+    attr = attributes.get_attribute('href')
+    assert_instance_of(XML::Attr, attr)
+    assert_instance_of(XML::Namespace, attr.ns)
+    assert_equal('xlink', attr.ns.prefix)
+    assert_equal('http://www.w3.org/1999/xlink', attr.ns.href)
+
+    attr = attributes.get_attribute_ns('http://www.w3.org/1999/xlink', 'href')
+    assert_instance_of(XML::Attr, attr)
+
+    attr = attributes.get_attribute_ns('http://www.opengis.net/gml', 'remoteSchema')
+    assert_instance_of(XML::Attr, attr)
+
+    attr = attributes.get_attribute_ns('http://i.dont.exist', 'nor do i')
+    assert_nil(attr)
+  end
+
+  def test_property
+    attr = city_member.property('name')
+    assert_instance_of(String, attr)
+    assert_equal('Cambridge', attr)
+  end
+
+  def test_get_values
+    assert_equal('Cambridge', city_member[:name])
+    assert_equal('http://www.foo.net/cgi-bin/wfs?FeatureID=C10239', city_member[:href])
+
+    attributes = city_member.attributes
+    assert_equal('Cambridge', attributes[:name])
+    assert_equal('http://www.foo.net/cgi-bin/wfs?FeatureID=C10239', attributes[:href])
+  end
+
+  def test_get_values_gc
+    # There used to be a bug caused by accessing an
+    # attribute over and over and over again.
+    20000.times do
+      @doc.root.attributes["key"]
+    end
+  end
+
+  def test_set_values
+    city_member[:name] = 'London'
+    assert_equal('London', city_member[:name])
+
+    city_member[:href] = 'foo'
+    assert_equal('foo', city_member[:href])
+
+    attributes = city_member.attributes
+
+    attributes[:name] = 'London'
+    assert_equal('London', attributes[:name])
+
+    attributes[:href] = 'foo'
+    assert_equal('foo', attributes[:href])
+  end
+
+  def test_str_sym()
+    attributes = city_member.attributes
+    assert_equal('Cambridge', attributes[:name])
+    assert_equal('Cambridge', attributes['name'])
+  end
+
+  def test_remove_first
+    attributes = @doc.find_first('/city:CityModel/city:cityMember').attributes
+    assert_equal(5, attributes.length)
+    attr = attributes.first
+    attr.remove!
+    assert_equal(4, attributes.length)
+  end
+
+  def test_remove_all
+    node = @doc.find_first('/city:CityModel/city:cityMember')
+    assert_equal(5, node.attributes.length)
+
+    attrs = Array.new
+    node.attributes.each do |attr|
+      attrs << attr
+      attr.remove!
+    end
+    assert_equal(5, attrs.length)
+    assert_equal(0, node.attributes.length)
+  end
+end