lutaml-model 0.8.17 → 0.8.19

data/lib/lutaml/model/schema/rnc_compiler/source_resolver.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module RncCompiler
+        # Resolves RNC input text and the base directory used for relative
+        # include paths.
+        module SourceResolver
+          ResolvedSource =
+            Struct.new(:text, :base_dir, :path, keyword_init: true)
+
+          module_function
+
+          def resolve(input, options)
+            location = options[:location].to_s
+            return string_source(input) if location.empty?
+
+            expanded = File.expand_path(location)
+            if File.file?(expanded)
+              return file_source(expanded) if input.nil? || input.to_s.empty?
+
+              return string_source(input, base_dir: File.dirname(expanded), path: expanded)
+            end
+            return string_source(input, base_dir: expanded) if File.directory?(expanded)
+
+            string_source(input)
+          end
+
+          def string_source(input, base_dir: nil, path: nil)
+            ResolvedSource.new(text: input.to_s, base_dir: base_dir, path: path)
+          end
+
+          def file_source(path)
+            ResolvedSource.new(
+              text: File.read(path),
+              base_dir: File.dirname(path),
+              path: path,
+            )
+          end
+
+          private_class_method :string_source, :file_source
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/rnc_compiler.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      # Compiles RELAX NG Compact Syntax (RNC) into Lutaml::Model Ruby source.
+      #
+      # RNC support is a thin adapter: the rng gem parses the compact syntax
+      # into Rng::Grammar — resolving includes, bracket annotations, and
+      # non-leading `start` definitions natively — then RngCompiler performs all
+      # model generation and output handling.
+      module RncCompiler
+        extend self
+
+        autoload :SourceResolver, "#{__dir__}/rnc_compiler/source_resolver"
+
+        DEFAULT_OUTPUT_DIR_PREFIX = "rnc_models"
+
+        def to_models(rnc, options = {})
+          require_rnc_parser!
+
+          grammar = parse_grammar(rnc, options)
+
+          RngCompiler.to_models(
+            grammar,
+            options.merge(default_output_dir: default_output_dir),
+          )
+        end
+
+        def parse_grammar(rnc, options)
+          return rnc if rnc.is_a?(::Rng::Grammar)
+
+          source = SourceResolver.resolve(rnc, options)
+          ::Rng.parse_rnc(source.text, location: source.path || source.base_dir)
+        end
+
+        def require_rnc_parser!
+          return if rnc_parser_available?
+
+          raise "RNC schema compilation requires an rng gem whose " \
+                "`Rng.parse_rnc` accepts a `location:` option (for native " \
+                "include resolution). Point your Gemfile at an rng version " \
+                "that provides it."
+        end
+
+        # rng gained the `location:` option (native include resolution) after
+        # the 0.3.7 release; the released parse_rnc takes only `(rnc)`.
+        def rnc_parser_available?
+          defined?(::Rng::Grammar) && ::Rng.respond_to?(:parse_rnc) &&
+            ::Rng.method(:parse_rnc).parameters.any? { |_type, name| name == :location }
+        end
+
+        def default_output_dir
+          "#{DEFAULT_OUTPUT_DIR_PREFIX}_#{Time.now.to_i}"
+        end
+
+        private :parse_grammar, :require_rnc_parser!, :rnc_parser_available?,
+                :default_output_dir
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/rng_compiler/define_classifier.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module RngCompiler
+        # Detects the shape of a <define> body and builds the corresponding
+        # Definitions::* spec for it.
+        #
+        #   <data type="X"><param ...>...</param></data>      -> RestrictedType
+        #   <choice><value>a</value><value>b</value></choice> -> RestrictedType (enum)
+        #   <choice><data type="A"/><data type="B"/></choice> -> UnionType
+        #
+        # Returns nil when the define is structural (contains elements or
+        # attributes) — caller falls back to building a Definitions::Model.
+        class DefineClassifier
+          def self.build(define, class_name)
+            new(define, class_name).build
+          end
+
+          def initialize(define, class_name)
+            @define = define
+            @class_name = class_name
+          end
+
+          def build
+            return nil if structural_define?
+
+            union_type || data_restricted_type || enum_restricted_type
+          end
+
+          private
+
+          def structural_define?
+            @define.element.any? || @define.attribute.any?
+          end
+
+          def union_type
+            choice = value_choice
+            return nil unless RngHelpers.pure_union_choice?(choice)
+
+            type_refs = Array(choice.data).map do |d|
+              symbol = RngCompiler::DATA_TYPE_MAP.fetch(
+                d.type, RngCompiler::DEFAULT_DATA_TYPE
+              )
+              Definitions::TypeRef.new(
+                kind: :class_ref,
+                value: RngHelpers.parent_class_for(symbol),
+              )
+            end
+
+            Definitions::UnionType.new(
+              class_name: @class_name,
+              members: type_refs,
+              cast_strategy: :class_refs,
+            )
+          end
+
+          def data_restricted_type
+            data = RngHelpers.single(@define.data)
+            return nil unless data
+
+            base = RngCompiler::DATA_TYPE_MAP.fetch(
+              data.type, RngCompiler::DEFAULT_DATA_TYPE
+            )
+            Definitions::RestrictedType.new(
+              class_name: @class_name,
+              parent_class: RngHelpers.parent_class_for(base),
+              facets: RngHelpers.facet_from_data(data),
+            )
+          end
+
+          def enum_restricted_type
+            choice = value_choice
+            return nil unless RngHelpers.pure_value_choice?(choice)
+
+            Definitions::RestrictedType.new(
+              class_name: @class_name,
+              parent_class: RngHelpers.parent_class_for(:string),
+              facets: RngHelpers.facet_from_values(choice.value),
+            )
+          end
+
+          def value_choice
+            RngHelpers.single(@define.choice)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/rng_compiler/element_visitor.rb

