rng 0.1.2 → 0.3.4

data/spec/rng/rnc_roundtrip_spec.rb

@@ -1,120 +1,134 @@
 # frozen_string_literal: true
 
-require "spec_helper"
+require 'spec_helper'
 
-RSpec.describe "RNG to RNC Round-trip Tests" do
-  describe "RNC Parser" do
-    it "exists as a class" do
-      expect(defined?(Rng::RncParser)).to eq("constant")
+RSpec.describe 'RNG to RNC Round-trip Tests' do
+  describe 'RNC Parser' do
+    it 'exists as a class' do
+      expect(defined?(Rng::RncParser)).to eq('constant')
     end
 
-    it "has a parse method" do
+    it 'has a parse method' do
       expect(Rng::RncParser).to respond_to(:parse)
     end
   end
 
-  describe "RNG to RNC Conversion" do
-    context "with simple schemas" do
-      let(:simple_rng) do
-        <<~XML
-          <element name="foo" xmlns="http://relaxng.org/ns/structure/1.0">
-            <empty/>
-          </element>
-        XML
+  describe 'RNG to RNC Conversion' do
+    context 'with the address book schema' do
+      let(:address_book_rng) do
+        File.read('spec/fixtures/rng/address_book.rng')
       end
 
-      it "can convert RNG to RNC" do
-        skip "RNG to RNC conversion not yet implemented"
-        rng_schema = Rng::Grammar.from_xml(simple_rng)
+      let(:address_book_rnc) do
+        File.read('spec/fixtures/rnc/address_book.rnc')
+      end
+
+      it 'can convert RNG to RNC' do
+        rng_schema = Rng.parse(address_book_rng)
         expect(rng_schema).not_to be_nil
 
-        # This would be the method to convert RNG to RNC
-        # rnc = Rng.to_rnc(rng_schema)
-        # expect(rnc).to include("element foo { empty }")
+        rnc = Rng.to_rnc(rng_schema)
+        expect(rnc).to include('element addressBook')
+        expect(rnc).to include('element card')
+        expect(rnc).to include('element name')
       end
 
-      it "can parse RNC back to RNG" do
-        skip "RNC parser not yet implemented"
-        "element foo { empty }"
+      it 'can parse RNC back to RNG' do
+        rng_schema = Rng.parse_rnc(address_book_rnc)
+        expect(rng_schema).to be_a(Rng::Grammar)
 
-        # This would be the method to parse RNC to RNG model
-        # rng_schema = Rng.parse_rnc(simple_rnc)
-        # expect(rng_schema).to be_a(Rng::Grammar)
-        # expect(rng_schema.element.name).to eq("foo")
+        xml = rng_schema.to_xml
+        expect(xml).to include('<grammar')
+        expect(xml).to include('name="addressBook"')
       end
 
-      it "supports round-trip conversion" do
-        skip "Round-trip conversion not yet implemented"
-        # rng_schema = Rng::Grammar.from_xml(simple_rng)
-        # rnc = Rng.to_rnc(rng_schema)
-        # rng_schema_from_rnc = Rng.parse_rnc(rnc)
+      it 'supports round-trip conversion' do
+        rng_schema = Rng.parse(address_book_rng)
+        rnc = Rng.to_rnc(rng_schema)
+        rng_schema_from_rnc = Rng.parse_rnc(rnc)
 
-        # Verify key properties are preserved
-        # expect(rng_schema_from_rnc.element.name).to eq(rng_schema.element.name)
+        expect(rng_schema_from_rnc).to be_a(Rng::Grammar)
+
+        xml = rng_schema_from_rnc.to_xml
+        expect(xml).to include('name="addressBook"')
+        expect(xml).to include('name="card"')
       end
     end
   end
 
