rng 0.1.1 → 0.1.2

data/spec/spec_helper.rb

@@ -2,6 +2,9 @@
 
 require "rng"
 require "xml/c14n"
+require "equivalent-xml"
+require "nokogiri"
+require "diffy"
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure
@@ -19,5 +22,35 @@ RSpec.configure do |config|
     def normalize_xml(xml)
       Xml::C14n.format(xml)
     end
+
+    def format_xml(xml_string)
+      # Use Nokogiri to parse and format the XML
+      # Strip comments for comparison purposes - we care about structure, not documentation
+      doc = Nokogiri::XML(xml_string, &:noblanks)
+
+      # Remove all comment nodes before comparison
+      doc.xpath("//comment()").remove
+
+      doc.to_xml(indent: 2)
+    end
+
+    def diff_xml(actual, expected)
+      # Generate a readable diff between the formatted XML strings
+      Diffy::Diff.new(expected, actual, context: 3).to_s
+    end
   end)
+
+  # Add custom matchers for XML comparison
+  RSpec::Matchers.define :be_equivalent_to_xml do |expected|
+    match do |actual|
+      @actual_formatted = format_xml(actual.to_s)
+      @expected_formatted = format_xml(expected.to_s)
+      EquivalentXml.equivalent?(@actual_formatted, @expected_formatted)
+    end
+
+    failure_message do
+      diff = diff_xml(@actual_formatted, @expected_formatted)
+      "Expected XML to be equivalent, but it wasn't.\n\nDiff:\n#{diff}"
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rng
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-27 00:00:00.000000000 Z
+date: 2025-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: parslet
   requirement: !ruby/object:Gem::Requirement
@@ -39,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: nokogiri
+  name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -64,23 +78,56 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- ".rubocop_todo.yml"
+- CODE_OF_CONDUCT.md
 - Gemfile
+- README.adoc
 - Rakefile
 - lib/rng.rb
+- lib/rng/any_name.rb
 - lib/rng/attribute.rb
-- lib/rng/builder.rb
+- lib/rng/choice.rb
+- lib/rng/data.rb
 - lib/rng/define.rb
 - lib/rng/element.rb
+- lib/rng/empty.rb
+- lib/rng/except.rb
+- lib/rng/external_ref.rb
+- lib/rng/grammar.rb
+- lib/rng/group.rb
+- lib/rng/include.rb
+- lib/rng/interleave.rb
+- lib/rng/list.rb
+- lib/rng/mixed.rb
+- lib/rng/name.rb
+- lib/rng/not_allowed.rb
+- lib/rng/ns_name.rb
+- lib/rng/one_or_more.rb
+- lib/rng/optional.rb
+- lib/rng/param.rb
+- lib/rng/parent_ref.rb
+- lib/rng/parse_rnc.rb
+- lib/rng/pattern.rb
+- lib/rng/ref.rb
 - lib/rng/rnc_parser.rb
-- lib/rng/rng_parser.rb
-- lib/rng/schema.rb
 - lib/rng/start.rb
+- lib/rng/text.rb
+- lib/rng/to_rnc.rb
+- lib/rng/value.rb
 - lib/rng/version.rb
+- lib/rng/zero_or_more.rb
 - rng.gemspec
 - sig/rng.rbs
+- spec/fixtures/rnc/address_book.rnc
+- spec/fixtures/rnc/complex_example.rnc
+- spec/fixtures/rng/address_book.rng
+- spec/fixtures/rng/relaxng.rng
+- spec/fixtures/rng/testSuite.rng
+- spec/fixtures/spectest.xml
 - spec/rng/rnc_parser_spec.rb
-- spec/rng/rng_parser_spec.rb
+- spec/rng/rnc_roundtrip_spec.rb
 - spec/rng/schema_spec.rb
+- spec/rng/spectest_spec.rb
 - spec/rng_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/lutaml/rng

data/lib/rng/builder.rb

