rxerces 0.2.0 → 0.3.0

data/lib/rxerces/version.rb

@@ -1,3 +1,3 @@
 module RXerces
-  VERSION = "0.2.0".freeze
+  VERSION = "0.3.0".freeze
 end

data/rxerces.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name        = "rxerces"
-  spec.version     = "0.2.0"
+  spec.version     = "0.3.0"
   spec.author      = "Daniel J. Berger"
   spec.email       = "djberg96@gmail.com"
   spec.cert_chain  = ["certs/djberg96_pub.pem"]

data/spec/document_spec.rb

@@ -63,4 +63,39 @@ RSpec.describe RXerces::XML::Document do
       expect(result).to be_a(RXerces::XML::NodeSet)
     end
   end
+
+  describe "#create_element" do
+    let(:doc) { RXerces::XML::Document.parse(simple_xml) }
+
+    it "creates a new element with the specified name" do
+      element = doc.create_element('book')
+      expect(element).to be_a(RXerces::XML::Element)
+      expect(element.name).to eq('book')
+    end
+
+    it "creates an element that can have attributes set" do
+      element = doc.create_element('book')
+      attributes = element.attributes
+      expect(attributes).to be_a(Hash)
+      expect(attributes).to be_empty
+    end
+
+    it "creates an element that can have children added" do
+      element = doc.create_element('book')
+      element.add_child('Test Content')
+      expect(element.text).to eq('Test Content')
+    end
+
+    it "creates an element that can be added to the document" do
+      root = doc.root
+      new_element = doc.create_element('new_child')
+      new_element.add_child('New content')
+      root.add_child(new_element)
+
+      # Verify the new element is in the document
+      result = doc.xpath('//new_child')
+      expect(result.length).to eq(1)
+      expect(result.first.text).to eq('New content')
+    end
+  end
 end

data/spec/node_spec.rb

@@ -102,10 +102,371 @@ RSpec.describe RXerces::XML::Node do
     end
   end
 
