rng 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3b70e1b28d17dd9d6a287a404f218151f5a25ab38eba65aba55330d1e5692a08
+  data.tar.gz: d8524a2367eb0c73b64f9040555a2269ad2e6f8121a5ed5d05021c20ad00042b
+SHA512:
+  metadata.gz: 06bc5ef5f3d56f356730e71b42ee2080ab449ed1c769446a315a8077a015327bea94635e172ab9dcbd1d2559eacbb21ad519f3c5dc48fc45c5c7c7ee577326e2
+  data.tar.gz: 2eca01084c177a824f02c5f30c03fc2463de4fee55fab370c9fc951bc51cbf56fadebee4f326c1472754f394361a4e932979d269bf130b1a23312af20feb6483

data/.github/workflows/rake.yml

@@ -0,0 +1,15 @@
+# Auto-generated by Cimas: Do not edit it manually!
+# See https://github.com/metanorma/cimas
+name: rake
+
+on:
+  push:
+    branches: [ master, main ]
+    tags: [ v* ]
+  pull_request:
+
+jobs:
+  rake:
+    uses: metanorma/ci/.github/workflows/generic-rake.yml@main
+    secrets:
+      pat_token: ${{ secrets.LUTAML_CI_PAT_TOKEN }}

data/.github/workflows/release.yml

@@ -0,0 +1,23 @@
+# Auto-generated by Cimas: Do not edit it manually!
+# See https://github.com/metanorma/cimas
+name: release
+
+on:
+  workflow_dispatch:
+    inputs:
+      next_version:
+        description: |
+          Next release version. Possible values: x.y.z, major, minor, patch or pre|rc|etc
+        required: true
+        default: 'skip'
+  repository_dispatch:
+    types: [ do-release ]
+
+jobs:
+  release:
+    uses: metanorma/ci/.github/workflows/rubygems-release.yml@main
+    with:
+      next_version: ${{ github.event.inputs.next_version }}
+    secrets:
+      rubygems-api-key: ${{ secrets.LUTAML_CI_RUBYGEMS_API_KEY }}
+      pat_token: ${{ secrets.LUTAML_CI_PAT_TOKEN }}

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/Gemfile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in rng.gemspec
+gemspec
+
+gem "equivalent-xml"
+gem "nokogiri"
+gem "xml-c14n"
+gem "rake", "~> 13.0"
+gem "rspec", "~> 3.0"
+gem "rubocop", "~> 1.21"
+gem "rubocop-performance", require: false
+gem "rubocop-rake", require: false
+gem "rubocop-rspec", require: false

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/rng/attribute.rb

@@ -0,0 +1,13 @@
+require "lutaml/model"
+
+module Rng
+  class Attribute < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :type, :string, collection: true
+
+    xml do
+      map_attribute "name", to: :name
+      map_element "data", to: :type
+    end
+  end
+end

data/lib/rng/builder.rb

@@ -0,0 +1,158 @@
+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/define.rb

@@ -0,0 +1,14 @@
+require "lutaml/model"
+require_relative "element"
+
+module Rng
+  class Define < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :elements, Element, collection: true
+
+    xml do
+      map_attribute "name", to: :name
+      map_element "element", to: :elements
+    end
+  end
+end

data/lib/rng/element.rb

@@ -0,0 +1,26 @@
+require "lutaml/model"
+require_relative "attribute"
+
+module Rng
+  class Element < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :attributes, Attribute, collection: true
+    attribute :elements, Element, collection: true
+    attribute :text, :boolean
+    attribute :zero_or_more, Element, collection: true
+    attribute :one_or_more, Element, collection: true
+    attribute :optional, Element, collection: true
+    attribute :choice, Element, collection: true
+
+    xml do
+      map_attribute "name", to: :name
+      map_element "attribute", to: :attributes
+      map_element "element", to: :elements
+      map_element "text", to: :text
+      map_element "zeroOrMore", to: :zero_or_more
+      map_element "oneOrMore", to: :one_or_more
+      map_element "optional", to: :optional
+      map_element "choice", to: :choice
+    end
+  end
+end

data/lib/rng/rnc_parser.rb