@@ -1,158 +0,0 @@
-module Rng
-  class Builder
-    def build(schema, format:)
-      case format
-      when :rng
-        build_rng(schema)
-      when :rnc
-        build_rnc(schema)
-      else
-        raise ArgumentError, "Unsupported format: #{format}"
-      end
-    end
-
-    private
-
-    def build_rng(schema)
-      doc = Nokogiri::XML::Document.new
-      doc.encoding = "UTF-8"
-
-      if schema.is_a?(Rng::Schema)
-        root = Nokogiri::XML::Node.new("grammar", doc)
-        root["xmlns"] = "http://relaxng.org/ns/structure/1.0"
-        doc.root = root
-
-        start = Nokogiri::XML::Node.new("start", doc)
-        root.add_child(start)
-
-        if schema.start.ref
-          ref = Nokogiri::XML::Node.new("ref", doc)
-          ref["name"] = schema.start.ref
-          start.add_child(ref)
-        end
-
-        schema.start.elements.each do |element|
-          start.add_child(build_rng_element(element, doc))
-        end
-
-        schema.define&.each do |define|
-          define_node = Nokogiri::XML::Node.new("define", doc)
-          define_node["name"] = define.name
-          define.elements.each do |element|
-            define_node.add_child(build_rng_element(element, doc))
-          end
-          root.add_child(define_node)
-        end
-      elsif schema.is_a?(Rng::Element)
-        el = build_rng_element(schema, doc)
-        el["xmlns"] = "http://relaxng.org/ns/structure/1.0"
-        doc.root = el
-      end
-
-      doc.to_xml
-    end
-
-    def build_rng_element(element, doc)
-      if element.zero_or_more&.any?
-        zero_or_more = Nokogiri::XML::Node.new("zeroOrMore", doc)
-        el = Nokogiri::XML::Node.new("element", doc)
-        el["name"] = element.name
-        add_element_content(element, el, doc)
-        zero_or_more.add_child(el)
-        return zero_or_more
-      elsif element.one_or_more&.any?
-        one_or_more = Nokogiri::XML::Node.new("oneOrMore", doc)
-        el = Nokogiri::XML::Node.new("element", doc)
-        el["name"] = element.name
-        add_element_content(element, el, doc)
-        one_or_more.add_child(el)
-        return one_or_more
-      elsif element.optional&.any?
-        optional = Nokogiri::XML::Node.new("optional", doc)
-        el = Nokogiri::XML::Node.new("element", doc)
-        el["name"] = element.name
-        add_element_content(element, el, doc)
-        optional.add_child(el)
-        return optional
-      else
-        el = Nokogiri::XML::Node.new("element", doc)
-        el["name"] = element.name
-        add_element_content(element, el, doc)
-        return el
-      end
-    end
-
-    def add_element_content(element, el, doc)
-      element.attributes&.each do |attr|
-        attr_node = Nokogiri::XML::Node.new("attribute", doc)
-        attr_node["name"] = attr.name
-        if attr.type&.any?
-          data = Nokogiri::XML::Node.new("data", doc)
-          data["type"] = attr.type.first
-          attr_node.add_child(data)
-        else
-          text = Nokogiri::XML::Node.new("text", doc)
-          attr_node.add_child(text)
-        end
-        el.add_child(attr_node)
-      end
-
-      element.elements&.each do |child|
-        el.add_child(build_rng_element(child, doc))
-      end
-
-      if element.text
-        text = Nokogiri::XML::Node.new("text", doc)
-        el.add_child(text)
-      end
-    end
-
-    def build_rnc(schema)
-      result = ""
-      elements = schema.is_a?(Rng::Schema) ? schema.start.elements : [schema]
-      elements.each do |element|
-        result += build_rnc_element(element)
-      end
-      result
-    end
-
-    def build_rnc_element(element, indent = 0)
-      return "" unless element # Handle nil elements
-
-      result = "  " * indent
-      result += "element #{element.name} {\n"
-
-      element.attributes&.each do |attr|
-        result += "  " * (indent + 1)
-        result += "attribute #{attr.name} { text }"
-        result += ",\n" unless element.attributes.last == attr && !element.elements&.any? && !element.text
-      end
-
-      element.elements&.each_with_index do |child, index|
-        child_result = build_rnc_element(child, indent + 1)
-        result += child_result
-        result += "," unless index == element.elements.size - 1 && !element.text
-        result += "\n"
-      end
-
-      if element.text
-        result += "  " * (indent + 1)
-        result += "text"
-        result += "\n"
-      end
-
-      result += "  " * indent
-      result += "}"
-
-      if element.zero_or_more&.any?
-        result += "*"
-      elsif element.one_or_more&.any?
-        result += "+"
-      elsif element.optional&.any?
-        result += "?"
-      end
-
-      result
-    end
-  end
-end

data/lib/rng/rng_parser.rb