+  describe "#parent" do
+    it "returns the parent node" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      parent = person.parent
+      expect(parent).to be_a(RXerces::XML::Element)
+      expect(parent.name).to eq('root')
+    end
+
+    it "returns the parent for nested elements" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      age = person.children.find { |n| n.name == 'age' }
+      parent = age.parent
+      expect(parent).to be_a(RXerces::XML::Element)
+      expect(parent.name).to eq('person')
+      expect(parent['id']).to eq('1')
+    end
+
+    it "returns the document for root element" do
+      parent = root.parent
+      expect(parent).not_to be_nil
+      expect(parent.name).to eq('#document')
+    end
+
+    it "returns nil for nodes without parent" do
+      # This is edge case - all nodes in a parsed document have parents
+      # but we test the safety of the method
+      expect(root.parent).not_to be_nil
+    end
+  end
+
+  describe "#attributes" do
+    it "returns a hash of attributes" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      attrs = person.attributes
+      expect(attrs).to be_a(Hash)
+      expect(attrs['id']).to eq('1')
+      expect(attrs['name']).to eq('Alice')
+    end
+
+    it "returns all attributes" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      attrs = person.attributes
+      expect(attrs.keys).to match_array(['id', 'name'])
+    end
+
+    it "returns empty hash for elements without attributes" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      age = person.children.find { |n| n.name == 'age' }
+      attrs = age.attributes
+      expect(attrs).to be_a(Hash)
+      expect(attrs).to be_empty
+    end
+
+    it "returns empty hash for text nodes" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      text_node = person.children.find { |n| n.is_a?(RXerces::XML::Text) }
+      attrs = text_node.attributes
+      expect(attrs).to be_a(Hash)
+      expect(attrs).to be_empty
+    end
+  end
+
+  describe "#next_sibling" do
+    it "returns the next sibling node" do
+      people = root.children.select { |n| n.is_a?(RXerces::XML::Element) }
+      first_person = people[0]
+      next_node = first_person.next_sibling
+
+      # May be a text node (whitespace) between elements
+      # Skip to next element if needed
+      while next_node && next_node.is_a?(RXerces::XML::Text)
+        next_node = next_node.next_sibling
+      end
+
+      expect(next_node).to be_a(RXerces::XML::Element)
+      expect(next_node.name).to eq('person')
+      expect(next_node['id']).to eq('2')
+    end
+
+    it "returns nil for last sibling" do
+      people = root.children.select { |n| n.is_a?(RXerces::XML::Element) }
+      last_person = people.last
+
+      # Navigate past any trailing whitespace
+      next_node = last_person.next_sibling
+      while next_node && next_node.is_a?(RXerces::XML::Text)
+        next_node = next_node.next_sibling
+      end
+
+      expect(next_node).to be_nil
+    end
+
+    it "can navigate through all siblings" do
+      first_element = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      siblings = []
+      current = first_element
+
+      while current
+        siblings << current if current.is_a?(RXerces::XML::Element)
+        current = current.next_sibling
+      end
+
+      expect(siblings.length).to eq(2)
+      expect(siblings[0]['id']).to eq('1')
+      expect(siblings[1]['id']).to eq('2')
+    end
+  end
+
+  describe "#previous_sibling" do
+    it "returns the previous sibling node" do
+      people = root.children.select { |n| n.is_a?(RXerces::XML::Element) }
+      second_person = people[1]
+      prev_node = second_person.previous_sibling
+
+      # May be a text node (whitespace) between elements
+      # Skip to previous element if needed
+      while prev_node && prev_node.is_a?(RXerces::XML::Text)
+        prev_node = prev_node.previous_sibling
+      end
+
+      expect(prev_node).to be_a(RXerces::XML::Element)
+      expect(prev_node.name).to eq('person')
+      expect(prev_node['id']).to eq('1')
+    end
+
+    it "returns nil for first sibling" do
+      first_element = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+
+      # Navigate past any leading whitespace
+      prev_node = first_element.previous_sibling
+      while prev_node && prev_node.is_a?(RXerces::XML::Text)
+        prev_node = prev_node.previous_sibling
+      end
+
+      expect(prev_node).to be_nil
+    end
+
+    it "can navigate backward through all siblings" do
+      last_element = root.children.select { |n| n.is_a?(RXerces::XML::Element) }.last
+      siblings = []
+      current = last_element
+
+      while current
+        siblings.unshift(current) if current.is_a?(RXerces::XML::Element)
+        current = current.previous_sibling
+      end
+
+      expect(siblings.length).to eq(2)
+      expect(siblings[0]['id']).to eq('1')
+      expect(siblings[1]['id']).to eq('2')
+    end
+  end
+
+  describe "#add_child" do
+    it "adds a text node from a string" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      initial_count = person.children.length
+
+      person.add_child("New text content")
+
+      expect(person.children.length).to eq(initial_count + 1)
+      last_child = person.children.last
+      expect(last_child).to be_a(RXerces::XML::Text)
+      expect(last_child.text).to eq("New text content")
+    end
+
+    it "adds a new element to another element" do
+      # Create a simple document to test with
+      simple_xml = '<root><parent></parent></root>'
+      simple_doc = RXerces::XML::Document.parse(simple_xml)
+      parent = simple_doc.root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+
+      # Add text child
+      parent.add_child("Hello World")
+
+      expect(parent.children.length).to be > 0
+      text_child = parent.children.find { |n| n.is_a?(RXerces::XML::Text) }
+      expect(text_child.text).to eq("Hello World")
+    end
+
+    it "allows building a document structure" do
+      simple_xml = '<root></root>'
+      simple_doc = RXerces::XML::Document.parse(simple_xml)
+      root = simple_doc.root
+
+      # Add multiple children
+      root.add_child("First text")
+      root.add_child("Second text")
+
+      text_nodes = root.children.select { |n| n.is_a?(RXerces::XML::Text) }
+      expect(text_nodes.length).to eq(2)
+      expect(text_nodes[0].text).to eq("First text")
+      expect(text_nodes[1].text).to eq("Second text")
+    end
+
+    it "modifies the document" do
+      simple_xml = '<item></item>'
+      simple_doc = RXerces::XML::Document.parse(simple_xml)
+      item = simple_doc.root
+
+      item.add_child("Content")
+
+      xml_output = simple_doc.to_s
+      expect(xml_output).to include("Content")
+    end
+  end
+
+  describe "#remove" do
+    it "removes a node from its parent" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      initial_count = root.children.select { |n| n.is_a?(RXerces::XML::Element) }.length
+
+      person.remove
+
+      remaining = root.children.select { |n| n.is_a?(RXerces::XML::Element) }
+      expect(remaining.length).to eq(initial_count - 1)
+    end
+
+    it "removes a child element from parent" do
+      person = root.children.find { |n| n.is_a?(RXerces::XML::Element) }
+      age = person.children.find { |n| n.name == 'age' }
+      initial_count = person.children.select { |n| n.is_a?(RXerces::XML::Element) }.length
+
+      age.remove
+
+      remaining = person.children.select { |n| n.is_a?(RXerces::XML::Element) }
+      expect(remaining.length).to eq(initial_count - 1)
+      expect(person.children.find { |n| n.name == 'age' }).to be_nil
+    end
+
+    it "modifies the document" do
+      simple_xml = '<root><item>Remove me</item><keep>Keep me</keep></root>'
+      simple_doc = RXerces::XML::Document.parse(simple_xml)
+      item = simple_doc.xpath('//item').first
+
+      item.remove
+
+      xml_output = simple_doc.to_s
+      expect(xml_output).not_to include("Remove me")
+      expect(xml_output).to include("Keep me")
+    end
+
+    it "raises error when node has no parent" do
+      # The root element's parent is the document, so this should work
+      # We'll test with a document node instead
+      expect {
+        root.parent.remove
+      }.to raise_error(RuntimeError, /no parent/)
+    end
+  end
+
+  describe "#unlink" do
+    it "is an alias for remove" do
+      simple_xml = '<root><item>Test</item></root>'
+      simple_doc = RXerces::XML::Document.parse(simple_xml)
+      item = simple_doc.xpath('//item').first
+
+      expect(item).to respond_to(:unlink)
+      item.unlink
+
+      xml_output = simple_doc.to_s
+      expect(xml_output).not_to include("Test")
+    end
+  end
+
   describe "#xpath" do
     it "returns a NodeSet" do
       result = root.xpath('.//age')
       expect(result).to be_a(RXerces::XML::NodeSet)
     end
   end