-  describe "RNC to RNG Conversion" do
-    context "with the address book example" do
-      # This is a sample RNC representation of an address book
-      let(:address_book_rnc) do
-        <<~RNC
-          element addressBook {
-            element card {
-              element name { text },
-              element email { text },
-              element note { text }?
-            }*
-          }
-        RNC
-      end
-
-      # Sample expected XML output after conversion
-      let(:expected_rng_pattern) do
-        %r{<element.*name="addressBook".*>.*<element.*name="card".*>.*<element.*name="name".*>.*<text/>.*</element>.*<element.*name="email".*>.*<text/>.*</element>.*<optional>.*<element.*name="note".*>.*<text/>.*</element>.*</optional>.*</element>.*</element>}m
-      end
-
-      it "can convert RNC to RNG" do
-        skip "RNC to RNG conversion not yet implemented"
-        # xml_output = Rng::RncParser.parse(address_book_rnc)
-        # expect(xml_output).to match(expected_rng_pattern)
-
-        # Check if we can load the generated XML as a schema
-        # rng_schema = Rng::Grammar.from_xml(xml_output)
-        # expect(rng_schema).not_to be_nil
+  describe 'RNC to RNG Conversion' do
+    context 'with the address book example' do
+      it 'can convert RNC to RNG' do
+        rnc = File.read('spec/fixtures/rnc/address_book.rnc')
+        xml_output = Rng.parse_rnc(rnc).to_xml
+        expect(xml_output).to include('<grammar')
+        expect(xml_output).to include('xmlns="http://relaxng.org/ns/structure/1.0"')
+
+        # Verify it produces parseable RNG XML
+        rng_schema = Rng.parse(xml_output)
+        expect(rng_schema).to be_a(Rng::Grammar)
       end
     end
   end
 
-  describe "Round-trip with complex features" do
-    # Test cases for more complex RELAX NG features that should be preserved
-    # in round-trip conversion
-
-    describe "RELAX NG pattern features" do
-      it "preserves attribute definitions" do
-        skip "Feature not yet implemented"
-        # Test attribute handling
+  describe 'Round-trip with complex features' do
+    describe 'RELAX NG pattern features' do
+      it 'preserves attribute definitions' do
+        rnc = <<~RNC
+          start = element foo {
+            attribute bar { text },
+            element baz { text }
+          }
+        RNC
+        grammar = Rng.parse_rnc(rnc)
+        xml = grammar.to_xml
+        expect(xml).to include('<attribute')
+        expect(xml).to include('name="bar"')
       end
 
-      it "preserves choices" do
-        skip "Feature not yet implemented"
-        # Test choice patterns
+      it 'preserves choices' do
+        rnc = <<~RNC
+          start = element foo {
+            (element a { text } | element b { text })
+          }
+        RNC
+        grammar = Rng.parse_rnc(rnc)
+        xml = grammar.to_xml
+        expect(xml).to include('<choice')
       end
 
-      it "preserves interleave" do
-        skip "Feature not yet implemented"
-        # Test interleave patterns
+      it 'preserves interleave' do
+        rnc = <<~RNC
+          start = element foo {
+            element a { text } & element b { text }
+          }
+        RNC
+        grammar = Rng.parse_rnc(rnc)
+        xml = grammar.to_xml
+        expect(xml).to include('<interleave')
       end
 
-      it "preserves data types" do
-        skip "Feature not yet implemented"
-        # Test datatype definitions
+      it 'preserves data types' do
+        rnc = <<~RNC
+          start = element foo {
+            attribute count { xsd:integer }
+          }
+        RNC
+        grammar = Rng.parse_rnc(rnc)
+        xml = grammar.to_xml
+        expect(xml).to include('<data')
+        expect(xml).to include('integer')
       end
 
-      it "preserves namespaces" do
-        skip "Feature not yet implemented"
-        # Test namespace handling
+      it 'preserves namespaces' do
+        rnc = <<~RNC
+          default namespace = "http://example.org"
+          start = element foo { text }
+        RNC
+        grammar = Rng.parse_rnc(rnc)
+        xml = grammar.to_xml
+        expect(xml).to include('<grammar')
+        expect(grammar.ns).to eq('http://example.org')
       end
     end
   end

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