rng 0.1.2 → 0.3.3

data/spec/rng/roundtrip_spec.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Round-Trip Conversion' do
+  # Helper method to check if two Grammar objects are semantically equivalent
+  def grammars_equivalent?(grammar1, grammar2)
+    # Compare key structural elements
+    return false unless grammar1.instance_of?(grammar2.class)
+
+    # Compare start elements
+    if grammar1.start.any? && grammar2.start.any?
+      start1 = grammar1.start.first
+      start2 = grammar2.start.first
+
+      # Compare element names if they exist
+      return false if start1.element && start2.element && start1.element.attr_name != start2.element.attr_name
+    end
+
+    # Compare defines if they exist
+    if grammar1.define.any? && grammar2.define.any?
+      return false unless grammar1.define.length == grammar2.define.length
+
+      grammar1.define.zip(grammar2.define).each do |def1, def2|
+        return false unless def1.name == def2.name
+      end
+    end
+
+    true
+  end
+
+  describe 'RNG → RNC → RNG' do
+    context 'with address_book.rng' do
+      let(:original_rng) { File.read('spec/fixtures/rng/address_book.rng') }
+
+      it 'maintains semantic equivalence through round-trip' do
+        # Parse RNG
+        grammar1 = Rng.parse(original_rng)
+
+        # Convert to RNC
+        rnc = Rng.to_rnc(grammar1)
+        expect(rnc).to be_a(String)
+        expect(rnc).to include('element addressBook')
+
+        # Parse RNC back to Grammar
+        grammar2 = Rng.parse_rnc(rnc)
+
+        # Convert back to RNG
+        regenerated_rng = grammar2.to_xml
+
+        # Parse regenerated RNG
+        grammar3 = Rng.parse(regenerated_rng)
+
+        # Compare key structural elements
+        expect(grammar3.start.first.element.attr_name).to eq('addressBook')
+        expect(grammars_equivalent?(grammar1, grammar3)).to be true
+      end
+
+      it 'produces valid RNC syntax' do
+        grammar = Rng.parse(original_rng)
+        rnc = Rng.to_rnc(grammar)
+
+        # Should be parseable
+        expect { Rng.parse_rnc(rnc) }.not_to raise_error
+      end
+
+      it 'preserves element structure' do
+        grammar1 = Rng.parse(original_rng)
+        rnc = Rng.to_rnc(grammar1)
+        grammar2 = Rng.parse_rnc(rnc)
+
+        # Both should have addressBook element
+        expect(grammar1.start.first.element.attr_name).to eq('addressBook')
+        expect(grammar2.start.first.element.attr_name).to eq('addressBook')
+      end
+    end
+
+    context 'with simple RNG schemas' do
+      it 'handles single element schema' do
+        rng = <<~RNG
+          <grammar xmlns="http://relaxng.org/ns/structure/1.0">
+            <start>
+              <element name="root">
+                <text/>
+              </element>
+            </start>
+          </grammar>
+        RNG
+
+        grammar1 = Rng.parse(rng)
+        rnc = Rng.to_rnc(grammar1)
+        grammar2 = Rng.parse_rnc(rnc)
+        rng2 = grammar2.to_xml
+        grammar3 = Rng.parse(rng2)
+
+        expect(grammar3.start.first.element.attr_name).to eq('root')
+      end
+
+      it 'handles choice patterns' do
+        rng = <<~RNG
+          <grammar xmlns="http://relaxng.org/ns/structure/1.0">
+            <start>
+              <choice>
+                <element name="option1"><text/></element>
+                <element name="option2"><text/></element>
+              </choice>
+            </start>
+          </grammar>
+        RNG
+
+        grammar1 = Rng.parse(rng)
+        rnc = Rng.to_rnc(grammar1)
+
+        # NOTE: Current RNC builder converts choice to sequence in some cases
+        # This is a known limitation - choice should use | not ,
+        expect(rnc).to include('element option1')
+        expect(rnc).to include('element option2')
+
+        # Can still parse back
+        grammar2 = Rng.parse_rnc(rnc)
+        expect(grammar2).to be_a(Rng::Grammar)
+      end
+
+      it 'handles group patterns' do
+        rng = <<~RNG
+          <grammar xmlns="http://relaxng.org/ns/structure/1.0">
+            <start>
+              <group>
+                <element name="first"><text/></element>
+                <element name="second"><text/></element>
+              </group>
+            </start>
+          </grammar>
+        RNG
+
+        grammar1 = Rng.parse(rng)
+        rnc = Rng.to_rnc(grammar1)
+        grammar2 = Rng.parse_rnc(rnc)
+
+        expect(grammar2.start.first.group).not_to be_nil
+      end
+    end
+  end
+
+  describe 'RNC → RNG → RNC' do
+    context 'with address_book.rnc' do
+      let(:original_rnc) { File.read('spec/fixtures/rnc/address_book.rnc') }
+
+      it 'maintains semantic equivalence through round-trip' do
+        # Parse RNC
+        grammar1 = Rng.parse_rnc(original_rnc)
+
+        # Convert to RNG
+        rng = grammar1.to_xml
+        expect(rng).to include('<grammar')
+        expect(rng).to include('<element name="addressBook">')
+
+        # Parse RNG back to Grammar
+        grammar2 = Rng.parse(rng)
+
+        # Convert back to RNC
+        regenerated_rnc = Rng.to_rnc(grammar2)
+
+        # Parse regenerated RNC
+        grammar3 = Rng.parse_rnc(regenerated_rnc)
+
+        # Compare key structural elements
+        expect(grammar3.start.first.element.attr_name).to eq('addressBook')
+        expect(grammars_equivalent?(grammar1, grammar3)).to be true
+      end
+
+      it 'produces valid RNG XML' do
+        grammar = Rng.parse_rnc(original_rnc)
+        rng = grammar.to_xml
+
+        # Should be parseable
+        expect { Rng.parse(rng) }.not_to raise_error
+      end
+
+      it 'preserves element structure' do
+        grammar1 = Rng.parse_rnc(original_rnc)
+        rng = grammar1.to_xml
+        grammar2 = Rng.parse(rng)
+
+        # Both should have addressBook element
+        expect(grammar1.start.first.element.attr_name).to eq('addressBook')
+        expect(grammar2.start.first.element.attr_name).to eq('addressBook')
+      end
+    end
+
+    context 'with simple RNC schemas' do
+      it 'handles single element schema' do
+        rnc = <<~RNC
+          start = element root { text }
+        RNC
+
+        grammar1 = Rng.parse_rnc(rnc)
+        rng = grammar1.to_xml
+        grammar2 = Rng.parse(rng)
+        rnc2 = Rng.to_rnc(grammar2)
+        grammar3 = Rng.parse_rnc(rnc2)
+
+        expect(grammar3.start.first.element.attr_name).to eq('root')
+      end
+
+      it 'handles choice patterns (|)' do
+        rnc = <<~RNC
+          start = element option1 { text } | element option2 { text }
+        RNC
+
+        grammar1 = Rng.parse_rnc(rnc)
+        rng = grammar1.to_xml
+        grammar2 = Rng.parse(rng)
+
+        expect(grammar2.start.first.choice).not_to be_nil
+      end
+
+      it 'handles sequence patterns (,)' do
+        rnc = <<~RNC
+          start = element first { text }, element second { text }
+        RNC
+
+        grammar1 = Rng.parse_rnc(rnc)
+        rng = grammar1.to_xml
+        grammar2 = Rng.parse(rng)
+
+        expect(grammar2.start.first.group).not_to be_nil
+      end
+
+      it 'handles optional patterns (?)' do
+        rnc = <<~RNC
+          start = element optional { text }?
+        RNC
+
+        grammar1 = Rng.parse_rnc(rnc)
+        rng = grammar1.to_xml
+        grammar2 = Rng.parse(rng)
+
+        expect(grammar2.start.first.optional).not_to be_nil
+      end
+
+      it 'handles zero-or-more patterns (*)' do
+        rnc = <<~RNC
+          start = element item { text }*
+        RNC
+
+        grammar1 = Rng.parse_rnc(rnc)
+        rng = grammar1.to_xml
+        grammar2 = Rng.parse(rng)
+
+        expect(grammar2.start.first.zeroOrMore).not_to be_nil
+      end
+
+      it 'handles one-or-more patterns (+)' do
+        rnc = <<~RNC
+          start = element item { text }+
+        RNC
+
+        grammar1 = Rng.parse_rnc(rnc)
+        rng = grammar1.to_xml
+        grammar2 = Rng.parse(rng)
+
+        # oneOrMore can be either an array or a single object depending on parsing
+        one_or_more = grammar2.start.first.oneOrMore
+        expect(one_or_more).not_to be_nil
+        # Check if it's an array or single object
+        if one_or_more.is_a?(Array)
+          expect(one_or_more.length).to be > 0
+        else
+          expect(one_or_more).to be_a(Rng::OneOrMore)
+        end
+      end
+    end
+  end
+
+  describe 'XML comparison using canon matchers' do
+    context 'with formatted XML comparison' do
+      it 'recognizes equivalent formatted XML' do
+        rng1 = <<~RNG
+          <grammar xmlns="http://relaxng.org/ns/structure/1.0">
+            <start>
+              <element name="root"><text/></element>
+            </start>
+          </grammar>
+        RNG
+
+        grammar = Rng.parse(rng1)
+        rng2 = grammar.to_xml
+
+        # May differ in formatting but should be equivalent
+        expect(rng2).to be_xml_equivalent_to(rng1)
+      end
+    end
+  end
+
+  describe 'Format compatibility' do
+    it 'RNC and RNG represent the same schema' do
+      rnc = File.read('spec/fixtures/rnc/address_book.rnc')
+      rng = File.read('spec/fixtures/rng/address_book.rng')
+
+      grammar_from_rnc = Rng.parse_rnc(rnc)
+      grammar_from_rng = Rng.parse(rng)
+
+      # Both should parse successfully
+      expect(grammar_from_rnc).to be_a(Rng::Grammar)
+      expect(grammar_from_rng).to be_a(Rng::Grammar)
+
+      # Both should have the same root element
+      expect(grammar_from_rnc.start.first.element.attr_name).to eq('addressBook')
+      expect(grammar_from_rng.start.first.element.attr_name).to eq('addressBook')
+    end
+  end
+
+  describe 'Edge cases' do
+    it 'handles empty element' do
+      rnc = 'start = element root { empty }'
+      grammar = Rng.parse_rnc(rnc)
+      rng = grammar.to_xml
+      grammar2 = Rng.parse(rng)
+
+      expect(grammar2.start.first.element.empty).not_to be_nil
+    end
+
+    it 'handles attributes' do
+      rnc = 'start = element root { attribute id { text } }'
+      grammar = Rng.parse_rnc(rnc)
+      rng = grammar.to_xml
+      grammar2 = Rng.parse(rng)
+
+      expect(grammar2.start.first.element.attribute).not_to be_nil
+    end
+
+    it 'handles mixed content' do
+      rnc = 'start = element root { mixed { element child { text } } }'
+      grammar = Rng.parse_rnc(rnc)
+      rng = grammar.to_xml
+      grammar2 = Rng.parse(rng)
+
+      expect(grammar2.start.first.element.mixed).not_to be_nil
+    end
+  end
+end