+
+  describe "#inner_html" do
+    it "returns the XML content of children without parent tags" do
+      person = root.xpath('//person').first
+      inner = person.inner_html
+      expect(inner).to include('<age>')
+      expect(inner).to include('<city>')
+      expect(inner).not_to include('<person')
+    end
+
+    it "returns empty string for nodes without children" do
+      age = root.xpath('//age').first
+      inner = age.inner_html
+      expect(inner).to eq('30')
+    end
+
+    it "includes multiple children" do
+      person = root.xpath('//person').first
+      inner = person.inner_html
+      expect(inner).to include('<age>30</age>')
+      expect(inner).to include('<city>New York</city>')
+    end
+  end
+
+  describe "#inner_xml" do
+    it "is an alias for inner_html" do
+      person = root.xpath('//person').first
+      expect(person.inner_xml).to eq(person.inner_html)
+    end
+
+    it "returns the same XML content" do
+      person = root.xpath('//person').first
+      inner = person.inner_xml
+      expect(inner).to include('<age>')
+      expect(inner).to include('<city>')
+    end
+  end
+
+  describe "#path" do
+    it "returns the XPath to the root element" do
+      expect(root.path).to eq('/root[1]')
+    end
+
+    it "returns the XPath to a nested element" do
+      person = root.xpath('//person').first
+      expect(person.path).to eq('/root[1]/person[1]')
+    end
+
+    it "returns the XPath to the second person element" do
+      people = root.xpath('//person')
+      second_person = people[1]
+      expect(second_person.path).to eq('/root[1]/person[2]')
+    end
+
+    it "returns the XPath to deeply nested elements" do
+      age = root.xpath('//age').first
+      expect(age.path).to eq('/root[1]/person[1]/age[1]')
+    end
+  end
+
+  describe "#blank?" do
+    let(:blank_xml) { '<root><empty></empty><whitespace>   </whitespace><content>Hello</content></root>' }
+    let(:blank_doc) { RXerces::XML::Document.parse(blank_xml) }
+
+    it "returns false for elements with text content" do
+      content = blank_doc.xpath('//content').first
+      expect(content.blank?).to be false
+    end
+
+    it "returns true for empty elements" do
+      empty = blank_doc.xpath('//empty').first
+      expect(empty.blank?).to be true
+    end
+
+    it "returns true for elements with only whitespace" do
+      whitespace = blank_doc.xpath('//whitespace').first
+      expect(whitespace.blank?).to be true
+    end
+
+    it "returns false for elements with child elements" do
+      root = blank_doc.root
+      expect(root.blank?).to be false
+    end
+
+    it "returns false for text nodes with content" do
+      content = blank_doc.xpath('//content').first
+      text_node = content.children.first
+      expect(text_node.blank?).to be false
+    end
+
+    it "returns true for text nodes with only whitespace" do
+      whitespace = blank_doc.xpath('//whitespace').first
+      text_node = whitespace.children.first
+      expect(text_node.blank?).to be true
+    end
+  end
 end

