rng 0.3.7 → 0.3.9

data/lib/rng/schema_validator.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'nokogiri'
+require 'moxml'
 require 'uri'
 
 module Rng
@@ -22,7 +22,7 @@ module Rng
   end
 
   # Validates raw XML against RELAX NG structural rules.
-  # Operates on the Nokogiri XML tree BEFORE Lutaml deserialization,
+  # Operates on the Moxml XML tree BEFORE Lutaml deserialization,
   # because Lutaml silently drops unmapped content.
   class SchemaValidator
     RNG_NS = 'http://relaxng.org/ns/structure/1.0'
@@ -31,6 +31,8 @@ module Rng
     LEAF_ELEMENTS = %w[empty text notAllowed ref parentRef value].freeze
     OBSOLETE_ELEMENTS = %w[not difference key keyRef].freeze
     OBSOLETE_ATTRS = %w[key keyRef global].freeze
+    OBSOLETE_ATTR_CONTEXTS = [%w[start name], %w[attribute global], %w[data key],
+                              %w[data keyRef]].freeze
     NAME_REQUIRED = %w[element attribute].freeze
     CONTAINER_ELEMENTS = %w[group choice interleave optional zeroOrMore oneOrMore list mixed define start].freeze
     VALID_ROOT_ELEMENTS = %w[grammar element group choice interleave notAllowed externalRef data].freeze
@@ -66,7 +68,7 @@ module Rng
 
     class << self
       def validate(xml_input)
-        doc = Nokogiri::XML(xml_input)
+        doc = Moxml::Context.new.parse(xml_input)
         root = doc.root
         report_error('Document has no root element') unless root
         validator = new
@@ -75,7 +77,7 @@ module Rng
       end
 
       def validate_all(xml_input)
-        doc = Nokogiri::XML(xml_input)
+        doc = Moxml::Context.new.parse(xml_input)
         root = doc.root
         return [SchemaValidationError.new('Document has no root element')] unless root
 
@@ -89,7 +91,7 @@ module Rng
       end
 
       def valid?(xml_input)
-        doc = Nokogiri::XML(xml_input)
+        doc = Moxml::Context.new.parse(xml_input)
         root = doc.root
         return false unless root
 
@@ -113,9 +115,9 @@ module Rng
     end
 
     def validate_node(node, parent_context: nil)
-      return unless node.is_a?(Nokogiri::XML::Element)
+      return unless node.is_a?(Moxml::Element)
 
-      ns = node.namespace&.href
+      ns = node.namespace&.uri
       local_name = node.name
       is_root = node.parent&.document&.root == node
       xpath = node.path.delete_prefix('/')
@@ -192,15 +194,15 @@ module Rng
       validate_oneOrMore_infinite_attribute_name(local_name, node, xpath)
 
       # Recurse
-      node.element_children.each do |child|
-        next if child.namespace&.href == ANNOTATIONS_NS
+      node.children.select(&:element?).each do |child|
+        next if child.namespace&.uri == ANNOTATIONS_NS
 
         validate_node(child, parent_context: context_for_child(local_name, node))
       end
     end
 
     def report_error(message, xpath: nil, node: nil)
-      line = node&.line if node
+      line = node&.line_number
       error = SchemaValidationError.new(message, xpath: xpath, line: line)
       raise error unless @collect_all
 
@@ -211,7 +213,7 @@ module Rng
     private
 
     def rng_ns_children(node)
-      node.element_children.select { |c| (c.namespace&.href == RNG_NS) || (c.namespace.nil? && !c.name.empty?) }
+      node.children.select(&:element?).select { |c| (c.namespace&.uri == RNG_NS) || (c.namespace.nil? && !c.name.empty?) }
     end
 
     def context_for_child(parent_name, _parent_node)
@@ -227,7 +229,7 @@ module Rng
       current = node.parent
       while current
         return current if current.name == name &&
-                          (current.namespace&.href == RNG_NS || (current.namespace.nil? && !current.name.empty?))
+                          (current.namespace&.uri == RNG_NS || (current.namespace.nil? && !current.name.empty?))
 
         current = current.parent
       end
@@ -436,21 +438,13 @@ module Rng
     end
 
     def validate_obsolete_attrs(node, xpath)