data/spec/rng/schema_preamble_spec.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../../lib/rng/schema_preamble'
+
+RSpec.describe Rng::SchemaPreamble do
+  describe '#initialize' do
+    it 'creates an empty preamble' do
+      preamble = described_class.new
+
+      expect(preamble.namespaces).to be_empty
+      expect(preamble.datatypes).to be_empty
+      expect(preamble).to be_empty
+    end
+  end
+
+  describe '#add_namespace' do
+    it 'adds namespace declarations' do
+      preamble = described_class.new
+      ns1 = Rng::NamespaceDeclaration.new(uri: 'http://example.com',
+                                          is_default: true)
+      ns2 = Rng::NamespaceDeclaration.new(prefix: 'eg', uri: 'http://example.com/eg')
+
+      preamble.add_namespace(ns1)
+      preamble.add_namespace(ns2)
+
+      expect(preamble.namespaces).to contain_exactly(ns1, ns2)
+      expect(preamble).not_to be_empty
+    end
+  end
+
+  describe '#add_datatype' do
+    it 'adds datatype declarations' do
+      preamble = described_class.new
+      dt = Rng::DatatypeDeclaration.new(
+        prefix: 'xsd',
+        uri: 'http://www.w3.org/2001/XMLSchema-datatypes'
+      )
+
+      preamble.add_datatype(dt)
+
+      expect(preamble.datatypes).to contain_exactly(dt)
+      expect(preamble).not_to be_empty
+    end
+  end
+
+  describe '#default_namespace' do
+    it 'returns the default namespace URI' do
+      preamble = described_class.new
+      default_ns = Rng::NamespaceDeclaration.new(uri: 'http://example.com',
+                                                 is_default: true)
+      other_ns = Rng::NamespaceDeclaration.new(prefix: 'eg', uri: 'http://example.com/eg')
+
+      preamble.add_namespace(default_ns)
+      preamble.add_namespace(other_ns)
+
+      expect(preamble.default_namespace).to eq('http://example.com')
+    end
+
+    it 'returns nil when there is no default namespace' do
+      preamble = described_class.new
+      ns = Rng::NamespaceDeclaration.new(prefix: 'eg', uri: 'http://example.com')
+
+      preamble.add_namespace(ns)
+
+      expect(preamble.default_namespace).to be_nil
+    end
+  end
+
+  describe '#namespace_map' do
+    it 'returns a map of prefixed namespaces' do
+      preamble = described_class.new
+      ns1 = Rng::NamespaceDeclaration.new(prefix: 'eg', uri: 'http://example.com')
+      ns2 = Rng::NamespaceDeclaration.new(prefix: 'local', uri: '')
+      default_ns = Rng::NamespaceDeclaration.new(uri: 'http://default.com',
+                                                 is_default: true)
+
+      preamble.add_namespace(ns1)
+      preamble.add_namespace(ns2)
+      preamble.add_namespace(default_ns)
+
+      map = preamble.namespace_map
+      expect(map).to eq({
+                          'eg' => 'http://example.com',
+                          'local' => ''
+                        })
+    end
+
+    it 'returns empty hash when there are no prefixed namespaces' do
+      preamble = described_class.new
+      default_ns = Rng::NamespaceDeclaration.new(uri: 'http://example.com',
+                                                 is_default: true)
+
+      preamble.add_namespace(default_ns)
+
+      expect(preamble.namespace_map).to eq({})
+    end
+  end
+
+  describe '#datatype_map' do
+    it 'returns a map of datatype prefixes to URIs' do
+      preamble = described_class.new
+      dt1 = Rng::DatatypeDeclaration.new(prefix: 'xsd', uri: 'http://www.w3.org/2001/XMLSchema-datatypes')
+      dt2 = Rng::DatatypeDeclaration.new(prefix: 'custom', uri: 'http://example.com/types')
+
+      preamble.add_datatype(dt1)
+      preamble.add_datatype(dt2)
+
+      map = preamble.datatype_map
+      expect(map).to eq({
+                          'xsd' => 'http://www.w3.org/2001/XMLSchema-datatypes',
+                          'custom' => 'http://example.com/types'
+                        })
+    end
+
+    it 'returns empty hash when there are no datatypes' do
+      preamble = described_class.new
+      expect(preamble.datatype_map).to eq({})
+    end
+  end
+
+  describe '#empty?' do
+    it 'returns true when preamble has no declarations' do
+      preamble = described_class.new
+      expect(preamble).to be_empty
+    end
+
+    it 'returns false when preamble has namespace declarations' do
+      preamble = described_class.new
+      ns = Rng::NamespaceDeclaration.new(uri: 'http://example.com',
+                                         is_default: true)
+      preamble.add_namespace(ns)
+
+      expect(preamble).not_to be_empty
+    end
+
+    it 'returns false when preamble has datatype declarations' do
+      preamble = described_class.new
+      dt = Rng::DatatypeDeclaration.new(prefix: 'xsd', uri: 'http://www.w3.org/2001/XMLSchema-datatypes')
+      preamble.add_datatype(dt)
+
+      expect(preamble).not_to be_empty
+    end
+  end
+end