data/spec/nokogiri_compatibility_spec.rb

@@ -61,6 +61,12 @@ RSpec.describe "Nokogiri compatibility" do
     end
   end
 
+  describe "Nokogiri::XML::Schema" do
+    it "is an alias for RXerces::XML::Schema" do
+      expect(Nokogiri::XML::Schema).to eq(RXerces::XML::Schema)
+    end
+  end
+
   describe "API compatibility" do
     let(:doc) { Nokogiri.XML(simple_xml) }
 
@@ -95,4 +101,67 @@ RSpec.describe "Nokogiri compatibility" do
       expect(children).to be_an(Array)
     end
   end
+
+  describe "Schema validation compatibility" do
+    let(:xsd) do
+      <<~XSD
+        <?xml version="1.0"?>
+        <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+          <xs:element name="person">
+            <xs:complexType>
+              <xs:sequence>
+                <xs:element name="name" type="xs:string"/>
+                <xs:element name="age" type="xs:integer"/>
+              </xs:sequence>
+            </xs:complexType>
+          </xs:element>
+        </xs:schema>
+      XSD
+    end
+
+    let(:valid_xml) do
+      <<~XML
+        <?xml version="1.0"?>
+        <person>
+          <name>John</name>
+          <age>30</age>
+        </person>
+      XML
+    end
+
+    let(:invalid_xml) do
+      <<~XML
+        <?xml version="1.0"?>
+        <person>
+          <name>Jane</name>
+          <age>invalid</age>
+        </person>
+      XML
+    end
+
+    it "provides Schema.from_string method" do
+      schema = Nokogiri::XML::Schema.from_string(xsd)
+      expect(schema).to be_a(Nokogiri::XML::Schema)
+    end
+
+    it "provides Schema.from_document method" do
+      doc = Nokogiri::XML.parse(xsd)
+      schema = Nokogiri::XML::Schema.from_document(doc)
+      expect(schema).to be_a(Nokogiri::XML::Schema)
+    end
+
+    it "validates a valid document" do
+      schema = Nokogiri::XML::Schema.from_string(xsd)
+      doc = Nokogiri::XML.parse(valid_xml)
+      errors = doc.validate(schema)
+      expect(errors).to be_empty
+    end
+
+    it "returns errors for an invalid document" do
+      schema = Nokogiri::XML::Schema.from_string(xsd)
+      doc = Nokogiri::XML.parse(invalid_xml)
+      errors = doc.validate(schema)
+      expect(errors).not_to be_empty
+    end
+  end
 end

data/spec/rxerces_shared.rb

@@ -4,7 +4,7 @@ require 'rxerces'
 
 RSpec.shared_examples RXerces do
   example 'version number is set to the expected value' do
