rng 0.1.1 → 0.3.3

data/lib/rng/start.rb

@@ -1,14 +1,65 @@
-require "lutaml/model"
-require_relative "element"
+# frozen_string_literal: true
 
 module Rng
   class Start < Lutaml::Model::Serializable
-    attribute :ref, :string
-    attribute :elements, Element, collection: true
+    attribute :id, :string
+    attribute :ns, :string
+    attribute :datatypeLibrary, :string
+    attribute :combine, :string
+    attribute :ref, Ref
+    attribute :element, Element
+    attribute :choice, Choice
+    attribute :group, Group
+    attribute :interleave, Interleave
+    attribute :mixed, Mixed
+    attribute :optional, Optional
+    attribute :zeroOrMore, ZeroOrMore
+    attribute :oneOrMore, OneOrMore
+    attribute :text, Text
+    attribute :empty, Empty
+    attribute :value, Value
+    attribute :data, Data
+    attribute :list, List
+    attribute :parentRef, ParentRef
+    attribute :notAllowed, NotAllowed
+    attribute :grammar, Grammar
+    attribute :documentation, Documentation
 
     xml do
-      map_attribute "ref", to: :ref
-      map_element "element", to: :elements
+      element 'start'
+      ordered
+
+      namespace ::Rng::Namespaces::RngNamespace
+
+      map_attribute 'id', to: :id
+      map_attribute 'ns', to: :ns, value_map: {
+        from: { empty: :empty, omitted: :omitted, nil: :nil },
+        to: { empty: :empty, omitted: :omitted, nil: :nil }
+      }
+      map_attribute 'datatypeLibrary', to: :datatypeLibrary, value_map: {
+        from: { empty: :empty, omitted: :omitted, nil: :nil },
+        to: { empty: :empty, omitted: :omitted, nil: :nil }
+      }
+      map_attribute 'combine', to: :combine
+
+      map_element 'ref', to: :ref
+      map_element 'element', to: :element
+      map_element 'choice', to: :choice
+      map_element 'group', to: :group
+      map_element 'interleave', to: :interleave
+      map_element 'mixed', to: :mixed
+      map_element 'optional', to: :optional
+      map_element 'zeroOrMore', to: :zeroOrMore
+      map_element 'oneOrMore', to: :oneOrMore
+      map_element 'text', to: :text
+      map_element 'empty', to: :empty
+      map_element 'value', to: :value
+      map_element 'data', to: :data
+      map_element 'list', to: :list
+      map_element 'parentRef', to: :parentRef
+      map_element 'notAllowed', to: :notAllowed
+      map_element 'grammar', to: :grammar
+      map_element 'documentation', to: :documentation
     end
   end
 end

