rng 0.1.1 → 0.1.2

data/spec/rng/rnc_parser_spec.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 RSpec.describe Rng::RncParser do
   let(:parser) { described_class.new }
 
-  describe "#parse" do
+  xdescribe "#parse" do
     context "with a simple RNC schema" do
       let(:input) do
         <<~RNC
@@ -18,10 +20,10 @@ RSpec.describe Rng::RncParser do
 
       it "correctly parses the schema" do
         result = parser.parse(input)
-        expect(result).to be_a(Rng::Schema)
+        expect(result).to be_a(Rng::Grammar)
         expect(result.start.elements.first.name).to eq("addressBook")
         expect(result.start.elements.first.elements.first.name).to eq("card")
-        expect(result.start.elements.first.elements.first.elements.map(&:name)).to eq(["name", "email"])
+        expect(result.start.elements.first.elements.first.elements.map(&:name)).to eq(%w[name email])
       end
     end
 
@@ -58,7 +60,7 @@ RSpec.describe Rng::RncParser do
       it "correctly parses nested elements" do
         result = parser.parse(input)
         expect(result.start.elements.first.name).to eq("root")
-        expect(result.start.elements.first.elements.map(&:name)).to eq(["child1", "child2"])
+        expect(result.start.elements.first.elements.map(&:name)).to eq(%w[child1 child2])
         expect(result.start.elements.first.elements.first.elements.first.name).to eq("grandchild")
       end
     end

data/spec/rng/rnc_roundtrip_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+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")
+    end
+
+    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
+      end
+
+      it "can convert RNG to RNC" do
+        skip "RNG to RNC conversion not yet implemented"
+        rng_schema = Rng::Grammar.from_xml(simple_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 }")
+      end
+
+      it "can parse RNC back to RNG" do
+        skip "RNC parser not yet implemented"
+        "element foo { empty }"
+
+        # 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")
+      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)
+
+        # Verify key properties are preserved
+        # expect(rng_schema_from_rnc.element.name).to eq(rng_schema.element.name)
+      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
+      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
+      end
+
+      it "preserves choices" do
+        skip "Feature not yet implemented"
+        # Test choice patterns
+      end
+
+      it "preserves interleave" do
+        skip "Feature not yet implemented"
+        # Test interleave patterns
+      end
+
+      it "preserves data types" do
+        skip "Feature not yet implemented"
+        # Test datatype definitions
+      end
+
+      it "preserves namespaces" do
+        skip "Feature not yet implemented"
+        # Test namespace handling
+      end
+    end
+  end
+end

data/spec/rng/schema_spec.rb

@@ -1,193 +1,142 @@
-require "spec_helper"
+# frozen_string_literal: true
 
-RSpec.describe Rng::Schema do
-  let(:rng_parser) { Rng::RngParser.new }
-  let(:rnc_parser) { Rng::RncParser.new }
-  let(:builder) { Rng::Builder.new }
+require "spec_helper"
 
-  describe "RNG parsing and building" do
+RSpec.describe Rng::Grammar do
+  describe "RNG parsing" do
     let(:rng_input) do
-      <<~RNG
-        <?xml version="1.0" encoding="UTF-8"?>
-        <element name="addressBook" xmlns="http://relaxng.org/ns/structure/1.0">
-          <zeroOrMore>
-            <element name="card">
-              <element name="name">
-                <text/>
-              </element>
-              <element name="email">
-                <text/>
-              </element>
-              <optional>
-                <element name="note">
-                  <text/>
-                </element>
-              </optional>
-            </element>
-          </zeroOrMore>
-        </element>
-      RNG
-    end
-
-    it "correctly parses and rebuilds RNG" do
-      parsed = rng_parser.parse(rng_input)
-      rebuilt = builder.build(parsed, format: :rng)
-      expect(normalize_xml(rebuilt)).to eq(normalize_xml(rng_input))
+      File.read("spec/fixtures/rng/address_book.rng")
+    end
+
+    it "correctly parses RNG" do
+      parsed = Rng.parse(rng_input)
+      expect(parsed).to be_a(Rng::Grammar)
+      expect(parsed.element).to be_empty
+      expect(parsed.start.element.attr_name).to eq("addressBook")
     end
   end
 
