rng 0.1.1 → 0.3.3

data/spec/rng/rng_generation_spec.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'RNG Generation' do
+  describe 'Grammar.to_xml()' do
+    context 'with simple manually constructed schema' do
+      it 'generates valid RNG XML from a Grammar object' do
+        # Create simple grammar manually
+        grammar = Rng::Grammar.new
+        grammar.datatypeLibrary = 'http://www.w3.org/2001/XMLSchema-datatypes'
+
+        # Create start with element
+        start = Rng::Start.new
+        element = Rng::Element.new
+        element.attr_name = 'root'
+        text = Rng::Text.new
+        element.text = text
+        start.element = element
+        grammar.start = [start]
+
+        # Generate XML (note: to_xml() doesn't include XML declaration)
+        xml = grammar.to_xml
+
+        # Verify structure
+        expect(xml).to include('<grammar')
+        expect(xml).to include('xmlns="http://relaxng.org/ns/structure/1.0"')
+        expect(xml).to include('<start')
+        expect(xml).to include('<element name="root"')
+        expect(xml).to include('<text')
+        expect(xml).to include('</element>')
+        expect(xml).to include('</start>')
+        expect(xml).to include('</grammar>')
+      end
+
+      it 'handles namespace attributes correctly' do
+        grammar = Rng::Grammar.new
+        grammar.ns = 'http://example.com/ns'
+
+        xml = grammar.to_xml
+        expect(xml).to include('ns="http://example.com/ns"')
+      end
+
+      it 'handles datatype library attributes correctly' do
+        grammar = Rng::Grammar.new
+        grammar.datatypeLibrary = 'http://www.w3.org/2001/XMLSchema-datatypes'
+
+        xml = grammar.to_xml
+        expect(xml).to include('datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes"')
+      end
+    end
+
+    context 'with parsed RNG schema' do
+      let(:address_book_rng) { File.read('spec/fixtures/rng/address_book.rng') }
+
+      it 'regenerates XML from parsed RNG' do
+        parsed = Rng.parse(address_book_rng)
+        regenerated = parsed.to_xml
+
+        # Verify it's valid XML (note: to_xml() doesn't include XML declaration)
+        expect(regenerated).to include('<grammar')
+        expect(regenerated).to include('xmlns="http://relaxng.org/ns/structure/1.0"')
+
+        # Verify structure
+        expect(regenerated).to include('<start')
+        expect(regenerated).to include('<element name="addressBook"')
+        expect(regenerated).to include('name="cardContent"')
+      end
+
+      it 'maintains semantic equivalence (round-trip)' do
+        parsed = Rng.parse(address_book_rng)
+        regenerated = parsed.to_xml
+        reparsed = Rng.parse(regenerated)
+
+        # Verify key structure is maintained
+        expect(reparsed.start.first.element.attr_name).to eq('addressBook')
+        expect(reparsed.define.first.name).to eq('cardContent')
+      end
+    end
+
+    context 'with parsed RNC schema' do
+      let(:address_book_rnc) { File.read('spec/fixtures/rnc/address_book.rnc') }
+
+      it 'generates RNG XML from parsed RNC' do
+        parsed = Rng.parse_rnc(address_book_rnc)
+        xml = parsed.to_xml
+
+        # Verify it's valid RNG XML (note: to_xml() doesn't include XML declaration)
+        expect(xml).to include('<grammar')
+        expect(xml).to include('xmlns="http://relaxng.org/ns/structure/1.0"')
+        expect(xml).to include('<start')
+        expect(xml).to include('<element name="addressBook"')
+        # NOTE: Current RNC parser doesn't populate Grammar.define array
+        # It inlines pattern definitions instead of creating separate <define> elements
+        expect(xml).to include('<ref name="cardContent"')
+      end
+
+      it 'produces semantically valid schema' do
+        parsed = Rng.parse_rnc(address_book_rnc)
+        xml = parsed.to_xml
+        reparsed = Rng.parse(xml)
+
+        # Verify structure
+        expect(reparsed).to be_a(Rng::Grammar)
+        expect(reparsed.start.first.element.attr_name).to eq('addressBook')
+      end
+    end
+
+    context 'with special attribute values' do
+      it 'handles nil namespace (attribute omitted)' do
+        grammar = Rng::Grammar.new
+        grammar.ns = nil
+
+        xml = grammar.to_xml
+        # nil values cause the attribute to be omitted
+        expect(xml).not_to match(/\bns="/)
+      end
+
+      it 'handles nil datatype library (attribute omitted)' do
+        grammar = Rng::Grammar.new
+        grammar.datatypeLibrary = nil
+
+        xml = grammar.to_xml
+        # nil values cause the attribute to be omitted
+        expect(xml).not_to include('datatypeLibrary=')
+      end
+
+      it 'handles empty strings correctly' do
+        grammar = Rng::Grammar.new
+        grammar.ns = ''
+
+        xml = grammar.to_xml
+        expect(xml).to include('ns=""')
+      end
+    end
+
+    context 'with complex patterns' do
+      it 'handles choice patterns' do
+        grammar = Rng::Grammar.new
+        start = Rng::Start.new
+        choice = Rng::Choice.new
+
+        elem1 = Rng::Element.new
+        elem1.attr_name = 'option1'
+        elem1.text = Rng::Text.new
+
+        elem2 = Rng::Element.new
+        elem2.attr_name = 'option2'
+        elem2.text = Rng::Text.new
+
+        choice.element = [elem1, elem2]
+        start.choice = choice
+        grammar.start = [start]
+
+        xml = grammar.to_xml
+        expect(xml).to include('<choice>')
+        expect(xml).to include('<element name="option1">')
+        expect(xml).to include('<element name="option2">')
+      end
+
+      it 'handles group patterns' do
+        grammar = Rng::Grammar.new
+        start = Rng::Start.new
+        group = Rng::Group.new
+
+        elem1 = Rng::Element.new
+        elem1.attr_name = 'first'
+        elem1.text = Rng::Text.new
+
+        elem2 = Rng::Element.new
+        elem2.attr_name = 'second'
+        elem2.text = Rng::Text.new
+
+        group.element = [elem1, elem2]
+        start.group = group
+        grammar.start = [start]
+
+        xml = grammar.to_xml
+        expect(xml).to include('<group>')
+        expect(xml).to include('<element name="first">')
+        expect(xml).to include('<element name="second">')
+      end
+
+      it 'handles optional patterns' do
+        grammar = Rng::Grammar.new
+        start = Rng::Start.new
+        optional = Rng::Optional.new
+
+        elem = Rng::Element.new
+        elem.attr_name = 'optional'
+        elem.text = Rng::Text.new
+        optional.element = elem
+
+        start.optional = optional
+        grammar.start = [start]
+
+        xml = grammar.to_xml
+        expect(xml).to include('<optional>')
+        expect(xml).to include('<element name="optional">')
+      end
+
+      it 'handles zeroOrMore patterns' do
+        grammar = Rng::Grammar.new
+        start = Rng::Start.new
+        zero_or_more = Rng::ZeroOrMore.new
+
+        elem = Rng::Element.new
+        elem.attr_name = 'item'
+        elem.text = Rng::Text.new
+        zero_or_more.element = elem
+
+        start.zeroOrMore = zero_or_more
+        grammar.start = [start]
+
+        xml = grammar.to_xml
+        expect(xml).to include('<zeroOrMore>')
+        expect(xml).to include('<element name="item">')
+      end
+
+      it 'handles oneOrMore patterns' do
+        grammar = Rng::Grammar.new
+        start = Rng::Start.new
+        one_or_more = Rng::OneOrMore.new
+
+        elem = Rng::Element.new
+        elem.attr_name = 'item'
+        elem.text = Rng::Text.new
+        one_or_more.element = elem
+
+        start.oneOrMore = [one_or_more]
+        grammar.start = [start]
+
+        xml = grammar.to_xml
+        expect(xml).to include('<oneOrMore>')
+        expect(xml).to include('<element name="item">')
+      end
+    end
+
+    context 'with references' do
+      it 'handles ref patterns' do
+        grammar = Rng::Grammar.new
+
+        # Define pattern
+        define = Rng::Define.new
+        define.name = 'myPattern'
+        elem = Rng::Element.new
+        elem.attr_name = 'test'
+        elem.text = Rng::Text.new
+        define.element = elem
+        grammar.define = [define]
+
+        # Reference pattern
+        start = Rng::Start.new
+        ref = Rng::Ref.new
+        ref.name = 'myPattern'
+        start.ref = ref
+        grammar.start = [start]
+
+        xml = grammar.to_xml
+        expect(xml).to match(/<define[^>]+name="myPattern"/)
+        expect(xml).to include('<ref name="myPattern"')
+      end
+    end
+
+    context 'with attributes' do
+      it 'handles attribute patterns' do
+        grammar = Rng::Grammar.new
+        start = Rng::Start.new
+
+        elem = Rng::Element.new
+        elem.attr_name = 'root'
+
+        attr = Rng::Attribute.new
+        attr.attr_name = 'id'
+        attr.text = Rng::Text.new
+        elem.attribute = attr
+
+        start.element = elem
+        grammar.start = [start]
+
+        xml = grammar.to_xml
+        expect(xml).to include('<element name="root"')
+        expect(xml).to include('<attribute name="id"')
+        expect(xml).to include('<text/')
+      end
+    end
+  end
+end

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