data/lib/rng/test_suite_parser.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module Rng
+  # Parses RELAX NG test suite XML files (like compacttest.xml)
+  class TestSuiteParser
+    # Represents a single test case with RNC and RNG versions
+    class TestCase
+      attr_reader :id, :compact_correct, :compact_incorrect,
+                  :xml_correct, :xml_incorrect,
+                  :compact_resources, :xml_resources
+
+      def initialize(id:)
+        @id = id
+        @compact_correct = nil
+        @compact_incorrect = nil
+        @xml_correct = nil
+        @xml_incorrect = nil
+        @compact_resources = {}
+        @xml_resources = {}
+      end
+
+      def valid_rnc?
+        !compact_correct.nil?
+      end
+
+      def invalid_rnc?
+        !compact_incorrect.nil?
+      end
+
+      def valid_rng?
+        !xml_correct.nil?
+      end
+
+      def has_resources?
+        !compact_resources.empty? || !xml_resources.empty?
+      end
+
+      def description
+        if valid_rnc? && valid_rng?
+          'RNC ↔ RNG conversion'
+        elsif valid_rnc?
+          'Valid RNC parsing'
+        elsif invalid_rnc?
+          'Invalid RNC rejection'
+        else
+          'Test case'
+        end
+      end
+    end
+
+    attr_reader :test_cases
+
+    def initialize(xml_content)
+      @doc = Nokogiri::XML(xml_content)
+      @test_cases = []
+      parse_test_cases
+    end
+
+    # Load test suite from file path
+    def self.load(file_path)
+      content = File.read(file_path)
+      new(content)
+    end
+
+    # Get test cases with valid RNC that should parse
+    def valid_rnc_cases
+      test_cases.select(&:valid_rnc?)
+    end
+
+    # Get test cases with invalid RNC that should fail
+    def invalid_rnc_cases
+      test_cases.select(&:invalid_rnc?)
+    end
+
+    # Get test cases with both RNC and RNG for round-trip testing
+    def roundtrip_cases
+      test_cases.select { |tc| tc.valid_rnc? && tc.valid_rng? }
+    end
+
+    # Get test cases with resources (external files)
+    def resource_cases
+      test_cases.select(&:has_resources?)
+    end
+
+    private
+
+    def parse_test_cases
+      @doc.xpath('//testCase').each_with_index do |test_node, index|
+        test_case = TestCase.new(id: index + 1)
+
+        # Parse compact syntax (RNC)
+        parse_compact_section(test_node, test_case)
+
+        # Parse XML syntax (RNG)
+        parse_xml_section(test_node, test_case)
+
+        @test_cases << test_case
+      end
+    end
+
+    def parse_compact_section(test_node, test_case)
+      compact_node = test_node.at_xpath('compact')
+      return unless compact_node
+
+      # Parse resources
+      compact_node.xpath('resource').each do |resource_node|
+        name = resource_node['name']
+        content = resource_node.text.strip
+        test_case.compact_resources[name] = content
+      end
+
+      # Parse correct RNC
+      correct_node = compact_node.at_xpath('correct')
+      if correct_node
+        test_case.instance_variable_set(
+          :@compact_correct,
+          correct_node.text.strip
+        )
+      end
+
+      # Parse incorrect RNC
+      incorrect_node = compact_node.at_xpath('incorrect')
+      return unless incorrect_node
+
+      test_case.instance_variable_set(
+        :@compact_incorrect,
+        incorrect_node.text.strip
+      )
+    end
+
+    def parse_xml_section(test_node, test_case)
+      xml_node = test_node.at_xpath('xml')
+      return unless xml_node
+
+      # Parse resources
+      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 = content_node ? content_node.to_xml : ''
+        test_case.xml_resources[name] = content
+      end
+
+      # Parse correct 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
+        test_case.instance_variable_set(
+          :@xml_correct,
+          rng_node ? rng_node.to_xml : ''
+        )
+      end
+
+      # Parse incorrect RNG (if any)
+      incorrect_node = xml_node.at_xpath('incorrect')
+      return unless incorrect_node
+
+      rng_node = incorrect_node.elements.first
+      test_case.instance_variable_set(
+        :@xml_incorrect,
+        rng_node ? rng_node.to_xml : ''
+      )
+    end
+  end
+end

data/lib/rng/text.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rng
+  class Text < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :ns, :string
+    attribute :datatypeLibrary, :string
+    attribute :value, :string
+
+    xml do
+      element 'text'
+      namespace ::Rng::Namespaces::RngNamespace
+
+      map_attribute 'id', to: :id
+      map_attribute 'ns', to: :ns, value_map: {
+        from: { empty: :empty, omitted: :omitted, nil: :nil },
+        to: { empty: :empty, omitted: :omitted, nil: :nil }
+      }
+      map_attribute 'datatypeLibrary', to: :datatypeLibrary, value_map: {
+        from: { empty: :empty, omitted: :omitted, nil: :nil },
+        to: { empty: :empty, omitted: :omitted, nil: :nil }
+      }
+      map_content to: :value, value_map: {
+        from: { empty: :empty, omitted: :omitted, nil: :nil },
+        to: { empty: :empty, omitted: :omitted, nil: :nil }
+      }
+    end
+  end
+end