-  describe "RNC parsing and building" do
+  describe "Round-trip testing RNG" do
+    # Address Book Tests
+    let(:address_book_rng) do
+      File.read("spec/fixtures/rng/address_book.rng")
+    end
+
+    it "correctly round-trips address_book.rng (analogous comparison)" do
+      parsed = Rng::Grammar.from_xml(address_book_rng)
+      regenerated = parsed.to_xml
+      expect(regenerated).to be_analogous_with(address_book_rng)
+    end
+
+    it "correctly round-trips address_book.rng (formatted equivalent comparison)" do
+      parsed = Rng::Grammar.from_xml(address_book_rng)
+      regenerated = parsed.to_xml
+      expect(regenerated).to be_equivalent_to_xml(address_book_rng)
+    end
+
+    # RELAX NG Schema Tests
+    let(:relaxng_schema) do
+      File.read("spec/fixtures/rng/relaxng.rng")
+    end
+
+    it "correctly round-trips relaxng.rng (analogous comparison)" do
+      parsed = Rng::Grammar.from_xml(relaxng_schema)
+      regenerated = parsed.to_xml
+      expect(regenerated).to be_analogous_with(relaxng_schema)
+    end
+
+    it "correctly round-trips relaxng.rng (formatted equivalent comparison)" do
+      parsed = Rng::Grammar.from_xml(relaxng_schema)
+      regenerated = parsed.to_xml
+      expect(regenerated).to be_equivalent_to_xml(relaxng_schema)
+    end
+
+    # Test Suite Schema Tests
+    let(:test_suite_rng) do
+      File.read("spec/fixtures/rng/testSuite.rng")
+    end
+
+    it "correctly round-trips testSuite.rng (analogous comparison)" do
+      parsed = Rng::Grammar.from_xml(test_suite_rng)
+      regenerated = parsed.to_xml
+      expect(regenerated).to be_analogous_with(test_suite_rng)
+    end
+
+    it "correctly round-trips testSuite.rng (formatted equivalent comparison)" do
+      parsed = Rng::Grammar.from_xml(test_suite_rng)
+      regenerated = parsed.to_xml
+      expect(regenerated).to be_equivalent_to_xml(test_suite_rng)
+    end
+  end
+
+  xdescribe "RNC parsing" do
     let(:rnc_input) do
-      <<~RNC
-        element addressBook {
-          element card {
-            element name { text },
-            element email { text },
-            element note { text }?
-          }*
-        }
-      RNC
-    end
-
-    it "correctly parses and rebuilds RNC" do
-      parsed = rnc_parser.parse(rnc_input)
-      rebuilt = builder.build(parsed, format: :rnc)
-      expect(rebuilt.gsub(/\s+/, "")).to eq(rnc_input.gsub(/\s+/, ""))
+      File.read("spec/fixtures/rnc/address_book.rnc")
+    end
+
+    it "correctly parses RNC" do
+      parsed = Rng.parse_rnc(rnc_input)
+      expect(parsed).to be_a(Rng::Grammar)
+      expect(parsed.element).to be_a(Rng::Element)
+      expect(parsed.element.name).to eq("addressBook")
     end
   end
 
-  describe "RNG to RNC conversion" do
+  xdescribe "RNG to RNC conversion" do
     let(:rng_input) do
-      <<~RNG
-        <?xml version="1.0" encoding="UTF-8"?>
-        <element name="addressBook" xmlns="http://relaxng.org/ns/structure/1.0">
-          <zeroOrMore>
-            <element name="card">
-              <element name="name">
-                <text/>
-              </element>
-              <element name="email">
-                <text/>
-              </element>
-            </element>
-          </zeroOrMore>
-        </element>
-      RNG
-    end
-
-    let(:expected_rnc) do
-      <<~RNC
-        element addressBook {
-          element card {
-            element name { text },
-            element email { text }
-          }*
-        }
-      RNC
+      File.read("spec/fixtures/rng/address_book.rng")
     end
 
     it "correctly converts RNG to RNC" do