-      node.attributes.each do |name, attr|
-        attr_ns = attr.namespace&.href
-        if attr_ns == RNG_NS && OBSOLETE_ATTRS.include?(name)
-          report_error("Attribute '#{name}' on '#{node.name}' is obsolete",
-                       xpath: xpath)
-        end
+      node.attributes.each do |attr|
+        attr_ns = attr.namespace&.uri
+        report_error("Attribute '#{attr.name}' on '#{node.name}' is obsolete", xpath: xpath) if attr_ns == RNG_NS && OBSOLETE_ATTRS.include?(attr.name)
         next unless attr_ns.nil? && attr.namespace&.prefix.nil?
+        next unless OBSOLETE_ATTR_CONTEXTS.include?([node.name, attr.name])
 
-        report_error("Attribute 'name' on 'start' is obsolete", xpath: xpath) if name == 'name' && node.name == 'start'
-        if name == 'global' && node.name == 'attribute'
-          report_error("Attribute 'global' on 'attribute' is obsolete",
-                       xpath: xpath)
-        end
-        report_error("Attribute '#{name}' on 'data' is obsolete", xpath: xpath) if %w[key
-                                                                                      keyRef].include?(name) && node.name == 'data'
+        report_error("Attribute '#{attr.name}' on '#{node.name}' is obsolete", xpath: xpath)
       end
     end
 
@@ -529,7 +523,7 @@ module Rng
       return false unless node
 
       current = node
-      while current.is_a?(Nokogiri::XML::Element)
+      while current.is_a?(Moxml::Element)
         current.namespace_definitions.each do |ns|
           return true if ns.prefix == prefix
         end
@@ -758,7 +752,7 @@ module Rng
     def validate_name_value_purity(local_name, node, xpath)
       return unless %w[name value].include?(local_name)
 
-      return unless node.element_children.any?
+      return unless node.children.any?(&:element?)
 
       report_error("'#{local_name}' must not contain child elements", xpath: xpath)
     end
@@ -827,8 +821,9 @@ module Rng
     def validate_leaf_no_attrs(local_name, node, xpath)
       return unless NO_ATTR_LEAF_ELEMENTS.include?(local_name)
 
-      node.attributes.each do |attr_name, attr|
-        attr_ns = attr.namespace&.href
+      node.attributes.each do |attr|
+        attr_name = attr.name
+        attr_ns = attr.namespace&.uri
         next if attr_ns && attr_ns != RNG_NS
         next if attr_name == 'xmlns' || attr_name.start_with?('xmlns:')
 
@@ -838,10 +833,11 @@ module Rng
     end
 
     def validate_unknown_attrs(node, xpath)
-      node.attributes.each do |attr_name, attr|
+      node.attributes.each do |attr|
+        attr_name = attr.name
         next if attr_name == 'xmlns'
 
-        attr_ns = attr.namespace&.href
+        attr_ns = attr.namespace&.uri
         if (attr_ns == RNG_NS) && !known_rng_attr?(
           node.name, attr_name
         )
@@ -1407,9 +1403,9 @@ module Rng
 
     def collect_all_refs(node)
       refs = []
-      return refs unless node.is_a?(Nokogiri::XML::Element)
+      return refs unless node.is_a?(Moxml::Element)
 
-      ns = node.namespace&.href
+      ns = node.namespace&.uri
       local = node.name
       if ns == RNG_NS || (ns.nil? && !local.empty?)
         case local
@@ -1418,7 +1414,7 @@ module Rng
         when 'parentRef'
           refs << { name: node['name'], type: 'parentRef' } if node['name']
         end
-        node.element_children.each do |child|
+        node.children.select(&:element?).each do |child|
           refs.concat(collect_all_refs(child))
         end
       end
@@ -1444,9 +1440,9 @@ module Rng
 
     def collect_direct_refs(node)
       refs = []
-      return refs unless node.is_a?(Nokogiri::XML::Element)
+      return refs unless node.is_a?(Moxml::Element)
 
-      ns = node.namespace&.href
+      ns = node.namespace&.uri
       local = node.name
       if ns == RNG_NS || (ns.nil? && !local.empty?)
         case local
@@ -1455,7 +1451,7 @@ module Rng
         when 'parentRef'
           refs << node['name'] if node['name']
         end