data/lib/rng/to_rnc.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'rnc_parser'
+
+module Rng
+  # RNG to RNC converter module
+  # Provides functionality to convert RELAX NG XML Schema (RNG) to RELAX NG Compact Syntax (RNC)
+  module ToRnc
+    class << self
+      # Convert an RNG schema object to RNC syntax
+      # @param schema [Rng::Grammar] The schema to convert
+      # @return [String] The RNC representation of the schema
+      def convert(schema)
+        # Delegate to RncParser which has the actual implementation via RncBuilder
+        RncParser.to_rnc(schema)
+      end
+    end
+  end
+
+  # Add class-level conversion method
+  def self.to_rnc(schema)
+    ToRnc.convert(schema)
+  end
+end

data/lib/rng/value.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rng
+  class Value < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :ns, :string
+    attribute :datatypeLibrary, :string
+    attribute :type, :string
+    attribute :value, :string
+
+    xml do
+      element 'value'
+      namespace ::Rng::Namespaces::RngNamespace
+
+      map_attribute 'type', to: :type
+      map_attribute 'id', to: :id
+      map_attribute 'ns', to: :ns, value_map: {
+        from: { empty: :empty, omitted: :omitted, nil: :nil },
+        to: { empty: :empty, omitted: :omitted, nil: :nil }
+      }
+      map_attribute 'datatypeLibrary', to: :datatypeLibrary, value_map: {
+        from: { empty: :empty, omitted: :omitted, nil: :nil },
+        to: { empty: :empty, omitted: :omitted, nil: :nil }
+      }
+      map_content to: :value
+    end
+  end
+end

data/lib/rng/version.rb

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

data/lib/rng/zero_or_more.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Rng
+  class ZeroOrMore < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :ns, :string
+    attribute :datatypeLibrary, :string
+    attribute :element, Element, collection: true, initialize_empty: true
+    attribute :attribute, Attribute, collection: true, initialize_empty: true
+    attribute :ref, Ref, collection: true, initialize_empty: true
+    attribute :choice, Choice, collection: true, initialize_empty: true
+    attribute :group, Group, collection: true, initialize_empty: true
+    attribute :interleave, Interleave, collection: true, initialize_empty: true
+    attribute :mixed, Mixed, collection: true, initialize_empty: true
+    attribute :optional, Optional, collection: true, initialize_empty: true
+    attribute :zeroOrMore, ZeroOrMore, collection: true, initialize_empty: true
+    attribute :oneOrMore, OneOrMore, collection: true, initialize_empty: true
+    attribute :text, Text, collection: true, initialize_empty: true
+    attribute :empty, Empty, collection: true, initialize_empty: true
+    attribute :value, Value, collection: true, initialize_empty: true
+    attribute :data, Data, collection: true, initialize_empty: true
+    attribute :list, List, collection: true, initialize_empty: true
+    attribute :notAllowed, NotAllowed, collection: true, initialize_empty: true
+
+    xml do
+      element 'zeroOrMore'
+      ordered
+
+      namespace ::Rng::Namespaces::RngNamespace
+
+      map_attribute 'id', to: :id
+      map_attribute 'ns', to: :ns, value_map: {
+        from: { empty: :empty, omitted: :omitted, nil: :nil },
+        to: { empty: :empty, omitted: :omitted, nil: :nil }
+      }
+      map_attribute 'datatypeLibrary', to: :datatypeLibrary, value_map: {
+        from: { empty: :empty, omitted: :omitted, nil: :nil },
+        to: { empty: :empty, omitted: :omitted, nil: :nil }
+      }
+      map_element 'element', to: :element
+      map_element 'attribute', to: :attribute
+      map_element 'ref', to: :ref
+      map_element 'choice', to: :choice
+      map_element 'group', to: :group
+      map_element 'interleave', to: :interleave
+      map_element 'mixed', to: :mixed
+      map_element 'optional', to: :optional
+      map_element 'zeroOrMore', to: :zeroOrMore
+      map_element 'oneOrMore', to: :oneOrMore
+      map_element 'text', to: :text
+      map_element 'empty', to: :empty
+      map_element 'value', to: :value
+      map_element 'data', to: :data
+      map_element 'list', to: :list
+      map_element 'notAllowed', to: :notAllowed
+    end
+  end
+end

data/lib/rng.rb

@@ -1,12 +1,87 @@
 # frozen_string_literal: true
 