-      parsed = rng_parser.parse(rng_input)
-      rnc = builder.build(parsed, format: :rnc)
-      expect(rnc.gsub(/\s+/, "")).to eq(expected_rnc.gsub(/\s+/, ""))
+      parsed = Rng.parse(rng_input)
+      rnc = Rng.to_rnc(parsed)
+      expect(rnc).to include("element addressBook")
+      expect(rnc).to include("element card")
+      expect(rnc).to include("element name { text }")
+      expect(rnc).to include("element email { text }")
+      expect(rnc).to include("element note { text }?")
     end
   end
 
-  describe "RNC to RNG conversion" do
+  xdescribe "RNC to RNG conversion" do
     let(:rnc_input) do
-      <<~RNC
-        element addressBook {
-          element card {
-            element name { text },
-            element email { text }
-          }*
-        }
-      RNC
-    end
-
-    let(:expected_rng) do
-      <<~RNG
-        <element name="addressBook" xmlns="http://relaxng.org/ns/structure/1.0">
-          <zeroOrMore>
-            <element name="card">
-              <element name="name">
-                <text/>
-              </element>
-              <element name="email">
-                <text/>
-              </element>
-            </element>
-          </zeroOrMore>
-        </element>
-      RNG
+      File.read("spec/fixtures/rnc/address_book.rnc")
     end
 
     it "correctly converts RNC to RNG" do
-      parsed = rnc_parser.parse(rnc_input)
-      rng = builder.build(parsed, format: :rng)
-      expect(rng.gsub(/\s+/, "")).to eq(expected_rng.gsub(/\s+/, ""))
+      parsed = Rng.parse_rnc(rnc_input)
+      expect(parsed).to be_a(Rng::Grammar)
+      expect(parsed.element).to be_a(Rng::Element)
+      expect(parsed.element.name).to eq("addressBook")
     end
   end
 
-  describe "Complex schema parsing and building" do
-    let(:complex_rng_input) do
-      <<~RNG
-        <grammar xmlns="http://relaxng.org/ns/structure/1.0">
-          <start>
-            <ref name="addressBook"/>
-          </start>
-
-          <define name="addressBook">
-            <element name="addressBook">
-              <zeroOrMore>
-                <ref name="card"/>
-              </zeroOrMore>
-            </element>
-          </define>
-
-          <define name="card">
-            <element name="card">
-              <ref name="name"/>
-              <ref name="email"/>
-              <optional>
-                <ref name="note"/>
-              </optional>
-            </element>
-          </define>
-
-          <define name="name">
-            <element name="name">
-              <text/>
-            </element>
-          </define>
-
-          <define name="email">
-            <element name="email">
-              <text/>
-            </element>
-          </define>
-
-          <define name="note">
-            <element name="note">
-              <text/>
-            </element>
-          </define>
-        </grammar>
-      RNG
-    end
-
-    it "correctly parses and rebuilds complex RNG" do
-      parsed = rng_parser.parse(complex_rng_input)
-      rebuilt = builder.build(parsed, format: :rng)
-      expect(rebuilt.gsub(/\s+/, "")).to eq(complex_rng_input.gsub(/\s+/, ""))
-    end
-
-    it "correctly converts complex RNG to RNC" do
-      parsed = rng_parser.parse(complex_rng_input)
-      rnc = builder.build(parsed, format: :rnc)
-      reparsed = rnc_parser.parse(rnc)
-      rng_again = builder.build(reparsed, format: :rng)
-      expect(rng_again.gsub(/\s+/, "")).to eq(complex_rng_input.gsub(/\s+/, ""))
+  xdescribe "Round-trip testing RNG/RNC" do
+    let(:rng_input) do
+      File.read("spec/fixtures/rng/address_book.rng")
+    end
+
+    let(:rnc_input) do
+      File.read("spec/fixtures/rnc/address_book.rnc")
+    end
+
+    it "correctly round-trips RNG to RNC and back" do
+      parsed_rng = Rng.parse(rng_input)
+      rnc = Rng.to_rnc(parsed_rng)
+      parsed_rnc = Rng.parse_rnc(rnc)
+
+      # Compare key properties
+      expect(parsed_rnc.element.name).to eq(parsed_rng.element.name)
+    end
+
+    it "correctly round-trips RNC to RNG and back" do
+      parsed_rnc = Rng.parse_rnc(rnc_input)
+      rng_xml = Rng::RncParser.parse(rnc_input)
+      parsed_rng = Rng.parse(rng_xml)
+      Rng.to_rnc(parsed_rng)
+
+      # Compare key properties
+      expect(parsed_rng.element.name).to eq(parsed_rnc.element.name)
     end
   end
 end