@@ -1,107 +0,0 @@
-require "nokogiri"
-require_relative "schema"
-require_relative "element"
-
-module Rng
-  class RngParser
-    RELAXNG_NS = "http://relaxng.org/ns/structure/1.0"
-
-    def parse(input)
-      doc = Nokogiri::XML(input)
-      doc.remove_namespaces! # This simplifies namespace handling
-
-      root = doc.root
-      case root.name
-      when "grammar"
-        parse_grammar(doc)
-      when "element"
-        parse_element(doc)
-      else
-        raise Rng::Error, "Unexpected root element: #{root.name}"
-      end
-    end
-
-    private
-
-    def parse_grammar(doc)
-      Schema.new(
-        start: parse_start(doc.at_xpath("//start")),
-        define: doc.xpath("//define").map { |define| parse_define(define) },
-      )
-    end
-
-    def parse_start(node)
-      return nil unless node
-
-      Start.new(
-        ref: node.at_xpath(".//ref")&.attr("name"),
-        elements: node.xpath(".//element").map { |element| parse_element(element) },
-      )
-    end
-
-    def parse_define(node)
-      Define.new(
-        name: node["name"],
-        elements: node.xpath(".//element").map { |element| parse_element(element) },
-      )
-    end
-
-    def parse_element(node)
-      return nil unless node["name"]
-
-      element = Element.new(
-        name: node["name"],
-        attributes: [],
-        elements: [],
-        text: false,
-      )
-
-      node.children.each do |child|
-        parse_child(child, element)
-      end
-
-      element
-    end
-
-    def parse_child(node, element)
-      case node.name
-      when "attribute"
-        element.attributes << parse_attribute(node)
-      when "element"
-        element.elements << parse_element(node)
-      when "text"
-        element.text = true
-      when "zeroOrMore"
-        parse_zero_or_more(node).each { |el| element.zero_or_more << el }
-      when "oneOrMore"
-        parse_one_or_more(node).each { |el| element.one_or_more << el }
-      when "optional"
-        parse_optional(node).each { |el| element.optional << el }
-      end
-    end
-
-    def parse_attribute(node)
-      data_node = node.at_xpath(".//data")
-      Attribute.new(
-        name: node["name"],
-        type: data_node ? [data_node["type"]] : ["string"],
-      )
-    end
-
-    def parse_zero_or_more(node)
-      node.xpath("./element").map { |el| parse_element(el) }
-    end
-
-    def parse_one_or_more(node)
-      node.xpath("./element").map { |el| parse_element(el) }
-    end
-
-    def parse_optional(node)
-      node.xpath("./element").map { |el| parse_element(el) }
-    end
-
-    def parse_choice(node)
-      node.xpath(".//choice/element").map { |el| parse_element(el) }
-    end
-  end
-end

data/lib/rng/schema.rb

@@ -1,18 +0,0 @@
-require "lutaml/model"
-require_relative "start"
-require_relative "define"
-
-module Rng
-  class Schema < Lutaml::Model::Serializable
-    attribute :start, Start
-    attribute :define, Define, collection: true
-
-    xml do
-      root "grammar"
-      namespace "http://relaxng.org/ns/structure/1.0"
-
-      map_element "start", to: :start
-      map_element "define", to: :define
-    end
-  end
-end

data/spec/rng/rng_parser_spec.rb

@@ -1,102 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Rng::RngParser do
-  let(:parser) { described_class.new }
-
-  describe "#parse" do
-    context "with a simple RNG schema" do
-      let(:input) do
-        <<~RNG
-          <grammar xmlns="http://relaxng.org/ns/structure/1.0">
-            <start>
-              <element name="addressBook">
-                <zeroOrMore>
-                  <element name="card">
-                    <element name="name">
-                      <text/>
-                    </element>
-                    <element name="email">
-                      <text/>
-                    </element>
-                  </element>
-                </zeroOrMore>
-              </element>
-            </start>
-          </grammar>
-        RNG
-      end
-
-      it "correctly parses the schema" do
-        result = parser.parse(input)
-        expect(result).to be_a(Rng::Schema)
-        expect(result.start.elements.first.name).to eq("addressBook")
-        expect(result.start.elements.first.zero_or_more.first.name).to eq("card")
-        expect(result.start.elements.first.zero_or_more.first.elements.map(&:name)).to eq(["name", "email"])
-      end
-    end
-
-    context "with a complex RNG schema" do
-      let(:input) do
-        <<~RNG
-          <grammar xmlns="http://relaxng.org/ns/structure/1.0">
-            <start>
-              <ref name="addressBook"/>
-            </start>
-            <define name="addressBook">
-              <element name="addressBook">
-                <zeroOrMore>
-                  <element name="card">
-                    <element name="name">
-                      <text/>
-                    </element>
-                    <element name="email">
-                      <text/>
-                    </element>
-                    <optional>
-                      <element name="note">
-                        <text/>
-                      </element>
-                    </optional>
-                  </element>
-                </zeroOrMore>
-              </element>
-            </define>
-          </grammar>
-        RNG
-      end
-
-      it "correctly parses the schema" do
-        result = parser.parse(input)
-        expect(result).to be_a(Rng::Schema)
-        expect(result.start.ref).to eq("addressBook")
-        expect(result.define.first.name).to eq("addressBook")
-        expect(result.define.first.elements.first.name).to eq("addressBook")
-      end
-    end
-
-    context "with attributes" do
-      let(:input) do
-        <<~RNG
-          <grammar xmlns="http://relaxng.org/ns/structure/1.0">
-            <start>
-              <element name="person">
-                <attribute name="id">
-                  <data type="ID"/>
-                </attribute>
-                <element name="name">
-                  <text/>
-                </element>
-              </element>
-            </start>
-          </grammar>
-        RNG
-      end
-
-      it "correctly parses attributes" do
-        result = parser.parse(input)
-        expect(result.start.elements.first.attributes.first.name).to eq("id")
-        expect(result.start.elements.first.attributes.first.type).to eq(["ID"])
-      end
-    end
-  end
-end