-require_relative "rng/version"
-require_relative "rng/rnc_parser"
-require_relative "rng/rng_parser"
-require_relative "rng/builder"
+require 'lutaml/model'
 
 module Rng
   class Error < StandardError; end
 
-  # Your code goes here...
+  autoload :Namespaces, File.expand_path('rng/namespaces', __dir__)
+
+  # Autoload all model classes - avoids circular dependency issues
+  autoload :Pattern, File.expand_path('rng/pattern', __dir__)
+  autoload :Text, File.expand_path('rng/text', __dir__)
+  autoload :Empty, File.expand_path('rng/empty', __dir__)
+  autoload :Value, File.expand_path('rng/value', __dir__)
+  autoload :Param, File.expand_path('rng/param', __dir__)
+  autoload :NotAllowed, File.expand_path('rng/not_allowed', __dir__)
+  autoload :Name, File.expand_path('rng/name', __dir__)
+  autoload :AnyName, File.expand_path('rng/any_name', __dir__)
+  autoload :NsName, File.expand_path('rng/ns_name', __dir__)
+  autoload :Except, File.expand_path('rng/except', __dir__)
+  autoload :Data, File.expand_path('rng/data', __dir__)
+  autoload :List, File.expand_path('rng/list', __dir__)
+  autoload :Ref, File.expand_path('rng/ref', __dir__)
+  autoload :ParentRef, File.expand_path('rng/parent_ref', __dir__)
+  autoload :ExternalRef, File.expand_path('rng/external_ref', __dir__)
+  autoload :Optional, File.expand_path('rng/optional', __dir__)
+  autoload :ZeroOrMore, File.expand_path('rng/zero_or_more', __dir__)
+  autoload :OneOrMore, File.expand_path('rng/one_or_more', __dir__)
+  autoload :Choice, File.expand_path('rng/choice', __dir__)
+  autoload :Group, File.expand_path('rng/group', __dir__)
+  autoload :Interleave, File.expand_path('rng/interleave', __dir__)
+  autoload :Mixed, File.expand_path('rng/mixed', __dir__)
+  autoload :Attribute, File.expand_path('rng/attribute', __dir__)
+  autoload :Element, File.expand_path('rng/element', __dir__)
+  autoload :Define, File.expand_path('rng/define', __dir__)
+  autoload :Start, File.expand_path('rng/start', __dir__)
+  autoload :Div, File.expand_path('rng/div', __dir__)
+  autoload :Include, File.expand_path('rng/include', __dir__)
+  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__)
+  autoload :RncToRngConverter, File.expand_path('rng/rnc_to_rng_converter', __dir__)
+  autoload :SchemaPreamble, File.expand_path('rng/schema_preamble', __dir__)
+  autoload :NamespaceDeclaration, File.expand_path('rng/namespace_declaration', __dir__)
+  autoload :DatatypeDeclaration, File.expand_path('rng/datatype_declaration', __dir__)
+
+  # Schema validation
+  autoload :SchemaValidator, File.expand_path('rng/schema_validator', __dir__)
+  autoload :SchemaValidationError, File.expand_path('rng/schema_validator', __dir__)
+
+  # External reference resolution
+  autoload :ExternalRefResolver, File.expand_path('rng/external_ref_resolver', __dir__)
+
+  # 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__)
+
+  module_function
+
+  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
+
+    ExternalRefResolver.new(grammar, location: location).resolve
+  end
+
+  def self.parse_rnc(rnc)
+    ParseRnc.parse(rnc)
+  end
+
+  def self.parse_file(file_path)
+    RncParser.parse_file(file_path)
+  end
+
+  def self.to_rnc(schema)
+    # Convert RNG schema to RNC
+    ToRnc.convert(schema)
+  end
 end

data/rng.gemspec

@@ -1,38 +1,38 @@
 # frozen_string_literal: true
 
-require_relative "lib/rng/version"
+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.name = 'rng'
   spec.version = Rng::VERSION
-  spec.authors = ["Ribose"]
-  spec.email = ["open.source@ribose.com"]
+  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.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"
+  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|\.)/}) }
+               .reject { |f| f.match(%r{\A(?:test|features|bin|\.)/}) }
 