data/spec/rng/spectest_spec.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "nokogiri"
+
+# Load the test suite XML file once for all tests
+SPEC_TEST_XML_PATH = "spec/fixtures/spectest.xml"
+SPEC_TEST_XML = Nokogiri::XML(File.read(SPEC_TEST_XML_PATH))
+
+def skip_if_foreign(test_desc)
+  return unless test_desc == "Section 3 compliance"
+
+  skip "lutaml-model does not allow arbitrary external XML"
+end
+
+# This helper function processes a test suite recursively and generates tests
+def process_test_suite(suite_element, context_description = "")
+  # Get documentation or section number for the context description
+  documentation = suite_element.xpath("./documentation").text.strip
+  section = suite_element.xpath("./section").text.strip
+
+  # Build context description
+  context_desc = context_description
+  if !documentation.empty?
+    context_desc || documentation
+  elsif !section.empty?
+    context_desc || "Section #{section}"
+  end
+
+  # Use a non-empty description
+  context_desc = "RELAX NG Test Suite" if context_desc.empty?
+
+  # Generate tests within a context
+  context(context_desc) do
+    # Process all test cases in this suite
+    suite_element.xpath("./testCase").each_with_index do |test_case, index|
+      test_documentation = test_case.xpath("./documentation").text.strip
+      test_section = test_case.xpath("./section").text.strip
+
+      # Create descriptive test name
+      test_desc = if !test_documentation.empty?
+                    test_documentation
+                  elsif !test_section.empty?
+                    "Section #{test_section} compliance"
+                  else
+                    "Schema validation"
+                  end
+
+      # Variable to store the last correct schema XML for validation tests
+      last_correct_schema_xml = nil
+
+      context(test_desc) do
+        # Test correct schemas
+        test_case.xpath("./correct").each do |correct_schema|
+          schema_xml = correct_schema.inner_html.strip
+
+          # Skip empty schemas
+          next if schema_xml.empty?
+
+          # Store for validation tests
+          last_correct_schema_xml = schema_xml
+
+          it "#{test_desc} - correct schema parsing ##{index + 1}" do
+            skip_if_foreign(test_desc)
+
+            schema = Rng::Grammar.from_xml(schema_xml)
+            expect(schema).not_to be_nil
+          rescue StandardError => e
+            raise "Expected schema to be valid but got: #{e.message}\nSchema:\n#{schema_xml}"
+          end
+
+          # Add round-trip test
+          it "#{test_desc} - correct schema round-trip ##{index + 1}" do
+            skip_if_foreign(test_desc)
+
+            skip "Skipping test for Section 4.11, test 1 due to <div>" if test_section == "4.11" && index + 1 == 1
+
+            # Parse the XML into a schema
+            # Parse the XML to determine the root element name
+            xml_doc = Nokogiri::XML(schema_xml)
+            root_element_name = xml_doc.root&.name
+
+            # Choose the appropriate class based on the root element name
+            schema = case root_element_name
+                     when "grammar"
+                       Rng::Grammar.from_xml(schema_xml)
+                     when "element"
+                       Rng::Element.from_xml(schema_xml)
+                     when "group"
+                       Rng::Group.from_xml(schema_xml)
+                     when "choice"
+                       Rng::Choice.from_xml(schema_xml)
+                     when "notAllowed"
+                       Rng::NotAllowed.from_xml(schema_xml)
+                     when "externalRef"
+                       Rng::ExternalRef.from_xml(schema_xml)
+                     else
+                       # Default to Schema for other cases
+                       raise "Unknown root element: #{root_element_name}"
+                     end
+
+            # Convert the schema back to XML
+            regenerated = schema.to_xml
+
+            # Verify the regenerated XML matches the original
+            expect(regenerated).to be_equivalent_to_xml(schema_xml)
+          end
+        end
+
+        # Test incorrect schemas
+        test_case.xpath("./incorrect").each do |incorrect_schema|
+          schema_xml = incorrect_schema.inner_html.strip
+
+          # Skip empty schemas
+          next if schema_xml.empty?
+
+          it "#{test_desc} - incorrect schema ##{index + 1}" do
+            skip "Schema validation not yet implemented"
+            # Once validation is implemented, uncomment:
+            # expect { Rng::Grammar.from_xml(schema_xml) }.to raise_error
+          end
+        end
+
+        # Test valid XML examples (for validation)
+        next unless last_correct_schema_xml
+
+        test_case.xpath("./valid").each do |valid_xml|
+          xml_content = valid_xml.inner_text.strip
+
+          # Skip empty XML
+          next if xml_content.empty?
+
+          it "#{test_desc} - valid XML example ##{index + 1}" do
+            skip "XML validation not yet implemented"
+            # Once validation is implemented, uncomment:
+            # schema = Rng::Grammar.from_xml(last_correct_schema_xml)
+            # expect(schema.valid?(xml_content)).to be true
+          end
+        end
+
+        # Test invalid XML examples (for validation)
+        test_case.xpath("./invalid").each do |invalid_xml|
+          xml_content = invalid_xml.inner_text.strip
+
+          # Skip empty XML
+          next if xml_content.empty?
+
+          it "#{test_desc} - invalid XML example ##{index + 1}" do
+            skip "XML validation not yet implemented"
+            # Once validation is implemented, uncomment:
+            # schema = Rng::Grammar.from_xml(last_correct_schema_xml)
+            # expect(schema.valid?(xml_content)).to be false
+          end
+        end
+      end
+    end
+
+    # Process nested test suites recursively
+    suite_element.xpath("./testSuite").each do |nested_suite|
+      process_test_suite(nested_suite, context_desc)
+    end
+  end
+end
+
+RSpec.describe "RELAX NG Specification Tests" do
+  # First, confirm the test file exists
+  it "finds the spectest.xml file" do
+    expect(File.exist?(SPEC_TEST_XML_PATH)).to be true
+  end
+
+  # Generate a summary of the test suite
+  describe "Test Suite Summary" do
+    it "contains test cases organized by section" do
+      sections = SPEC_TEST_XML.xpath("//section").map(&:text).uniq
+      puts "Found #{sections.length} sections with tests"
+
+      correct_count = SPEC_TEST_XML.xpath("//correct").count
+      incorrect_count = SPEC_TEST_XML.xpath("//incorrect").count
+      valid_count = SPEC_TEST_XML.xpath("//valid").count
+      invalid_count = SPEC_TEST_XML.xpath("//invalid").count
+
+      puts "Test suite contains:"
+      puts "- #{correct_count} correct schemas"
+      puts "- #{incorrect_count} incorrect schemas"
+      puts "- #{valid_count} valid XML examples"
+      puts "- #{invalid_count} invalid XML examples"
+
+      total = correct_count + incorrect_count
+      expect(total).to be > 0
+    end
+  end
+
+  # Start processing from the root test suite
+  process_test_suite(SPEC_TEST_XML.xpath("/testSuite").first)
+end