@@ -0,0 +1,136 @@
+require "parslet"
+require_relative "schema"
+
+module Rng
+  class RncParser < Parslet::Parser
+    rule(:space) { match('\s').repeat(1) }
+    rule(:space?) { space.maybe }
+    rule(:newline) { (str("\r").maybe >> str("\n")).repeat(1) }
+    rule(:newline?) { newline.maybe }
+    rule(:whitespace) { (space | newline).repeat }
+    rule(:comma) { str(",") }
+    rule(:comma?) { (whitespace >> comma >> whitespace).maybe }
+
+    rule(:identifier) { match("[a-zA-Z0-9_]").repeat(1).as(:identifier) }
+
+    rule(:element_def) {
+      str("element") >> space >>
+      identifier >>
+      whitespace >>
+      str("{") >>
+      whitespace >>
+      content.maybe.as(:content) >>
+      whitespace >>
+      str("}") >>
+      (str("*") | str("+") | str("?")).maybe.as(:occurrence)
+    }
+
+    rule(:attribute_def) {
+      str("attribute") >> space >>
+      identifier.as(:name) >>
+      whitespace >>
+      str("{") >>
+      whitespace >>
+      (str("text")).as(:type) >>
+      whitespace >>
+      str("}")
+    }
+
+    rule(:text_def) { str("text").as(:text) }
+
+    rule(:content_item) {
+      ((element_def | attribute_def | text_def).as(:item) >> comma?).repeat(1).as(:items)
+    }
+
+    rule(:content) { content_item }
+
+    rule(:grammar) { whitespace >> element_def.as(:element) >> whitespace }
+
+    root(:grammar)
+
+    def parse(input)
+      tree = super(input.strip)
+      build_schema(tree)
+    end
+
+    private
+
+    def build_schema(tree)
+      element = tree[:element]
+      Schema.new(
+        start: Start.new(
+          elements: [build_element(element)],
+        ),
+      )
+    end
+
+    def build_element(element)
+      name = element[:identifier].to_s
+      content = element[:content]&.[](:items)
+      occurrence = element[:occurrence]
+
+      # Create base element
+      el = Element.new(
+        name: name,
+        attributes: [],
+        elements: [],
+        text: false,
+      )
+
+      if content
+        current_elements = []
+        current_attributes = []
+
+        content.each do |item|
+          case
+          when item[:item][:name] || (item[:item][:identifier] && item[:item][:type])
+            attr_name = item[:item][:name] || item[:item][:identifier]
+            attr = Attribute.new(
+              name: attr_name.to_s,
+              type: ["string"],
+            )
+            current_attributes << attr
+          when item[:item][:identifier]
+            current_elements << build_element(item[:item])
+          when item[:item][:text]
+            el.text = true
+          end
+        end
+
+        el.attributes = current_attributes
+        el.elements = current_elements
+      end
+
+      # Handle occurrence modifiers
+      result = el
+      case occurrence
+      when "*"
+        result = Element.new(
+          name: el.name,
+          attributes: el.attributes,
+          elements: el.elements,
+          text: el.text,
+        )
+        result.zero_or_more = [el]
+      when "+"
+        result = Element.new(
+          name: el.name,
+          attributes: el.attributes,
+          elements: el.elements,
+          text: el.text,
+        )
+        result.one_or_more = [el]
+      when "?"
+        result = Element.new(
+          name: el.name,
+          attributes: el.attributes,
+          elements: el.elements,
+          text: el.text,
+        )
+        result.optional = [el]
+      end
+
+      result
+    end
+  end
+end

data/lib/rng/rng_parser.rb

@@ -0,0 +1,107 @@
+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

@@ -0,0 +1,18 @@
+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/lib/rng/start.rb

@@ -0,0 +1,14 @@
+require "lutaml/model"
+require_relative "element"
+
+module Rng
+  class Start < Lutaml::Model::Serializable
+    attribute :ref, :string
+    attribute :elements, Element, collection: true
+
+    xml do
+      map_attribute "ref", to: :ref
+      map_element "element", to: :elements
+    end
+  end
+end

data/lib/rng/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rng
+  VERSION = "0.1.1"
+end

data/lib/rng.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "rng/version"
+require_relative "rng/rnc_parser"
+require_relative "rng/rng_parser"
+require_relative "rng/builder"
+
+module Rng
+  class Error < StandardError; end
+
+  # Your code goes here...
+end