-  spec.bindir = "exe"
+  spec.bindir = 'exe'
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_dependency "lutaml-model"
-  spec.add_dependency "parslet"
-  spec.add_dependency "nokogiri"
+  spec.add_dependency 'lutaml-model', '~> 0.8.0'
+  spec.add_dependency 'nokogiri'
+  spec.add_dependency 'parslet'
 
-  # spec.add_dependency "thor"
-  spec.metadata["rubygems_mfa_required"] = "true"
+  spec.add_dependency 'thor'
+  spec.metadata['rubygems_mfa_required'] = 'true'
 end

data/scripts/extract_spectest_resources.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Extracts external test resources from Jing-Trang's spectest.xml
+# and creates fixture files for testing external href resolution.
+#
+# Creates:
+#   spec/fixtures/spectest_external/  - extracted resources organized by test case
+#   spec/fixtures/spectest_external/resources.json - mapping of test indices to files
+
+require 'fileutils'
+require 'json'
+require 'nokogiri'
+
+SPECTEST_XML = File.expand_path('~/src/external/jing-trang/mod/rng-validate/test/spectest.xml')
+OUTPUT_DIR = 'spec/fixtures/spectest_external'
+MAPPING_FILE = File.join(OUTPUT_DIR, 'resources.json')
+
+def extract_resources
+  unless File.exist?(SPECTEST_XML)
+    puts "Error: spectest.xml not found at #{SPECTEST_XML}"
+    puts 'Please ensure Jing-Trang is checked out at ~/src/external/jing-trang'
+    exit 1
+  end
+
+  doc = Nokogiri::XML(File.read(SPECTEST_XML))
+
+  # Clean up existing fixtures
+  FileUtils.rm_rf(OUTPUT_DIR)
+  FileUtils.mkdir_p(OUTPUT_DIR)
+
+  # Find all test cases with resources
+  test_cases = doc.xpath('//testCase[resource]')
+
+  puts "Found #{test_cases.count} test cases with resources"
+  puts "Extracting to #{OUTPUT_DIR}..."
+
+  mapping = {}
+
+  test_cases.each_with_index do |tc, idx|
+    case_num = idx + 1
+    section = tc.at_xpath('section')&.text || 'unknown'
+    documentation = tc.at_xpath('documentation')&.text || ''
+
+    case_dir = File.join(OUTPUT_DIR, "case_#{case_num}_#{section}")
+    mapping[case_num] = {
+      section: section,
+      documentation: documentation,
+      resources: []
+    }
+
+    # Handle resources in directories
+    FileUtils.mkdir_p(case_dir)
+    tc.xpath('.//dir').each do |dir|
+      dir_name = dir['name']
+      dir_path = File.join(case_dir, dir_name)
+      FileUtils.mkdir_p(dir_path)
+
+      dir.xpath('.//resource').each do |res|
+        resource_name = res['name']
+        content = res.inner_html.strip
+        next if content.empty?
+
+        resource_path = File.join(dir_path, resource_name)
+        File.write(resource_path, content)
+        mapping[case_num][:resources] << "#{dir_name}/#{resource_name}"
+      end
+    end
+
+    # Handle resources at root level
+    tc.xpath('./resource').each do |res|
+      resource_name = res['name']
+      content = res.inner_html.strip
+      next if content.empty?
+
+      resource_path = File.join(case_dir, resource_name)
+      File.write(resource_path, content)
+      mapping[case_num][:resources] << resource_name
+    end
+  end
+
+  # Write mapping file
+  File.write(MAPPING_FILE, JSON.pretty_generate(mapping))
+
+  puts "\nExtracted #{test_cases.count} test cases to #{OUTPUT_DIR}"
+  puts "Created mapping file: #{MAPPING_FILE}"
+
+  puts "\nDirectory structure:"
+  Dir.glob("#{OUTPUT_DIR}/**/*").reject { |f| File.directory?(f) }.sort.each { |f| puts "  #{f}" }
+
+  puts "\nTo use these fixtures, update spectest_spec.rb to use resolve_external: true"
+  puts 'and reference the case_N directories when resolving external refs.'
+end
+
+# Run if called directly
+extract_resources if __FILE__ == $PROGRAM_NAME