rng 0.3.6 → 0.3.8

data/spec/rng/external_ref_resolver_spec.rb

@@ -69,6 +69,22 @@ RSpec.describe Rng::ExternalRefResolver do
       end
     end
 
+    context 'with interleaved children reached through an include' do
+      let(:order_main) { File.read('spec/fixtures/external/order_main.rng') }
+
+      it 'preserves element_order through external ref resolution' do
+        grammar = Rng::Grammar.from_xml(order_main)
+        resolved = described_class.new(grammar, location: 'spec/fixtures/external/order_main.rng').resolve
+
+        xml = resolved.to_xml
+        expect(xml.index('first')).to be < xml.index('mid')
+        expect(xml.index('mid')).to be < xml.index('last')
+
+        root = resolved.start.first.element
+        expect(root.instance_variable_get(:@element_order)).not_to be_nil
+      end
+    end
+
     context 'with non-existent external file' do
       it 'does not raise error but warns when external file not found' do
         # Create a grammar with a non-existent include
@@ -110,6 +126,13 @@ RSpec.describe Rng::ExternalRefResolver do
       # Without resolve_external, the grammar is returned as-is
       expect(grammar).to be_a(Rng::Grammar)
     end
+
+    it 'warns about unresolved external references when not resolving' do
+      main_rng = File.read('spec/fixtures/external/include_main.rng')
+      grammar = Rng.parse(main_rng)
+
+      expect(grammar.warnings).to include(a_string_matching(/include_lib\.rng/))
+    end
   end
 
   describe Rng::ExternalRefResolver::ExternalRefResolutionError do

data/spec/rng/parse_rnc_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+
+RSpec.describe 'ParseRncSpec' do
+  describe '.parse_rnc' do
+    let(:simple_rnc) { 'element foo { text }' }
+
+    it 'returns a Grammar for include-free RNC without a location' do
+      parsed = Rng.parse_rnc(simple_rnc)
+
+      expect(parsed).to be_a(Rng::Grammar)
+      expect(parsed.start.first.element.attr_name).to eq('foo')
+    end
+
+    it 'produces equivalent output with and without location for hex-escaped RNC' do
+      # \x{72}oot decodes to "root". Hex preprocessing must run on the
+      # with-location path or the parse tree differs from the no-location path
+      # for the same input — which is the divergence this spec guards against.
+      rnc = 'element \\x{72}oot { text }'
+
+      Dir.mktmpdir do |dir|
+        scratch = File.join(dir, 'scratch.rnc')
+
+        without_location = Rng.parse_rnc(rnc)
+        with_location = Rng.parse_rnc(rnc, location: scratch)
+
+        expect(with_location.to_xml).to be_xml_equivalent_to(without_location.to_xml)
+        expect(with_location.start.first.element.attr_name).to eq('root')
+      end
+    end
+
+    it 'resolves relative includes when location is the source directory' do
+      Dir.mktmpdir do |dir|
+        File.write(File.join(dir, 'child.rnc'), <<~RNC)
+          ChildPattern = element child { text }
+          start = element wrapped { ChildPattern }
+        RNC
+
+        parent_path = File.join(dir, 'parent.rnc')
+        File.write(parent_path, <<~RNC)
+          include "child.rnc" {
+            start = element root { ChildPattern }
+          }
+        RNC
+
+        parsed = Rng.parse_rnc(File.read(parent_path), location: dir)
+
+        expect(parsed.define.map(&:name)).to include('ChildPattern')
+        expect(parsed.start.first.element.attr_name).to eq('root')
+      end
+    end
+
+    it 'also accepts a source file path as location' do
+      Dir.mktmpdir do |dir|
+        File.write(File.join(dir, 'child.rnc'), <<~RNC)
+          ChildPattern = element child { text }
+        RNC
+
+        parent_path = File.join(dir, 'parent.rnc')
+        File.write(parent_path, <<~RNC)
+          include "child.rnc" {
+            start = element root { ChildPattern }
+          }
+        RNC
+
+        parsed = Rng.parse_rnc(File.read(parent_path), location: parent_path)
+
+        expect(parsed.define.map(&:name)).to include('ChildPattern')
+        expect(parsed.start.first.element.attr_name).to eq('root')
+      end
+    end
+  end
+end

data/spec/rng/rnc_parser_spec.rb