data/rng.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/rng/version"
+
+all_files_in_git = Dir.chdir(File.expand_path(__dir__)) do
+  `git ls-files -z`.split("\x0")
+end
+
+Gem::Specification.new do |spec|
+  spec.name = "rng"
+  spec.version = Rng::VERSION
+  spec.authors = ["Ribose"]
+  spec.email = ["open.source@ribose.com"]
+
+  spec.summary = "Library to parse and build RELAX NG (RNG) and RELAX NG Compact Syntax (RNC) schemas."
+  spec.homepage = "https://github.com/lutaml/rng"
+  spec.license = "BSD-2-Clause"
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["bug_tracker_uri"] = "#{spec.homepage}/issues"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = all_files_in_git
+    .reject { |f| f.match(%r{\A(?:test|features|bin|\.)/}) }
+
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "lutaml-model"
+  spec.add_dependency "parslet"
+  spec.add_dependency "nokogiri"
+
+  # spec.add_dependency "thor"
+  spec.metadata["rubygems_mfa_required"] = "true"
+end

data/sig/rng.rbs

@@ -0,0 +1,4 @@
+module Rng
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/spec/rng/rnc_parser_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+
+RSpec.describe Rng::RncParser do
+  let(:parser) { described_class.new }
+
+  describe "#parse" do
+    context "with a simple RNC schema" do
+      let(:input) do
+        <<~RNC
+          element addressBook {
+            element card {
+              element name { text },
+              element email { text }
+            }*
+          }
+        RNC
+      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.elements.first.name).to eq("card")
+        expect(result.start.elements.first.elements.first.elements.map(&:name)).to eq(["name", "email"])
+      end
+    end
+
+    context "with attributes" do
+      let(:input) do
+        <<~RNC
+          element person {
+            attribute id { text },
+            element name { text }
+          }
+        RNC
+      end
+
+      it "correctly parses attributes" do
+        result = parser.parse(input)
+        expect(result.start.elements.first.name).to eq("person")
+        expect(result.start.elements.first.elements.first).to be_a(Rng::Attribute)
+        expect(result.start.elements.first.elements.first.name).to eq("id")
+      end
+    end
+
+    context "with nested elements" do
+      let(:input) do
+        <<~RNC
+          element root {
+            element child1 {
+              element grandchild { text }
+            },
+            element child2 { text }
+          }
+        RNC
+      end
+
+      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.first.elements.first.name).to eq("grandchild")
+      end
+    end
+  end
+end

data/spec/rng/rng_parser_spec.rb

@@ -0,0 +1,102 @@
+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

data/spec/rng/schema_spec.rb

@@ -0,0 +1,193 @@
+require "spec_helper"
+
+RSpec.describe Rng::Schema do
+  let(:rng_parser) { Rng::RngParser.new }
+  let(:rnc_parser) { Rng::RncParser.new }
+  let(:builder) { Rng::Builder.new }
+
+  describe "RNG parsing and building" 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))
+    end
+  end
+
+  describe "RNC parsing and building" 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+/, ""))
+    end
+  end
+
+  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+/, ""))
+    end
+  end
+
+  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+/, ""))
+    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+/, ""))
+    end
+  end
+end

data/spec/rng_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe Rng do
+  it "has a version number" do
+    expect(Rng::VERSION).not_to be nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "rng"
+require "xml/c14n"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  # Add helper method for XML comparison
+  config.include(Module.new do
+    def normalize_xml(xml)
+      Xml::C14n.format(xml)
+    end
+  end)
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: rng
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Ribose
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lutaml-model
+  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
+    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: 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'
+description:
+email:
+- open.source@ribose.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/rake.yml"
+- ".github/workflows/release.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- Rakefile
+- lib/rng.rb
+- lib/rng/attribute.rb
+- lib/rng/builder.rb
+- lib/rng/define.rb
+- lib/rng/element.rb
+- lib/rng/rnc_parser.rb
+- lib/rng/rng_parser.rb
+- lib/rng/schema.rb
+- lib/rng/start.rb
+- lib/rng/version.rb
+- rng.gemspec
+- sig/rng.rbs
+- spec/rng/rnc_parser_spec.rb
+- spec/rng/rng_parser_spec.rb
+- spec/rng/schema_spec.rb
+- spec/rng_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/lutaml/rng
+licenses:
+- BSD-2-Clause
+metadata:
+  homepage_uri: https://github.com/lutaml/rng
+  source_code_uri: https://github.com/lutaml/rng
+  bug_tracker_uri: https://github.com/lutaml/rng/issues
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Library to parse and build RELAX NG (RNG) and RELAX NG Compact Syntax (RNC)
+  schemas.
+test_files: []