-        node.element_children.each do |child|
+        node.children.select(&:element?).each do |child|
           next if child.name == 'define' # Don't recurse into nested grammar's defines
 
           refs.concat(collect_direct_refs(child))

data/lib/rng/test_suite_parser.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'nokogiri'
+require 'moxml'
 
 module Rng
   # Parses RELAX NG test suite XML files (like compacttest.xml)
@@ -53,7 +53,7 @@ module Rng
     attr_reader :test_cases
 
     def initialize(xml_content)
-      @doc = Nokogiri::XML(xml_content)
+      @doc = Moxml::Context.new.parse(xml_content)
       @test_cases = []
       parse_test_cases
     end
@@ -138,7 +138,7 @@ module Rng
       xml_node.xpath('resource').each do |resource_node|
         name = resource_node['name']
         # Get the first element child as RNG content
-        content_node = resource_node.elements.first
+        content_node = resource_node.children.find(&:element?)
         content = content_node ? content_node.to_xml : ''
         test_case.xml_resources[name] = content
       end
@@ -147,7 +147,7 @@ module Rng
       correct_node = xml_node.at_xpath('correct')
       if correct_node
         # Get the first element child as RNG content
-        rng_node = correct_node.elements.first
+        rng_node = correct_node.children.find(&:element?)
         test_case.instance_variable_set(
           :@xml_correct,
           rng_node ? rng_node.to_xml : ''
@@ -158,7 +158,7 @@ module Rng
       incorrect_node = xml_node.at_xpath('incorrect')
       return unless incorrect_node
 
-      rng_node = incorrect_node.elements.first
+      rng_node = incorrect_node.children.find(&:element?)
       test_case.instance_variable_set(
         :@xml_incorrect,
         rng_node ? rng_node.to_xml : ''

data/lib/rng/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rng
-  VERSION = '0.3.7'
+  VERSION = '0.3.9'
 end

data/lib/rng.rb

@@ -39,7 +39,6 @@ module Rng
   autoload :Grammar, File.expand_path('rng/grammar', __dir__)
   autoload :Documentation, File.expand_path('rng/documentation', __dir__)
   autoload :TestSuiteParser, File.expand_path('rng/test_suite_parser', __dir__)
-  autoload :Value, File.expand_path('rng/value', __dir__)
 
   # Autoload parser support classes
   autoload :ParseTreeProcessor, File.expand_path('rng/parse_tree_processor', __dir__)
@@ -57,7 +56,6 @@ module Rng
 
   # Autoload parsers and builders
   autoload :RncParser, File.expand_path('rng/rnc_parser', __dir__)
-  autoload :ParseRnc, File.expand_path('rng/parse_rnc', __dir__)
   autoload :ToRnc, File.expand_path('rng/to_rnc', __dir__)
   autoload :RncBuilder, File.expand_path('rng/rnc_builder', __dir__)
   autoload :IncludeProcessor, File.expand_path('rng/include_processor', __dir__)
@@ -67,13 +65,17 @@ module Rng
   def parse(rng, location: nil, nested_schema: false, validate: false, resolve_external: false)
     SchemaValidator.validate(rng) if validate && !nested_schema
     grammar = Grammar.from_xml(rng)
-    return grammar unless resolve_external
+
+    unless resolve_external
+      grammar.warnings = ExternalRefResolver.unresolved_ref_hrefs(grammar)
+      return grammar
+    end
 
     ExternalRefResolver.new(grammar, location: location).resolve
   end
 
-  def self.parse_rnc(rnc)
-    ParseRnc.parse(rnc)
+  def self.parse_rnc(rnc, location: nil)
+    IncludeProcessor.new.parse_content(rnc, location: location)
   end
 
   def self.parse_file(file_path)

data/rng.gemspec

@@ -29,8 +29,8 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'lutaml-model', '~> 0.8.0'
-  spec.add_dependency 'nokogiri'
+  spec.add_dependency 'lutaml-model', '~> 0.8.114'
+  spec.add_dependency 'moxml'
   spec.add_dependency 'parslet'
 
   spec.add_dependency 'thor'

data/spec/fixtures/external/order_lib.rng

@@ -0,0 +1,13 @@
+<grammar xmlns="http://relaxng.org/ns/structure/1.0">
+  <start>
+    <element name="root">
+      <element name="first">
+        <empty/>
+      </element>
+      <attribute name="mid"/>
+      <element name="last">
+        <empty/>
+      </element>
+    </element>
+  </start>
+</grammar>

data/spec/fixtures/external/order_main.rng

@@ -0,0 +1,3 @@
+<grammar xmlns="http://relaxng.org/ns/structure/1.0">
+  <include href="order_lib.rng"/>
+</grammar>

data/spec/rng/advanced_rnc_spec.rb

@@ -2,6 +2,7 @@
 
 require 'spec_helper'
 require 'rng'
+require 'parslet'
 
 RSpec.describe 'Advanced RNC features' do
   describe 'Name wildcards' do
@@ -98,4 +99,126 @@ RSpec.describe 'Advanced RNC features' do
       expect { Rng.parse_rnc(rnc) }.not_to raise_error
     end
   end
+
+  describe 'Content-position annotations' do
+    it 'parses a bracket annotation before an attribute in content' do
+      rnc = 'start = element n { [ a:defaultValue = "x" ] attribute foo { text } }'
+      expect { Rng.parse_rnc(rnc) }.not_to raise_error
+    end
+
+    it 'parses a bracket annotation before a nested element in content' do
+      rnc = 'start = element n { [ a:documentation [ "hi" ] ] element c { text } }'
+      expect { Rng.parse_rnc(rnc) }.not_to raise_error
+    end
+
+    it 'parses an annotated attribute within a sequence' do
+      rnc = 'start = element n { [ a:x = "1" ] attribute foo { text }, ' \
+            'attribute bar { text } }'
+      grammar = Rng.parse_rnc(rnc)
+      attrs = grammar.start.first.element.attribute.map(&:attr_name)
+      expect(attrs).to eq(%w[foo bar])
+    end
+
+    it 'leaves un-annotated content parsing unchanged' do
+      rnc = 'start = element n { attribute foo { text } }'
+      expect { Rng.parse_rnc(rnc) }.not_to raise_error
+    end
+
+    it 'does not let brackets inside an annotation string close it early' do
+      rnc = 'start = element n { [ a:x = "a]b[c" ] attribute foo { text }, ' \
+            'attribute bar { text } }'
+      grammar = Rng.parse_rnc(rnc)
+      attrs = grammar.start.first.element.attribute.map(&:attr_name)
+      expect(attrs).to eq(%w[foo bar])
+    end
+
+    it 'ignores brackets inside a single-quoted annotation string' do
+      rnc = "start = element n { [ a:x = 'a]b[c' ] attribute foo { text }, " \
+            'attribute bar { text } }'
+      grammar = Rng.parse_rnc(rnc)
+      attrs = grammar.start.first.element.attribute.map(&:attr_name)
+      expect(attrs).to eq(%w[foo bar])
+    end
+
+    it 'ignores brackets inside a triple-quoted annotation string' do
+      rnc = 'start = element n { [ a:doc [ """multi]line[x""" ] ] ' \
+            'attribute foo { text }, attribute bar { text } }'
+      grammar = Rng.parse_rnc(rnc)
+      attrs = grammar.start.first.element.attribute.map(&:attr_name)
+      expect(attrs).to eq(%w[foo bar])
+    end
+
+    it 'drops an annotation before a non-leading definition without corrupting it' do
+      rnc = "foo = element foo { text }\n" \
+            "[ a:defaultValue = \"x\" ]\n" \
+            "bar = element bar { text }\n" \
+            'start = foo'
+      grammar = Rng.parse_rnc(rnc)
+
+      expect(grammar.define.map(&:name)).to contain_exactly('foo', 'bar')
+    end
+
+    it 'rejects a control character inside an annotation string, like a value string' do
+      rnc = "start = element n { [ a:x = \"#{1.chr}\" ] " \
+            'attribute foo { text } }'
+      expect { Rng.parse_rnc(rnc) }.to raise_error(Parslet::ParseFailed)
+    end
+  end
+
+  describe 'Sequence separators' do
+    it 'rejects comma-less sequence items so they cannot swallow the next definition' do
+      rnc = 'start = element n { attribute foo { text } attribute bar { text } }'
+      expect { Rng.parse_rnc(rnc) }.to raise_error(Parslet::ParseFailed)
+    end
+
+    it 'parses comma-separated sequence items in element content' do
+      rnc = 'start = element n { attribute foo { text }, attribute bar { text } }'
+      grammar = Rng.parse_rnc(rnc)
+      attrs = grammar.start.first.element.attribute.map(&:attr_name)
+      expect(attrs).to eq(%w[foo bar])
+    end
+  end
+
+  describe 'Non-leading start' do
+    it 'produces a real <start> for a start = element after other defines' do
+      rnc = "item = element item { text }\nstart = element root { item* }"
+      grammar = Rng.parse_rnc(rnc)
+
+      expect(grammar.start.first.element.attr_name).to eq('root')
+      expect(grammar.define.map(&:name)).to eq(['item'])
+    end
+
+    it 'produces a real <start> for a non-leading start = ref' do
+      rnc = "library = element library { text }\nstart = library"
+      grammar = Rng.parse_rnc(rnc)
+
+      expect(grammar.start.first.ref.name).to eq('library')
+      expect(grammar.define.map(&:name)).not_to include('start')
+    end
+
+    it 'collects multiple start |= definitions as combining starts' do
+      rnc = "a = element a { empty }\nb = element b { empty }\n" \
+            "start |= a\nstart |= b"
+      grammar = Rng.parse_rnc(rnc)
+
+      expect(grammar.start.map(&:combine)).to eq(%w[choice choice])
+      expect(grammar.start.map { |s| s.ref.name }).to contain_exactly('a', 'b')
+    end
+
+    it 'maps start &= to interleave-combining starts' do
+      rnc = "a = element a { empty }\nb = element b { empty }\n" \
+            "start &= a\nstart &= b"
+      grammar = Rng.parse_rnc(rnc)
+
+      expect(grammar.start.map(&:combine)).to eq(%w[interleave interleave])
+    end
+
+    it 'keeps an escaped \\start as a define, not the grammar start' do
+      rnc = "x = element x { text }\n\\start = element a { text }\nstart = x"
+      grammar = Rng.parse_rnc(rnc)
+
+      expect(grammar.define.map(&:name)).to include('start')
+      expect(grammar.start.first.ref.name).to eq('x')
+    end
+  end
 end

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/include_processor_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+
+RSpec.describe Rng::IncludeProcessor do
+  # A grammar-block RNC that includes another grammar and then defines its
+  # own named patterns after the include. The merged grammar must carry BOTH
+  # the included grammar's definitions and the including file's own patterns.
+  # ParseTreeProcessor used to overwrite :definitions (the include merge
+  # result) with only :includes + :patterns, dropping every included define.
+  it 'keeps included definitions and own patterns in a grammar block file' do
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, 'base.rnc'), <<~RNC)
+        start = doc
+        doc = element doc { sections }
+        sections = element sections { element a { text } }
+      RNC
+
+      File.write(File.join(dir, 'derived.rnc'), <<~RNC)
+        include "base.rnc" {
+          doc = element doc { sections }
+        }
+
+        start = derived
+        derived = element derived { sections }
+        note = element note { text }
+      RNC
+
+      grammar = Rng.parse_file(File.join(dir, 'derived.rnc'))
+      names = grammar.define.map(&:name)
+
+      expect(names).to include('sections')
+      expect(names).to include('note')
+      expect(names).to include('derived')
+    end
+  end
+
+  it 'applies include-block overrides, replacing the base definition' do
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, 'base.rnc'), <<~RNC)
+        start = doc
+        doc = element doc { sections }
+        sections = element sections { element a { text } }
+      RNC
+
+      File.write(File.join(dir, 'derived.rnc'), <<~RNC)
+        include "base.rnc" {
+          sections = element sections { element b { text } }
+        }
+      RNC
+
+      grammar = Rng.parse_file(File.join(dir, 'derived.rnc'))
+      sections = grammar.define.find { |d| d.name == 'sections' }
+
+      expect(sections).not_to be_nil
+      expect(sections.to_xml).to include('name="b"')
+      expect(sections.to_xml).not_to include('name="a"')
+    end
+  end
+end

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