@@ -0,0 +1,392 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module RngCompiler
+        # Walks an RNG <element> / <define> subtree and produces
+        # Definitions::Model / Definitions::RestrictedType / Definitions::UnionType
+        # objects, registered in the shared `classes` hash.
+        #
+        # Supported constructs:
+        #   element, attribute, ref, text, data, value, empty,
+        #   optional, zeroOrMore, oneOrMore, group, choice, mixed, list,
+        #   interleave
+        #
+        # Shape classification (define-wraps-data, define-wraps-enum-choice,
+        # union) is delegated to DefineClassifier. Value-shape resolution
+        # for individual children is delegated to ValueTypeResolver.
+        class ElementVisitor
+          DISPATCHABLE_KINDS = %i[
+            element attribute ref group optional oneOrMore zeroOrMore
+            choice list interleave empty
+          ].freeze
+
+          REPETITION_CTX = {
+            zeroOrMore: { collection: (0..Float::INFINITY), initialize_empty: true },
+            oneOrMore: { collection: (1..Float::INFINITY), initialize_empty: true },
+            list: { collection: (0..Float::INFINITY), initialize_empty: true },
+          }.freeze
+
+          HANDLERS = {
+            element: :handle_element,
+            attribute: :handle_attribute,
+            ref: :handle_ref,
+            group: :handle_group,
+            optional: :handle_optional,
+            oneOrMore: :handle_repeating,
+            zeroOrMore: :handle_repeating,
+            list: :handle_repeating,
+            choice: :handle_choice,
+            interleave: :handle_interleave,
+            empty: :handle_empty,
+          }.freeze
+
+          def initialize(defines, classes, default_namespace_class: nil,
+                         register_namespace: nil)
+            @defines = defines
+            @classes = classes
+            @default_namespace_class = default_namespace_class
+            @register_namespace = register_namespace
+            @value_type_resolver = ValueTypeResolver.new(
+              defines, classes,
+              compile_define: method(:compile_define),
+              register_class: method(:register_class!)
+            )
+          end
+
+          # Compile a top-level <element>. Always becomes a rooted model.
+          def compile_element(element)
+            class_name = Utils.camel_case(element.attr_name)
+            model = @classes[class_name] ||= Definitions::Model.new(
+              class_name: class_name,
+              xml_root: Definitions::XmlRoot.new(kind: :element, name: element.attr_name),
+              documentation: documentation_text(element),
+              namespace_class_name: namespace_class_for(element),
+            )
+            visit_content(element, model)
+            model
+          end
+
+          # Compile a <define> into a class.
+          # - Define body matches a simple-type shape -> RestrictedType/UnionType.
+          # - Wraps exactly one element                -> rooted Definitions::Model.
+          # - Multiple or zero wrapped elements        -> fragment Definitions::Model.
+          def compile_define(define)
+            class_name = Utils.camel_case(define.name)
+            return @classes[class_name] if @classes.key?(class_name)
+
+            if (simple = DefineClassifier.build(define, class_name))
+              register_class!(simple)
+              return simple
+            end
+
+            build_complex_define(define, class_name)
+          end
+
+          private
+
+          def build_complex_define(define, class_name)
+            wrapping = define.element.size == 1 ? define.element.first : nil
+
+            xml_root = if wrapping
+                         Definitions::XmlRoot.new(kind: :element, name: wrapping.attr_name)
+                       else
+                         Definitions::XmlRoot.new(kind: :fragment)
+                       end
+
+            model = Definitions::Model.new(
+              class_name: class_name,
+              xml_root: xml_root,
+              documentation: documentation_text(define) || documentation_text(wrapping),
+              namespace_class_name: namespace_class_for(wrapping || define),
+            )
+            register_class!(model)
+            visit_content(wrapping || define, model)
+            model
+          end
+
+          def register_class!(klass)
+            @classes[klass.class_name] = klass
+          end
+
+          # A node's foreign XML namespace URI, or nil. An empty `ns` (RNC's
+          # `ns=""` no-namespace override) and the built-in "xml" prefix are
+          # both treated as not foreign, so `namespace_class_for` hands the
+          # node the grammar default namespace. lutaml expresses namespaces
+          # only at class level, so a per-node `ns=""` override cannot be
+          # represented distinctly from the default and is not separately
+          # honored -- excluding "" here just avoids registering a bogus
+          # empty-URI namespace that would clobber the grammar default.
+          def foreign_namespace_uri(node)
+            uri = node.respond_to?(:ns) ? node.ns : nil
+            uri if uri.is_a?(String) && !uri.empty? && uri != "xml"
+          end
+
+          # An element's own ns (from `element ex:name`) becomes its model's
+          # class-level namespace; otherwise it inherits the grammar default.
+          def namespace_class_for(node)
+            uri = foreign_namespace_uri(node)
+            uri ? @register_namespace.call(uri) : @default_namespace_class
+          end
+
+          def documentation_text(node)
+            return nil unless node.respond_to?(:documentation)
+
+            docs = Array(node.documentation).map(&:to_s).reject(&:empty?)
+            docs.empty? ? nil : docs.join("\n")
+          end
+
+          # Generic content walker.
+          def visit_content(node, model, ctx = default_ctx)
+            ordered_children(node).each do |kind, child|
+              dispatch(kind, child, model, ctx)
+            end
+
+            model.mixed = true if mixed?(node)
+            model.text_content = true if text?(node)
+          end
+
+          def default_ctx
+            { collection: nil, initialize_empty: false }
+          end
+
+          def ordered_children(node)
+            element_entries = element_order_entries(node)
+            return fallback_each_child_kind(node) if element_entries.empty?
+
+            arrays = {}
+            indices = ::Hash.new(0)
+            element_entries.each_with_object([]) do |entry, pairs|
+              kind = entry.name.to_sym
+              next unless DISPATCHABLE_KINDS.include?(kind) && node.respond_to?(kind)
+
+              children = arrays[kind] ||= Array(node.public_send(kind))
+              child = children[indices[kind]]
+              indices[kind] += 1
+              pairs << [kind, child] if child
+            end
+          end
+
+          def element_order_entries(node)
+            return [] unless node.respond_to?(:element_order)
+
+            Array(node.element_order).select do |e|
+              e.respond_to?(:node_type) && e.node_type == :element
+            end
+          end
+
+          def fallback_each_child_kind(node)
+            DISPATCHABLE_KINDS.each_with_object([]) do |attr_name, pairs|
+              next unless node.respond_to?(attr_name)
+
+              Array(node.public_send(attr_name)).each do |child|
+                pairs << [attr_name, child] unless child.nil?
+              end
+            end
+          end
+
+          def dispatch(kind, child, parent, ctx)
+            handler = HANDLERS[kind] or return
+
+            send(handler, kind, child, parent, ctx)
+          end
+
+          # --- handlers ---------------------------------------------------
+
+          def handle_element(_kind, child, parent, ctx)
+            doc = documentation_text(child)
+            value_type = @value_type_resolver.resolve(child)
+            type_ref = type_ref_for_element(child, value_type)
+            push_attribute(parent, build_attribute(child, type_ref, :element, ctx, doc))
+          end
+
+          def type_ref_for_element(child, value_type)
+            return Definitions::TypeRef.new(kind: :symbol, value: value_type.to_s) if value_type
+
+            compiled = compile_element(child)
+            Definitions::TypeRef.new(kind: :class_ref, value: compiled.class_name)
+          end
+
+          def handle_attribute(_kind, child, parent, ctx)
+            doc = documentation_text(child)
+            symbol = attribute_type_symbol(child)
+            type_ref = Definitions::TypeRef.new(kind: :symbol, value: symbol.to_s)
+            fixed = fixed_value_default(child)
+            push_attribute(parent, build_attribute(child, type_ref, :attribute, ctx, doc, default: fixed))
+          end
+
+          # The attribute's value type, as a Symbol. An attribute in a foreign
+          # namespace (a prefix other than the built-in "xml") must carry that
+          # namespace, which lutaml-model expresses only through a Type::Value
+          # subclass — so wrap the value in a generated namespaced type.
+          def attribute_type_symbol(child)
+            base = @value_type_resolver.resolve(child) || :string
+            uri = foreign_namespace_uri(child)
+            return base unless uri
+
+            namespaced_attribute_type(child, base, @register_namespace.call(uri))
+          end
+
+          # Give the attribute's value a namespace via a dedicated generated
+          # type — never by mutating the resolved type, which may be a named
+          # define or an inline type shared with unqualified members. When the
+          # resolved base is itself a generated RestrictedType, subclass it so
+          # its constraints are inherited; otherwise subclass the built-in base.
+          def namespaced_attribute_type(child, base, ns_class)
+            resolved = generated_type_for(base)
+            parent = resolved ? resolved.class_name : RngHelpers.parent_class_for(base)
+
+            type = Definitions::RestrictedType.new(
+              class_name: RngHelpers.unique_class_name(
+                @classes, "#{Utils.camel_case(child.attr_name)}Type"
+              ),
+              parent_class: parent,
+              facets: Definitions::Facet.new,
+              namespace_class_name: ns_class,
+            )
+            register_class!(type)
+            RngHelpers.type_symbol(type.class_name)
+          end
+
+          # The generated RestrictedType a resolved type symbol refers to, found
+          # by symbol identity (so acronym class names round-trip) — or nil for a
+          # built-in symbol. A built-in symbol always means the built-in type,
+          # even if a define shares its name (a custom `dateTime` must not shadow
+          # the primitive `:date_time`).
+          def generated_type_for(base)
+            return nil if Lutaml::Model::Type::TYPE_CODES.key?(base)
+
+            @classes.values.find do |klass|
+              klass.is_a?(Definitions::RestrictedType) &&
+                RngHelpers.type_symbol(klass.class_name) == base
+            end
+          end
+
+          def build_attribute(child, type_ref, kind, ctx, doc, default: nil)
+            xml_name = xml_name_for(child)
+            Definitions::Attribute.new(
+              name: Utils.snake_case(xml_name.tr(":", "_")),
+              type: type_ref,
+              xml_name: xml_name,
+              kind: kind,
+              collection: ctx[:collection] || false,
+              initialize_empty: ctx[:initialize_empty] || false,
+              documentation: doc,
+              default: default,
+            )
+          end
+
+          def xml_name_for(child)
+            name = child.attr_name
+            ns = child.respond_to?(:ns) ? child.ns : nil
+            return name unless ns == "xml"
+
+            "#{ns}:#{name}"
+          end
+
+          # <attribute name="x"><value>X</value></attribute> = fixed value.
+          # Match XSD compiler's behavior — emit `default: -> { "X" }` so
+          # the value round-trips even when omitted.
+          def fixed_value_default(container)
+            return nil unless container.respond_to?(:value)
+
+            values = Array(container.value)
+            return nil if values.size != 1
+            return nil if RngHelpers.structural_content?(container)
+
+            values.first.value.to_s
+          end
+
+          def handle_ref(_kind, ref, parent, ctx)
+            target_define = @defines[ref.name]
+            raise Lutaml::Model::Error, "ref to unknown define: #{ref.name}" unless target_define
+
+            target_class = compile_define(target_define)
+
+            if RngHelpers.simple_type?(target_class)
+              type_ref = Definitions::TypeRef.new(kind: :symbol, value: RngHelpers.type_symbol(target_class.class_name).to_s)
+              push_attribute(parent, build_ref_attribute(ref, type_ref, ref.name, ctx))
+            elsif RngHelpers.fragment_model?(target_class) && ctx[:collection].nil?
+              push_import(parent, target_class.class_name)
+            else
+              type_ref = Definitions::TypeRef.new(kind: :class_ref, value: target_class.class_name)
+              xml_name = target_class.xml_root.name || ref.name
+              push_attribute(parent, build_ref_attribute(ref, type_ref, xml_name, ctx))
+            end
+          end
+
+          def build_ref_attribute(ref, type_ref, xml_name, ctx)
+            Definitions::Attribute.new(
+              name: Utils.snake_case(ref.name),
+              type: type_ref,
+              xml_name: xml_name,
+              kind: :element,
+              collection: ctx[:collection] || false,
+              initialize_empty: ctx[:initialize_empty] || false,
+            )
+          end
+
+          # <group> = ordered sequence of items.
+          def handle_group(_kind, group, parent, ctx)
+            collector = MemberCollector.new
+            visit_content(group, collector, ctx)
+            return if collector.members.empty?
+
+            parent.members << Definitions::Sequence.new(members: collector.members)
+            collector.imports.each { |name| push_import(parent, name) }
+          end
+
+          def handle_optional(_kind, opt, parent, ctx)
+            visit_content(opt, parent, ctx)
+          end
+
+          def handle_interleave(_kind, interleave, parent, ctx)
+            visit_content(interleave, parent, ctx)
+          end
+
+          def handle_repeating(kind, node, parent, ctx)
+            visit_content(node, parent, ctx.merge(REPETITION_CTX.fetch(kind)))
+          end
+
+          def handle_choice(_kind, choice, parent, ctx)
+            return if RngHelpers.pure_value_choice?(choice)
+
+            collector = MemberCollector.new
+            visit_content(choice, collector, ctx)
+            return if collector.members.empty?
+
+            parent.members << Definitions::Choice.new(
+              alternatives: collector.members,
+              header: "choice",
+            )
+            collector.imports.each { |name| push_import(parent, name) }
+          end
+
+          def handle_empty(_kind, _child, _parent, _ctx)
+            # <empty/> contributes no content — intentionally no-op.
+          end
+
+          def push_attribute(parent, attr)
+            parent.members.reject! do |m|
+              m.is_a?(Definitions::Attribute) && m.name == attr.name
+            end
+            parent.members << attr
+          end
+
+          def push_import(parent, name)
+            parent.imports << name unless parent.imports.include?(name)
+          end
+
+          def mixed?(node)
+            node.respond_to?(:mixed) && Utils.present?(node.mixed)
+          end
+
+          def text?(node)
+            node.respond_to?(:text) && Utils.present?(node.text)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/rng_compiler/member_collector.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module RngCompiler
+        # Lightweight accumulator used by ElementVisitor when collecting the
+        # children of a transient construct (`<group>`, `<choice>`) before
+        # promoting them into a Definitions::Sequence or Definitions::Choice on
+        # the real Definitions::Model.
+        #
+        # Mirrors the surface ElementVisitor expects on a model
+        # (members, imports, mixed, text_content) but with no XML root,
+        # documentation, or namespace — none of which apply to a scratch
+        # container.
+        class MemberCollector
+          attr_reader :members, :imports
+          attr_accessor :mixed, :text_content
+
+          def initialize
+            @members = []
+            @imports = []
+            @mixed = false
+            @text_content = false
+          end
+        end
+      end
+    end
+  end
+end