rng 0.3.7 → 0.3.9

data/lib/rng/rnc_parser.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'parslet'
-require 'nokogiri'
 require 'set'
 
 module Rng
@@ -261,6 +260,23 @@ module Rng
       (whitespace >> annotation).repeat(1)
     end
 
+    # Match a `[ ... ]` annotation WITHOUT capturing anything (produces a raw
+    # slice that is discarded in a sequence). Strings and nested brackets are
+    # matched as raw characters so no `.as` capture turns the surrounding
+    # content item into an array. Used to drop a content-position annotation.
+    rule(:annotation_skip) do
+      str('[') >> annotation_skip_inner.repeat >> str(']')
+    end
+
+    rule(:annotation_skip_inner) do
+      (str('"""') >> (str('"""').absent? >> any).repeat >> str('"""')) |
+        (str("'''") >> (str("'''").absent? >> any).repeat >> str("'''")) |
+        (str('"') >> ((str('\\') >> any) | (str('"').absent? >> match('[\u0000-\u001F\u007F]').absent? >> any)).repeat >> str('"')) |
+        (str("'") >> ((str('\\') >> any) | (str("'").absent? >> match('[\u0000-\u001F\u007F]').absent? >> any)).repeat >> str("'")) |
+        (str('[') >> annotation_skip_inner.repeat >> str(']')) |
+        (str('[').absent? >> str(']').absent? >> str('"').absent? >> str("'").absent? >> any)
+    end
+
     # Notation/annotation: [ key = "value" ] or just [ ... ]
     # Notations are only valid when attached to patterns using >>, not as standalone preamble items
     rule(:notation) do
@@ -312,14 +328,18 @@ module Rng
           value_literal >>
           (whitespace >> str('|') >> whitespace >> value_literal).repeat(1) >>
           whitespace >> str(')')).as(:datatype_except) |
-        # Non-parenthesized choice of value literals: "a" | "b" | "c"
-        (value_literal >> (whitespace >> str('|') >> whitespace >> value_literal).repeat(1).as(:value_choice)) |
+        # Non-parenthesized choice of items: "a" | "b", text | "a", "a" | ref, text | ref
+        (attribute_choice_item >> (whitespace >> str('|') >> whitespace >> attribute_choice_item).repeat(1).as(:attribute_choice)) |
         value_literal |
         datatype_ref |
         keyword('text').as(:text_type) |
         identifier.as(:ref)
     end
 