-    expect(RXerces::VERSION).to eq('0.2.0')
+    expect(RXerces::VERSION).to eq('0.3.0')
     expect(RXerces::VERSION).to be_frozen
   end
 end

data/spec/schema_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+RSpec.describe RXerces::XML::Schema do
+  let(:simple_xsd) do
+    <<~XSD
+      <?xml version="1.0" encoding="UTF-8"?>
+      <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+        <xs:element name="root">
+          <xs:complexType>
+            <xs:sequence>
+              <xs:element name="name" type="xs:string"/>
+              <xs:element name="age" type="xs:integer"/>
+            </xs:sequence>
+          </xs:complexType>
+        </xs:element>
+      </xs:schema>
+    XSD
+  end
+
+  let(:valid_xml) do
+    <<~XML
+      <?xml version="1.0"?>
+      <root>
+        <name>John</name>
+        <age>30</age>
+      </root>
+    XML
+  end
+
+  let(:invalid_xml) do
+    <<~XML
+      <?xml version="1.0"?>
+      <root>
+        <name>John</name>
+        <age>not-a-number</age>
+      </root>
+    XML
+  end
+
+  describe '.from_string' do
+    it 'creates a schema from an XSD string' do
+      schema = described_class.from_string(simple_xsd)
+      expect(schema).to be_a(described_class)
+    end
+
+    # Note: Xerces-C parser is very tolerant of invalid XML
+    # So we just skip testing for invalid XML for now
+  end
+
+  describe '.from_document' do
+    it 'creates a schema from a Document' do
+      schema_doc = RXerces::XML::Document.parse(simple_xsd)
+      schema = described_class.from_document(schema_doc)
+      expect(schema).to be_a(described_class)
+    end
+  end
+
+  describe 'validation' do
+    let(:schema) { described_class.from_string(simple_xsd) }
+
+    it 'validates a valid document' do
+      doc = RXerces::XML::Document.parse(valid_xml)
+      errors = doc.validate(schema)
+      expect(errors).to be_a(Array)
+      expect(errors).to be_empty
+    end
+
+    it 'returns validation errors for an invalid document' do
+      doc = RXerces::XML::Document.parse(invalid_xml)
+      errors = doc.validate(schema)
+      expect(errors).to be_a(Array)
+      expect(errors).not_to be_empty
+      expect(errors.first).to include('not-a-number')
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rxerces
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Daniel J. Berger
@@ -93,6 +93,7 @@ files:
 - Rakefile
 - certs/djberg96_pub.pem
 - examples/basic_usage.rb
+- examples/schema_example.rb
 - examples/simple_example.rb
 - examples/xpath_example.rb
 - ext/rxerces/extconf.rb
@@ -109,6 +110,7 @@ files:
 - spec/nokogiri_compatibility_spec.rb
 - spec/rxerces_shared.rb
 - spec/rxerces_spec.rb
+- spec/schema_spec.rb
 - spec/spec_helper.rb
 - spec/xpath_spec.rb
 homepage: http://github.com/djberg96/rxerces
@@ -148,4 +150,5 @@ test_files:
 - spec/nodeset_spec.rb
 - spec/nokogiri_compatibility_spec.rb
 - spec/rxerces_spec.rb
+- spec/schema_spec.rb
 - spec/xpath_spec.rb

metadata.gz.sig

@@ -1,2 +1,2 @@
-*P�]���/���d�E���/'�*L��Ư��?]�ZmZ�u,�_�W����q���jí�Ͷ2�O�1���{��iI��7���"�	�����+��b�>�B���
-s��P}(]�����J�4����kӺP^��&9m����[N3i�pֲ�MK���Ǒ��D� �Qz��%eR���.|U�u�6O!ku�ma���Á}��W~���/�z�;�n��HU�
+Q� �q
��o�{�;?��-6��%�:��-ܪB�h�y,�P�U}�#loyp�w��c����M@X+>��]U�.��<z5��a'�m�z]G���1laA�x���w�V�`���b6��U�����s��z��=u��$�6��Vj6��~��x:�����
+O��Е>d~�s��cYs����	������tHgd�%�Y��@TtcԁI��S