@@ -182,6 +182,54 @@ RSpec.describe Rng::RncParser do
       end
     end
 
+    context 'with occurrence markers on leaf patterns' do
+      def root_element_for(form, extra = '')
+        rnc = "start = element root { #{form} }\n#{extra}"
+        described_class.parse(rnc).start.first.element
+      end
+
+      # On Element, :ref is a collection slot but :text/:empty/etc. are singular,
+      # so "leaf is empty" needs to handle both shapes uniformly.
+      def leaf_empty?(container, slot)
+        v = container.public_send(slot)
+        v.nil? || (v.respond_to?(:empty?) && v.empty?)
+      end
+
+      # form => { slot: model accessor on Element/wrapper, extra: extra RNC needed }
+      patterns = {
+        'item' => { slot: :ref, extra: "item = element item { text }\n" },
+        'text' => { slot: :text },
+        'empty' => { slot: :empty },
+        'notAllowed' => { slot: :notAllowed },
+        '"foo"' => { slot: :value },
+        'xsd:string' => { slot: :data }
+      }
+      wrappers = { '*' => :zeroOrMore, '+' => :oneOrMore, '?' => :optional }
+
+      patterns.each do |form, config|
+        slot  = config[:slot]
+        extra = config[:extra].to_s
+
+        it "emits a bare <#{slot}> when there is no occurrence marker on #{form}" do
+          element = root_element_for(form, extra)
+          expect(leaf_empty?(element, slot)).to be(false)
+          expect(element.zeroOrMore).to be_empty
+          expect(element.oneOrMore).to be_empty
+          expect(element.optional).to be_empty
+        end
+
+        wrappers.each do |marker, wrapper|
+          it "wraps #{form}#{marker} in <#{wrapper}>" do
+            element = root_element_for("#{form}#{marker}", extra)
+            wrapper_coll = element.public_send(wrapper)
+            expect(wrapper_coll.length).to eq(1)
+            expect(wrapper_coll.first.public_send(slot).length).to eq(1)
+            expect(leaf_empty?(element, slot)).to be(true)
+          end
+        end
+      end
+    end
+
     context 'with pattern references in choice' do
       let(:input) do
         <<~RNC
@@ -415,6 +463,103 @@ RSpec.describe Rng::RncParser do
       end
     end
 
+    context 'with named pattern after ## comment' do
+      let(:input) do
+        <<~RNC
+          document =
+            element document {
+              ## test 1
+              test
+            }
+
+          test =
+            element sections {
+              attribute test { text }?
+            }
+        RNC
+      end
+
+      let(:grammar) { described_class.parse(input) }
+
+      it 'parses without error' do
+        expect { grammar }.not_to raise_error
+      end
+
+      it 'contains the element document' do
+        expect(grammar.define.map(&:name)).to include('document')
+        document_def = grammar.define.find { |d| d.name == 'document' }
+        expect(document_def.element[0].attr_name).to eq('document')
+      end
+
+      it 'contains the element sections' do
+        expect(grammar.define.map(&:name)).to include('test')
+        test_def = grammar.define.find { |d| d.name == 'test' }
+        expect(test_def.element[0].attr_name).to eq('sections')
+      end
+    end
+
+    context 'with escape sequences in string literals' do
+      it 'parses known escapes (\\n, \\t, \\r, \\", \\\\)' do
+        input = <<~'RNC'
+          start = element value {
+            xsd:string { pattern = "hello\nworld\ttab\r\n" }
+          }
+        RNC
+        expect { described_class.parse(input) }.not_to raise_error
+      end
+
+      it 'parses RELAX NG class escapes (\\i, \\c, \\d, \\w)' do
+        input = <<~'RNC'
+          start = element value {
+            xsd:string { pattern = "\\i\\c\\d\\w" }
+          }
+        RNC
+        expect { described_class.parse(input) }.not_to raise_error
+      end
+
+      it 'parses unknown escape sequences (\\+, \\-, \\s, \\., \\,) preserving backslash' do
+        input = <<~'RNC'
+          start = element value {
+            xsd:string { pattern = "[\\+\\-]?\\d{4}" }
+          }
+        RNC
+        expect { described_class.parse(input) }.not_to raise_error
+      end
+
+      it 'parses ISO 8601 regex pattern with multiple escape sequences' do
+        input = <<~'RNC'
+          ISO8601DateTime = xsd:string { pattern = "([\\+\\-]?\\d{4})((-?)((0[1-9]|1[0-2])((-?)([12]\\d|0[1-9]|3[01]))?|W([0-4]\\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\\d|[12]\\d{2}|3([0-5]\\d|6[1-6])))([T\\s]((([01]\\d|2[0-3])((:?)[0-5]\\d)?|24:?00)([\\.,]\\d+)?)?((:?)[0-5]\\d([.,]\\d+)?)?([zZ]|([\\+\\-])([01]\\d|2[0-3]):?([0-5]\\d)?)?)?)?)?)?" }
+          elem = element elem { ISO8601DateTime }
+        RNC
+        expect { described_class.parse(input) }.not_to raise_error
+      end
+
+      it 'rejects invalid hex escape \\x{}' do
+        # Single-quoted heredoc: \x{} is literal \x{} (one backslash)
+        input = <<~'RNC'
+          start = element value {
+            xsd:string { pattern = "\x{}" }
+          }
+        RNC
+        expect do
+          described_class.parse(input)
+        end.to raise_error(Parslet::ParseFailed)
+      end
+
+      it 'round-trips unknown escape sequences preserving backslash' do
+        rnc_input = <<~'RNC'
+          start = element value {
+            xsd:string { pattern = "[\\+\\-]?\\d{4}" }
+          }
+        RNC
+        grammar = described_class.parse(rnc_input)
+        rnc_output = described_class.to_rnc(grammar)
+        expect(rnc_output).to include('\\+')
+        expect(rnc_output).to include('\\-')
+        expect(rnc_output).to include('\\d')
+      end
+    end
+
     context 'with except patterns in anyName' do
       let(:input) do
         <<~RNC