+    rule(:attribute_choice_item) do
+      keyword('text').as(:text_type) | value_literal | identifier.as(:ref)
+    end
+
     rule(:datatype_ref) do
       identifier.as(:prefix) >> str(':') >> identifier.as(:type) >>
         (whitespace >> str('{') >> whitespace >>
@@ -381,7 +401,7 @@ module Rng
     # Named pattern definition (e.g., "myPattern = element foo { text }")
     rule(:named_pattern) do
       (doc_comments >> whitespace).maybe.as(:docs) >>
-        annotations.maybe >>
+        (annotation_skip >> whitespace).repeat >>
         identifier.as(:name) >> whitespace >>
         (str('|=') | str('&=') | str('=')).as(:operator) >> whitespace >>
         pattern_list.as(:pattern)
@@ -402,14 +422,18 @@ module Rng
         (
           (whitespace >> str('&') >> whitespace >> content_item).repeat(1).as(:interleave_items) |
           (whitespace >> str('|') >> whitespace >> content_item).repeat(1).as(:choice_items) |
-          (comma? >> content_item).repeat(1).as(:sequence_items)
+          # A comma is required between top-level sequence items; a comma-less
+          # continuation would greedily swallow the following definition.
+          (whitespace >> comma >> whitespace >> content_item).repeat(1).as(:sequence_items)
         ).maybe
     end
 
     # Choice is handled at content level, not as separate pattern
     rule(:content_item) do
       (doc_comments >> whitespace).maybe >>
-        annotations.maybe >>
+        # Drop any content-position bracket annotation(s) before the item so the
+        # following pattern still matches (annotations are not modelled here).
+        (annotation_skip >> whitespace).repeat >>
         (element_def | attribute_def |
           # Datatype subtraction: identifier - ( value|identifier|choice|annotated )
           (identifier.as(:datatype_name) >>
@@ -668,18 +692,13 @@ module Rng
       result
     end
 
+    # Parse RNC content into a Grammar.
+    #
+    # Delegates to {IncludeProcessor#parse_content} so that this entry point
+    # and {Rng.parse_rnc} share a single canonical pipeline. With no location,
+    # include directives are not resolved.
     def self.parse(input)
-      parser = new
-      preprocessed = preprocess_hex_escapes(input.strip)
-      tree = parser.parse(preprocessed)
-
-      # Normalize parse tree
-      processor = ParseTreeProcessor.new(tree)
-      normalized = processor.normalize
-
-      # Convert to RNG XML and Grammar object
-      rng_xml = convert_to_rng(normalized.grammar_tree)
-      Grammar.from_xml(rng_xml)
+      IncludeProcessor.new.parse_content(input)
     end
 
     # Convert RNG schema to RNC

data/lib/rng/rnc_to_rng_converter.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
-require 'nokogiri'
+require 'moxml'
 require 'set'
 
 module Rng
   # RncToRngConverter converts RNC parse trees to RNG XML format.
   #
   # This class takes the parse tree output from the Parslet RNC parser and
-  # converts it to RNG XML using Nokogiri's XML builder. The resulting XML
+  # converts it to RNG XML using Moxml's Nokogiri-compatible XML builder.
+  # The resulting XML
   # can then be deserialized into Grammar objects using Lutaml::Model.
   #
   # @example Convert a parse tree to RNG XML
@@ -17,6 +18,8 @@ module Rng
   #   grammar = Rng::Grammar.from_xml(rng_xml)
   class RncToRngConverter
     RNG_NAMESPACE = 'http://relaxng.org/ns/structure/1.0'
+    OCCURRENCE_TAGS = { '*' => 'zeroOrMore', '+' => 'oneOrMore', '?' => 'optional' }.freeze
+    private_constant :OCCURRENCE_TAGS
 
     # Convert a parse tree to RNG XML
     #
@@ -36,65 +39,37 @@ module Rng
       # Validate that element notations in preamble annotations are only used with element/attribute patterns
       validate_preamble_element_notation_usage(tree[:preamble_items], tree[:definitions])
 
-      builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
+      # Build without Context#build: its block is instance_eval'd, which
+      # would re-bind self and turn every converter helper call into a
+      # builder method_missing tag. A lambda preserves self; Moxml's tag
+      # blocks use block.call, so caller context survives down the tree.
+      builder = Moxml::Builder.new(Moxml::Context.new)
+      emit = lambda do |xml|
+        xml.declaration
         grammar_attrs = { xmlns: 'http://relaxng.org/ns/structure/1.0' }
         if @has_documentation
           grammar_attrs[:'xmlns:a'] =
             'http://relaxng.org/ns/compatibility/annotations/1.0'
         end
+        if tree[:namespace]
+          grammar_attrs[:ns] =
+            process_string_literal(tree[:namespace][:namespace_uri])
+        end
+        if tree[:datatype_library]
+          grammar_attrs[:datatypeLibrary] =
+            process_string_literal(tree[:datatype_library][:uri])
+        elsif tree[:datatype_map] && !tree[:datatype_map].empty?
+          # From ParseTreeProcessor - datatype_map is {prefix => uri}
+          # Use the first (typically only) datatype library
+          grammar_attrs[:datatypeLibrary] = tree[:datatype_map].values.first
+        end
 
         xml.grammar(grammar_attrs) do
-          # Add namespace if present
-          if tree[:namespace]
-            xml.parent[:ns] =
-              process_string_literal(tree[:namespace][:namespace_uri])
-          end
-
-          # Add datatype library if present
-          if tree[:datatype_library]
-            xml.parent[:datatypeLibrary] =
-              process_string_literal(tree[:datatype_library][:uri])
-          elsif tree[:datatype_map] && !tree[:datatype_map].empty?
-            # From ParseTreeProcessor - datatype_map is {prefix => uri}
-            # Use the first (typically only) datatype library
-            xml.parent[:datatypeLibrary] = tree[:datatype_map].values.first
-          end
-
-          # If no explicit start but we have top-level elements, wrap them in start
-          has_explicit_start = tree[:start] && tree[:start][:start_pattern]
-          has_top_elements = tree[:definitions]&.any? do |d|
-            d.key?(:top_element)
-          end
-          has_top_choice = tree[:definitions]&.any? do |d|
-            d.key?(:top_choice)
-          end
-
-          if has_explicit_start
-            # Process explicit start pattern
-            xml.start do
-              add_documentation(xml, tree[:start]) if tree[:start][:docs]
-              process_pattern_list(xml, tree[:start][:start_pattern])
-            end
-          elsif has_top_choice
-            # No explicit start, but has top-level choice - wrap in start with choice
-            first_choice = tree[:definitions].find { |d| d.key?(:top_choice) }
-            xml.start do
-              xml.choice do
-                process_content_item(xml, first_choice[:top_choice][:first])
-                first_choice[:top_choice][:choice_items]&.each do |item|
-                  process_content_item(xml, item)
-                end
-              end
-            end
-          elsif has_top_elements
-            # No explicit start, but has top-level elements - wrap first one in start
-            xml.start do
-              first_element = tree[:definitions].find do |d|
-                d.key?(:top_element)
-              end
-              process_content_item(xml, first_element[:top_element])
-            end
-          end
+          # A leading `start` (tree[:start]) or a non-leading one (emitted as
+          # <start> in the definitions loop) both suppress auto-wrapping.
+          has_explicit_start =
+            (tree[:start] && tree[:start][:start_pattern]) || nonleading_start?(tree)
+          emit_grammar_start(xml, tree)
 
           # Process named patterns and remaining top-level elements
           tree[:definitions]&.each_with_index do |def_item, idx|
@@ -162,6 +137,8 @@ module Rng
                 # Include without override block
                 xml.include(href: href)
               end
+            elsif def_item.key?(:name) && keyword_start_name?(def_item[:name])
+              emit_nonleading_start(xml, def_item)
             elsif def_item.key?(:name)
               # Named pattern - handle augmentation operators
               name = process_identifier(def_item[:name])
@@ -204,7 +181,8 @@ module Rng
         end
       end
 
-      builder.to_xml
+      emit.call(builder)
+      builder.document.to_xml
     end
 
     private
@@ -256,6 +234,11 @@ module Rng
     end
 
     # Add annotations (foreign attributes and elements) if present
+    #
+    # NOTE: currently uncalled; kept for upcoming annotation emission. The
+    # foreign-attribute branch below needs the enclosing element, which the
+    # Moxml builder does not expose yet — port it together with that hook
+    # rather than reintroducing Nokogiri-style parent mutation.
     def add_annotations(xml, item, processor = nil)
       return unless item[:annotations]
 
@@ -440,6 +423,66 @@ module Rng
       end
     end
 
+    # Emit the grammar's <start>: an explicit leading start, or (when there is
+    # none) auto-wrap the first top-level choice/element. A non-leading start is
+    # emitted by the definitions loop, so here it only suppresses auto-wrapping.
+    def emit_grammar_start(xml, tree)
+      if tree[:start] && tree[:start][:start_pattern]
+        xml.start do
+          add_documentation(xml, tree[:start]) if tree[:start][:docs]
+          process_pattern_list(xml, tree[:start][:start_pattern])
+        end
+      elsif nonleading_start?(tree)
+        # Emitted as <start> by the definitions loop.
+      elsif (choice = tree[:definitions]&.find { |d| d.key?(:top_choice) })
+        emit_start_from_top_choice(xml, choice)
+      elsif (element = tree[:definitions]&.find { |d| d.key?(:top_element) })
+        xml.start { process_content_item(xml, element[:top_element]) }
+      end
+    end
+
+    def emit_start_from_top_choice(xml, first_choice)
+      xml.start do
+        xml.choice do
+          process_content_item(xml, first_choice[:top_choice][:first])
+          first_choice[:top_choice][:choice_items]&.each do |item|
+            process_content_item(xml, item)
+          end
+        end
+      end
+    end
+
+    # True when a `start = X` / `start |= X` appears outside the leading
+    # position and was parsed as a named pattern named "start".
+    def nonleading_start?(tree)
+      tree[:definitions]&.any? do |d|
+        d.key?(:name) && keyword_start_name?(d[:name])
+      end || false
+    end
+
+    # True when a named-pattern name is the `start` keyword, and NOT an escaped
+    # identifier `\start` (a define literally named "start", which must stay a
+    # <define>). The escape survives as a backslash_escape identifier part.
+    def keyword_start_name?(name_node)
+      process_identifier(name_node) == 'start' && !escaped_identifier?(name_node)
+    end
+
+    def escaped_identifier?(name_node)
+      parts = name_node.is_a?(Hash) ? name_node[:identifier_parts] : nil
+      Array(parts).any? { |p| p.is_a?(Hash) && p.key?(:backslash_escape) }
+    end
+
+    # Emit a real <start> for a non-leading `start = X` / `start |= X` that was
+    # parsed as a named pattern (a <define name="start"> would be wrong).
+    def emit_nonleading_start(xml, def_item)
+      op = def_item[:operator] ? extract_string(def_item[:operator]) : '='
+      combine = { '|=' => 'choice', '&=' => 'interleave' }[op]
+      xml.start(combine ? { combine: combine } : {}) do
+        add_documentation(xml, def_item) if def_item[:docs]
+        process_pattern_list(xml, def_item[:pattern])
+      end
+    end
+
     # Collect prefixed namespace declarations from preamble items
     def collect_namespace_prefixes(preamble_items)
       return unless preamble_items
@@ -707,7 +750,7 @@ module Rng
         # Bare anyName wildcard: *
         any_name_info = item[:bare_any_name]
         except_clause = any_name_info[:any_name_except]
-        xml.element do
+        xml.element({}) do
           xml.anyName do
             if except_clause
               xml.except_ do
@@ -722,6 +765,13 @@ module Rng
       end
     end
 
+    def wrap_with_occurrence(xml, occurrence, &block)
+      tag = OCCURRENCE_TAGS[occurrence.to_s] if occurrence
+      return yield unless tag
+
+      xml.send(tag, &block)
+    end
+
     def process_content_item(xml, item)
       if item.key?(:type) && item.key?(:name)
         # Attribute definition (has both :type and :name keys)
@@ -821,19 +871,7 @@ module Rng
           end
         end
 
-        if occurrence
-          # Wrap in occurrence element
-          occurrence_tag = case occurrence.to_s
-                           when '*' then 'zeroOrMore'
-                           when '+' then 'oneOrMore'
-                           when '?' then 'optional'
-                           end
-          xml.send(occurrence_tag) do
-            attribute_block.call(xml)
-          end
-        else
-          attribute_block.call(xml)
-        end
+        wrap_with_occurrence(xml, occurrence) { attribute_block.call(xml) }
       elsif item.key?(:name)
         # Element definition
         attrs = {}
@@ -886,7 +924,7 @@ module Rng
           case element_name_type
           when :any_name
             # Generate <anyName> with optional <except>
-            xml_ctx.element do
+            xml_ctx.element({}) do
               add_documentation(xml_ctx, item) if item[:docs]
               xml_ctx.anyName do
                 if except_clause
@@ -899,7 +937,7 @@ module Rng
             end
           when :ns_name
             # Generate <nsName> with ns attribute and optional <except>
-            xml_ctx.element do
+            xml_ctx.element({}) do
               add_documentation(xml_ctx, item) if item[:docs]
               xml_ctx.nsName(ns: ns_prefix) do
                 if except_clause
@@ -912,7 +950,7 @@ module Rng
             end
           when :name_choice
             # Element with choice of names (e.g., element foo|bar { ... })
-            xml_ctx.element do
+            xml_ctx.element({}) do
               add_documentation(xml_ctx, item) if item[:docs]
               xml_ctx.choice do
                 choice_names.each do |name_part|
@@ -939,26 +977,19 @@ module Rng
           end
         end
 
-        if occurrence
-          # Wrap in occurrence element
-          occurrence_tag = case occurrence.to_s
-                           when '*' then 'zeroOrMore'
-                           when '+' then 'oneOrMore'
-                           when '?' then 'optional'
-                           end
-
-          xml.send(occurrence_tag) do
-            element_block.call(xml)
-          end
-        else
-          element_block.call(xml)
-        end
+        wrap_with_occurrence(xml, occurrence) { element_block.call(xml) }
       elsif item.key?(:text)
-        xml.parent << Nokogiri::XML::Node.new('text', xml.doc)
+        wrap_with_occurrence(xml, item[:occurrence]) do
+          xml.text_
+        end
       elsif item.key?(:empty)
-        xml.parent << Nokogiri::XML::Node.new('empty', xml.doc)
+        wrap_with_occurrence(xml, item[:occurrence]) do
+          xml.empty_
+        end
       elsif item.key?(:not_allowed)
-        xml.parent << Nokogiri::XML::Node.new('notAllowed', xml.doc)
+        wrap_with_occurrence(xml, item[:occurrence]) do
+          xml.notAllowed_
+        end
       elsif item.key?(:list_content)
         xml.list do
           process_list_content(xml, item[:list_content])
@@ -968,21 +999,7 @@ module Rng
       elsif item.key?(:external_href)
         xml.externalRef(href: process_string_literal(item[:external_href]))
       elsif item.key?(:group)
-        occurrence = item[:occurrence]
-
-        if occurrence
-          occurrence_tag = case occurrence.to_s
-                           when '*' then 'zeroOrMore'
-                           when '+' then 'oneOrMore'
-                           when '?' then 'optional'
-                           end
-
-          xml.send(occurrence_tag) do
-            xml.group do
-              process_element_content(xml, item[:group])
-            end
-          end
-        else
+        wrap_with_occurrence(xml, item[:occurrence]) do
           xml.group do
             process_element_content(xml, item[:group])
           end
@@ -997,28 +1014,34 @@ module Rng
         ref_name = process_identifier(item[:ref])
         raise StandardError, "subtraction operator '-' cannot be used as a pattern" if ref_name == '-'
 
-        xml.ref(name: ref_name)
+        wrap_with_occurrence(xml, item[:occurrence]) do
+          xml.ref(name: ref_name)
+        end
       elsif item.key?(:prefix) && item.key?(:type)
         # Datatype reference (e.g., xsd:string { maxLength = "100" })
         data_attrs = {
           type: process_identifier(item[:type]),
           datatypeLibrary: 'http://www.w3.org/2001/XMLSchema-datatypes'
         }
-        if item[:params]
-          xml.data(data_attrs) do
-            params = item[:params].is_a?(Array) ? item[:params] : [item[:params]]
-            params.each do |param|
-              param_name = process_identifier(param[:param_name])
-              param_value = process_string_literal(param[:param_value])
-              xml.param(param_value, name: param_name)
+        wrap_with_occurrence(xml, item[:occurrence]) do
+          if item[:params]
+            xml.data(data_attrs) do
+              params = item[:params].is_a?(Array) ? item[:params] : [item[:params]]
+              params.each do |param|
+                param_name = process_identifier(param[:param_name])
+                param_value = process_string_literal(param[:param_value])
+                xml.param(param_value, name: param_name)
+              end
             end
+          else
+            xml.data(data_attrs)
           end
-        else
-          xml.data(data_attrs)
         end
       elsif item.key?(:value)
         # Value literal (string) in element content
-        xml.value(process_string_literal(item[:value]))
+        wrap_with_occurrence(xml, item[:occurrence]) do
+          xml.value(process_string_literal(item[:value]))
+        end
       elsif item.key?(:grammar_block)
         # Inline grammar block
         grammar_data = item[:grammar_block]
@@ -1158,11 +1181,9 @@ module Rng
 
     # Process a single list content item (datatype or text with optional occurrence)
     def process_list_item(xml, item)
-      occurrence = item[:occurrence]&.to_s
-
       item_block = lambda do |xml_ctx|
         if item.key?(:text)
-          xml_ctx.parent << Nokogiri::XML::Node.new('text', xml_ctx.doc)
+          xml_ctx.text_
         elsif item.key?(:prefix)
           # Datatype reference
           data_attrs = {
@@ -1179,18 +1200,7 @@ module Rng
         end
       end
 
-      if occurrence
-        occurrence_tag = case occurrence
-                         when '*' then 'zeroOrMore'
-                         when '+' then 'oneOrMore'
-                         when '?' then 'optional'
-                         end
-        xml.send(occurrence_tag) do
-          item_block.call(xml)
-        end
-      else
-        item_block.call(xml)
-      end
+      wrap_with_occurrence(xml, item[:occurrence]) { item_block.call(xml) }
     end
 
     # Process name except clause for wildcards
@@ -1243,18 +1253,17 @@ module Rng
 
     # Process attribute type content (factored out for wildcard support)
     def process_attribute_type(xml, type_info)
-      if type_info == 'text' || (type_info.is_a?(Hash) && type_info.key?(:text_type))
-        xml.parent << Nokogiri::XML::Node.new('text', xml.doc)
-      elsif type_info.is_a?(Hash) && type_info.key?(:value_choice)
-        # Choice of value literals
+      if type_info.is_a?(Hash) && type_info.key?(:attribute_choice)
+        # Choice of attribute items (text / value literals / refs)
         xml.choice do
-          # First value (before the choice operator)
-          xml.value(process_string_literal(type_info[:value]))
-          # Remaining values (after | operators)
-          type_info[:value_choice].each do |val|
-            xml.value(process_string_literal(val[:value]))
+          # The first item is hoisted alongside the rest of the choice
+          emit_attribute_choice_item(xml, type_info)
+          type_info[:attribute_choice].each do |item|
+            emit_attribute_choice_item(xml, item)
           end
         end
+      elsif type_info == 'text' || (type_info.is_a?(Hash) && type_info.key?(:text_type))
+        xml.text_
       elsif type_info.is_a?(Hash) && type_info.key?(:value)
         # Single value literal
         xml.value(process_string_literal(type_info[:value]))
@@ -1282,6 +1291,16 @@ module Rng
       end
     end
 
+    def emit_attribute_choice_item(xml, item)
+      if item.key?(:text_type)
+        xml.text_
+      elsif item.key?(:value)
+        xml.value(process_string_literal(item[:value]))
+      elsif item.key?(:ref)
+        xml.ref(name: process_identifier(item[:ref]))
+      end
+    end
+
     # Process data parameters (e.g., maxLength = "100")
     def process_data_params(xml, params)
       params = [params] unless params.is_a?(Array)
@@ -1402,7 +1421,7 @@ module Rng
       end
 
       # Emit as an empty foreign element (content is annotation-only, ignored in RNG)
-      xml.parent.add_child("<#{element_name}/>")
+      xml.create_tag(element_name)
     end
   end
 end