rng 0.1.1 → 0.3.3

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

data/spec/rng/schema_spec.rb

@@ -1,193 +1,146 @@
-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(described_class)
+      expect(parsed.element).to be_empty
+      expect(parsed.start.first.element.attr_name).to eq('addressBook')
+    end
+  end
+
+  describe 'Round-trip testing RNG' do
+    # Address Book Tests
+    let(:address_book_rng) do
+      File.read('spec/fixtures/rng/address_book.rng')
+    end
+
+    # Test Suite Schema Tests
+    let(:test_suite_rng) do
+      File.read('spec/fixtures/rng/testSuite.rng')
+    end
+    # RELAX NG Schema Tests
+    let(:relaxng_schema) do
+      File.read('spec/fixtures/rng/relaxng.rng')
+    end
+
+    it 'correctly round-trips address_book.rng (analogous comparison)' do
+      parsed = described_class.from_xml(address_book_rng)
+      regenerated = parsed.to_xml
+      expect(regenerated.gsub(/<!--.*?-->/m, '')).to be_xml_equivalent_to(address_book_rng.gsub(/<!--.*?-->/m, ''))
+    end
+
+    it 'correctly round-trips address_book.rng (formatted equivalent comparison)' do
+      parsed = described_class.from_xml(address_book_rng)
+      regenerated = parsed.to_xml
+      expect(regenerated).to be_xml_equivalent_to(address_book_rng)
+    end
+
+    it 'correctly round-trips relaxng.rng (analogous comparison)' do
+      parsed = described_class.from_xml(relaxng_schema)
+      regenerated = parsed.to_xml
+      # Strip comments for comparison since Lutaml doesn't preserve them
+      expect(regenerated.gsub(/<!--.*?-->/m, '')).to be_xml_equivalent_to(relaxng_schema.gsub(/<!--.*?-->/m, ''))
+    end
+
+    it 'correctly round-trips relaxng.rng (formatted equivalent comparison)' do
+      parsed = described_class.from_xml(relaxng_schema)
+      regenerated = parsed.to_xml
+      expect(regenerated.gsub(/<!--.*?-->/m, '')).to be_xml_equivalent_to(relaxng_schema.gsub(/<!--.*?-->/m, ''))
+    end
+
+    it 'correctly round-trips testSuite.rng (analogous comparison)' do
+      parsed = described_class.from_xml(test_suite_rng)
+      regenerated = parsed.to_xml
+      expect(regenerated.gsub(/<!--.*?-->/m, '')).to be_xml_equivalent_to(test_suite_rng.gsub(/<!--.*?-->/m, ''))
+    end
+
+    it 'correctly round-trips testSuite.rng (formatted equivalent comparison)' do
+      parsed = described_class.from_xml(test_suite_rng)
+      regenerated = parsed.to_xml
+      expect(regenerated.gsub(/<!--.*?-->/m, '')).to be_xml_equivalent_to(test_suite_rng.gsub(/<!--.*?-->/m, ''))
     end
   end
 
-  describe "RNC parsing and building" do
+  describe '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(described_class)
+      start_element = parsed.start.first.element
+      expect(start_element).to be_a(Rng::Element)
+      expect(start_element.attr_name).to eq('addressBook')
     end
   end
 
-  describe "RNG to RNC conversion" do
+  describe '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
-    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+/, ""))
+      File.read('spec/fixtures/rng/address_book.rng')
+    end
+
+    it 'correctly converts RNG to RNC' do
+      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')
+      expect(rnc).to include('element email')
     end
   end
 
-  describe "RNC to RNG conversion" do
+  describe '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
-    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+/, ""))
+      File.read('spec/fixtures/rnc/address_book.rnc')
+    end
+
+    it 'correctly converts RNC to RNG' do
+      parsed = Rng.parse_rnc(rnc_input)
+      expect(parsed).to be_a(described_class)
+      start_element = parsed.start.first.element
+      expect(start_element).to be_a(Rng::Element)
+      expect(start_element.attr_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+/, ""))
+  describe '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
+      rng_start_elem = parsed_rng.start.first.element
+      rnc_start_elem = parsed_rnc.start.first.element
+      expect(rnc_start_elem.attr_name).to eq(rng_start_elem.attr_name)
+    end
+
+    it 'correctly round-trips RNC to RNG and back' do
+      parsed_rnc = Rng.parse_rnc(rnc_input)
+      rng_xml = parsed_rnc.to_xml
+      parsed_rng = Rng.parse(rng_xml)
+
+      # Compare key properties
+      rng_start_elem = parsed_rng.start.first.element
+      rnc_start_elem = parsed_rnc.start.first.element
+      expect(rng_start_elem.attr_name).to eq(rnc_start_elem.attr_name)
     end
   end
 end