data/spec/rng/rnc_roundtrip_spec.rb

@@ -97,6 +97,83 @@ RSpec.describe 'RNG to RNC Round-trip Tests' do
         expect(xml).to include('<choice')
       end
 
+      it 'preserves a mixed attribute choice of text and value' do
+        rnc = <<~RNC
+          start = element doc {
+            attribute a { text | "x" }
+          }
+        RNC
+        xml = Rng.parse_rnc(rnc).to_xml
+        expect(xml).to include('<choice>')
+        expect(xml).to include('<text>')
+        expect(xml).to include('<value>x</value>')
+      end
+
+      it 'preserves a mixed attribute choice of value and ref' do
+        rnc = <<~RNC
+          start = element doc {
+            attribute a { "x" | foo }
+          }
+          foo = element foo { text }
+        RNC
+        xml = Rng.parse_rnc(rnc).to_xml
+        expect(xml).to include('<choice>')
+        expect(xml).to include('<value>x</value>')
+        expect(xml).to include('<ref name="foo"/>')
+      end
+
+      it 'preserves a mixed attribute choice of text and ref' do
+        rnc = <<~RNC
+          start = element doc {
+            attribute a { text | foo }
+          }
+          foo = element foo { text }
+        RNC
+        xml = Rng.parse_rnc(rnc).to_xml
+        expect(xml).to include('<choice>')
+        expect(xml).to include('<text>')
+        expect(xml).to include('<ref name="foo"/>')
+      end
+
+      it 'emits a mixed attribute choice of text and value back to RNC' do
+        rng = <<~RNG
+          <grammar xmlns="http://relaxng.org/ns/structure/1.0">
+            <start><element name="doc"><attribute name="indent">
+              <choice><text/><value>adaptive</value></choice>
+            </attribute></element></start>
+          </grammar>
+        RNG
+        rnc = Rng.to_rnc(Rng.parse(rng))
+        expect(rnc).to match(/attribute indent \{[^}]*text[^}]*\}/)
+        expect(rnc).to include('"adaptive"')
+      end
+
+      it 'emits a mixed attribute choice of value and ref back to RNC' do
+        rng = <<~RNG
+          <grammar xmlns="http://relaxng.org/ns/structure/1.0">
+            <start><element name="doc"><attribute name="a">
+              <choice><value>x</value><ref name="foo"/></choice>
+            </attribute></element></start>
+            <define name="foo"><text/></define>
+          </grammar>
+        RNG
+        rnc = Rng.to_rnc(Rng.parse(rng))
+        expect(rnc).to match(/attribute a \{[^}]*foo[^}]*\}/)
+        expect(rnc).to include('"x"')
+      end
+
+      it 'round-trips a mixed attribute choice of text and value through RNC and RNG' do
+        rnc = <<~RNC
+          start = element doc {
+            attribute indent { text | "adaptive" }
+          }
+        RNC
+        regenerated = Rng.to_rnc(Rng.parse(Rng.parse_rnc(rnc).to_xml))
+        # Both members of the choice must survive a full RNC -> RNG -> RNC trip
+        expect(regenerated).to match(/attribute indent \{[^}]*text[^}]*\}/)
+        expect(regenerated).to include('"adaptive"')
+      end
+
       it 'preserves interleave' do
         rnc = <<~RNC
           start = element foo {

data/spec/rng/schema_spec.rb

@@ -81,6 +81,24 @@ RSpec.describe Rng::Grammar do
       expect(start_element).to be_a(Rng::Element)
       expect(start_element.attr_name).to eq('addressBook')
     end
+
+    it 'resolves includes for in-memory RNC when location is the source directory' do
+      main_path = File.expand_path('spec/fixtures/rnc/main_with_include.rnc')
+      parsed = Rng.parse_rnc(File.read(main_path), location: File.dirname(main_path))
+
+      expect(parsed).to be_a(described_class)
+      expect(parsed.define.map(&:name)).to include('BasePattern', 'ExtendedPattern')
+      expect(parsed.start.first.element.attr_name).to eq('doc')
+    end
+
+    it 'matches parse_file include resolution for in-memory RNC when location is the source directory' do
+      main_path = File.expand_path('spec/fixtures/rnc/main_include_trailing.rnc')
+      from_memory = Rng.parse_rnc(File.read(main_path), location: File.dirname(main_path))
+      from_file = Rng.parse_file(main_path)
+
+      expect(from_memory.start.first.element.attr_name).to eq(from_file.start.first.element.attr_name)
+      expect(from_memory.define.map(&:name).sort).to eq(from_file.define.map(&:name).sort)
+    end
   end
 
   describe 'RNG to RNC conversion' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rng
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.8
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-15 00:00:00.000000000 Z
+date: 2026-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.8.114
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.8.114
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -136,7 +136,6 @@ files:
 - lib/rng/optional.rb
 - lib/rng/param.rb
 - lib/rng/parent_ref.rb
-- lib/rng/parse_rnc.rb
 - lib/rng/parse_tree_processor.rb
 - lib/rng/pattern.rb
 - lib/rng/ref.rb
@@ -166,6 +165,8 @@ files:
 - spec/fixtures/external/nested_chain.rng
 - spec/fixtures/external/nested_leaf.rng
 - spec/fixtures/external/nested_mid.rng
+- spec/fixtures/external/order_lib.rng
+- spec/fixtures/external/order_main.rng
 - spec/fixtures/metanorma/3gpp.rnc
 - spec/fixtures/metanorma/3gpp.rng
 - spec/fixtures/metanorma/basicdoc.rnc
@@ -254,6 +255,7 @@ files:
 - spec/rng/metanorma_conversion_spec.rb
 - spec/rng/namespace_declaration_spec.rb
 - spec/rng/namespace_support_spec.rb
+- spec/rng/parse_rnc_spec.rb
 - spec/rng/rnc_parser_spec.rb
 - spec/rng/rnc_roundtrip_spec.rb
 - spec/rng/rng_generation_spec.rb

data/lib/rng/parse_rnc.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Rng
-  # RNC Parser module
-  # Provides functionality to parse RELAX NG Compact Syntax (RNC) files
-  module ParseRnc
-    class << self
-      # Parse RNC syntax and return an RNG schema object
-      # @param rnc_string [String] The RNC content to parse
-      # @return [Rng::Grammar] The parsed schema object
-      def parse(rnc_string)
-        # This is a placeholder implementation
-        # The actual parsing logic would need to be implemented
-
-        # For now, we delegate to RncParser which is our internal implementation
-        # In the future, this could be expanded with additional functionality
-        RncParser.parse(rnc_string)
-      end
-    end
-  end
-
-  # Add class-level parsing method
-  def self.parse_rnc(rnc_string)
-    ParseRnc.parse(rnc_string)
-  end
-end