lutaml-model 0.8.17 → 0.8.18

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

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Lutaml
+  module Model
+    module Schema
+      # Compiles a parsed RNG grammar into Lutaml::Model::Serializable Ruby
+      # source. Mirrors XmlCompiler in API, options, and output format.
+      #
+      # Requires the `rng` gem (https://github.com/lutaml/rng) at runtime --
+      # that gem provides the Rng::Grammar parsing model. lutaml-model itself
+      # has no dependency on it. Registration of Schema.from_relaxng is done
+      # in lib/lutaml/xml.rb (alongside Schema.from_xml and Schema.to_relaxng).
+      #
+      # Entry point: Lutaml::Model::Schema::RngCompiler.to_models(rng, options)
+      module RngCompiler
+        extend self
+
+        autoload :MemberCollector,   "#{__dir__}/rng_compiler/member_collector"
+        autoload :ElementVisitor,    "#{__dir__}/rng_compiler/element_visitor"
+        autoload :DefineClassifier,  "#{__dir__}/rng_compiler/define_classifier"
+        autoload :ValueTypeResolver, "#{__dir__}/rng_compiler/value_type_resolver"
+        autoload :RngHelpers,        "#{__dir__}/rng_compiler/rng_helpers"
+
+        # Map RNG <data type="..."/> values to Lutaml::Model attribute type
+        # symbols. Mirrors Lutaml::Xml::Schema::RelaxngSchema.get_relaxng_type
+        # so RNG-generate + compile-back is a round-trip.
+        DATA_TYPE_MAP = {
+          "string" => :string,
+          "integer" => :integer,
+          "int" => :integer,
+          "long" => :integer,
+          "boolean" => :boolean,
+          "float" => :float,
+          "double" => :float,
+          "decimal" => :decimal,
+          "date" => :date,
+          "dateTime" => :date_time,
+          "time" => :time,
+        }.freeze
+
+        DEFAULT_DATA_TYPE = :string
+
+        def to_models(rng, options = {})
+          require_rng_parser!
+
+          opts = normalize_options(options)
+          output = compile(rng, opts)
+
+          dispatch_output(output, normalize_options(opts))
+        end
+
+        def compile(rng, options = {})
+          require_rng_parser!
+
+          opts = normalize_options(options)
+          grammar = parse_grammar(rng, opts)
+          classes, namespaces = compile_grammar(grammar)
+
+          entries =
+            classes.map { |name, spec| CompiledOutput::Entry.new(name, spec, :model) } +
+            namespaces.map { |name, spec| CompiledOutput::Entry.new(name, spec, :namespace) }
+
+          CompiledOutput.new(
+            entries: entries,
+            module_namespace: opts[:module_namespace],
+            register_id: opts[:register_id],
+          )
+        end
+
+        private
+
+        def require_rng_parser!
+          return if defined?(::Rng::Grammar)
+
+          raise "RNG schema compilation requires the rng gem. " \
+                "Add `gem \"rng\"` to your Gemfile."
+        end
+
+        def normalize_options(options)
+          opts = options.dup
+          opts[:indent]      ||= 2
+          opts[:register_id] ||= :default
+          opts
+        end
+
+        def parse_grammar(rng, options)
+          return rng if rng.is_a?(::Rng::Grammar)
+
+          if options[:location]
+            ::Rng.parse(rng, location: options[:location], resolve_external: true)
+          else
+            ::Rng::Grammar.from_xml(rng)
+          end
+        end
+
+        def dispatch_output(output, options)
+          if options[:create_files]
+            dir = options.fetch(
+              :output_dir,
+              options.fetch(:default_output_dir, "rng_models_#{Time.now.to_i}"),
+            )
+            FileWriter.write(output, dir)
+            true
+          elsif options[:load_classes]
+            ClassLoader.load(output)
+            output.sources
+          else
+            output.sources
+          end
+        end
+
+        # Returns [classes_hash, namespaces_hash]. `classes` holds
+        # Definitions::Model / Definitions::RestrictedType / Definitions::UnionType.
+        # `namespaces` holds Definitions::Namespace.
+        def compile_grammar(grammar)
+          defines = grammar.define.to_h { |d| [d.name, d] }
+          classes = {}
+          namespaces = {}
+          registrar = ->(uri) { register_namespace(namespaces, uri) }
+
+          default_uri = grammar_default_ns(grammar)
+          visitor = ElementVisitor.new(
+            defines, classes,
+            default_namespace_class: default_uri && registrar.call(default_uri),
+            register_namespace: registrar
+          )
+
+          grammar.start.each do |start|
+            visitor.compile_element(start.element) if start.element
+            Array(start.ref).each do |ref|
+              target = defines[ref.name]
+              visitor.compile_define(target) if target
+            end
+          end
+
+          # Sweep: compile any <define> not reachable from <start>.
+          grammar.define.each { |define| visitor.compile_define(define) }
+
+          finalize_models(classes)
+
+          [classes, namespaces]
+        end
+
+        def grammar_default_ns(grammar)
+          uri = grammar.respond_to?(:ns) ? grammar.ns : nil
+          uri if uri.is_a?(String) && !uri.empty?
+        end
+
+        # Build-or-find the namespace for `uri`; returns its class_name.
+        # RNG/RNC name-prefixed elements are namespace-qualified, so descendant
+        # elements inherit the namespace via element_form_default :qualified.
+        def register_namespace(namespaces, uri)
+          existing = namespaces.values.find { |ns| ns.uri == uri }
+          return existing.class_name if existing
+
+          # Distinct URIs can map to the same generated class name AND prefix
+          # (e.g. both `urn:a` and `urn:b` -> "DefaultNamespace"/"ns"); uniquify
+          # both so one namespace does not silently overwrite the other or
+          # collide with its prefix at serialization.
+          class_name = RngHelpers.unique_class_name(
+            namespaces, NamespaceNaming.class_name_for(uri)
+          )
+          ns = Definitions::Namespace.new(
+            class_name: class_name,
+            uri: uri,
+            prefix_default: unique_prefix(namespaces, NamespaceNaming.prefix_for(uri)),
+            element_form_default: :qualified,
+          )
+          namespaces[class_name] = ns
+          class_name
+        end
+
+        # A prefix that does not collide with an already-registered namespace's
+        # prefix (appends 2, 3, ... on collision).
+        def unique_prefix(namespaces, base)
+          taken = namespaces.values.map(&:prefix_default)
+          return base unless taken.include?(base)
+
+          counter = 2
+          counter += 1 while taken.include?("#{base}#{counter}")
+          "#{base}#{counter}"
+        end
+
+        # Set `required_files` so each generated file requires its
+        # dependencies: a Model requires its imports/class_ref types/namespace;
+        # a namespaced RestrictedType requires its namespace class.
+        def finalize_models(classes)
+          classes.each_value do |spec|
+            case spec
+            when Definitions::Model
+              spec.required_files =
+                Renderers::RequiredFilesCalculator.class_names_for_rng(spec)
+                  .map { |dep| require_relative_line(dep) }
+            when Definitions::RestrictedType
+              next unless spec.namespace_class_name
+
+              spec.required_files = namespaced_type_requires(spec)
+            end
+          end
+        end
+
+        # A namespaced RestrictedType requires its namespace class and, when it
+        # subclasses another generated type (a bare name, not a Lutaml built-in),
+        # that parent too.
+        def namespaced_type_requires(spec)
+          deps = [spec.namespace_class_name]
+          parent = spec.parent_class
+          deps << parent if parent && !parent.include?("::")
+          deps.map { |dep| require_relative_line(dep) }
+        end
+
+        def require_relative_line(class_name)
+          %(require_relative "#{Utils.snake_case(class_name)}")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Lutaml
+  module Model
+    module Schema
+      # Templates that are *actually* shared between schema compilers
+      # (XSD, RNG, future formats). Single-consumer templates live in
+      # the renderer that uses them — putting them here would just be
+      # relocation, not deduplication.
+      #
+      # Each constant is an `ERB.new(...)` evaluated via
+      # `TEMPLATE.result(binding)` from a renderer that exposes the
+      # required hook methods (documented above each template).
+      module Templates
+        # ----------------------------------------------------------------
+        # Single shape for any Lutaml::Model::Serializable subclass
+        # generated by ANY schema compiler. There is no per-format
+        # variant — adding a new xml directive here propagates to every
+        # compiler that uses this template. Consumed by:
+        #   - Lutaml::Model::Schema::Renderers::Model
+        #     (renders XSD complex types / groups and RNG generated classes)
+        #
+        # Required binding methods (renderer must expose all of these,
+        # returning "" / nil / false for inapplicable sections):
+        #
+        #   from ClassBoilerplate:
+        #     module_opening, module_closing,
+        #     registration_methods, registration_execution,
+        #     boilerplate_indent_str
+        #
+        #   identity / parent:
+        #     rendered_class_name                 String — CamelCase
+        #     serializable_class_parent           String — e.g. "Lutaml::Model::Serializable"
+        #
+        #   header:
+        #     serializable_class_required_files   String — `require_relative` lines or ""
+        #     serializable_class_documentation    String — doc comment block or ""
+        #
+        #   body — attribute declarations:
+        #     serializable_class_attributes       String — `attribute :foo, :bar` lines
+        #     serializable_class_imports          String — `import_model :foo` lines or ""
+        #
+        #   body — xml block:
+        #     xml_root_directive_line             String or nil — `element "X"` /
+        #                                         `type_name "X"` / nil to skip
+        #     xml_namespace_line                  String or nil — `namespace ClassName` / nil
+        #     xml_mixed_content?                  Boolean — emit `mixed_content`
+        #     xml_text_content?                   Boolean — emit `map_content to: :content`
+        #     xml_attribute_mappings              String — `map_element`/`map_attribute` lines
+        #     xml_extra_mappings                  String — extra mapping lines or ""
+        #                                         (e.g. XSD's simple_content tail)
+        # ----------------------------------------------------------------
+        SERIALIZABLE_CLASS = ERB.new(<<~TMPL, trim_mode: "-")
+          # frozen_string_literal: true
+
+          require "lutaml/model"
+          <%= serializable_class_required_files -%>
+          <%= module_opening -%>
+          <%= serializable_class_documentation -%>
+          class <%= rendered_class_name %> < <%= serializable_class_parent %>
+          <%= serializable_class_attributes -%>
+          <%= serializable_class_imports -%>
+          <%= "\n" if serializable_class_attributes.length.positive? || serializable_class_imports.length.positive? -%>
+          <%= boilerplate_indent_str %>xml do
+          <%- if xml_root_directive_line -%>
+          <%= boilerplate_indent_str * 2 %><%= xml_root_directive_line %>
+          <%- end -%>
+          <%- if xml_namespace_line -%>
+          <%= boilerplate_indent_str * 2 %><%= xml_namespace_line %>
+          <%- end -%>
+          <%- if xml_mixed_content? -%>
+          <%= boilerplate_indent_str * 2 %>mixed_content
+          <%- end -%>
+          <%- if xml_text_content? -%>
+          <%= boilerplate_indent_str * 2 %>map_content to: :content
+          <%- end -%>
+          <%= xml_attribute_mappings -%>
+          <%= xml_extra_mappings -%>
+          <%= boilerplate_indent_str %>end
+          <%= registration_methods -%>
+          end
+          <%= module_closing -%>
+          <%= registration_execution -%>
+        TMPL
+
+        # XmlNamespace subclass. Consumed by:
+        #   - Lutaml::Model::Schema::Renderers::Namespace
+        # Binding: module_opening, module_closing, class_name, uri, prefix_default.
+        XML_NAMESPACE = ERB.new(<<~TMPL, trim_mode: "-")
+          # frozen_string_literal: true
+
+          require "lutaml/model"
+
+          <%= module_opening -%>
+          # Namespace: <%= uri %>
+          class <%= class_name %> < Lutaml::Xml::W3c::XmlNamespace
+            uri <%= uri.inspect %>
+            prefix_default <%= prefix_default.inspect %>
+          <%- if element_form_default_line -%>
+            <%= element_form_default_line %>
+          <%- end -%>
+          end
+          <%= module_closing -%>
+        TMPL
+
+        # Restricted simple-type subclass (cast method that mutates options
+        # with facets then delegates to super). Consumed by:
+        #   - Lutaml::Model::Schema::Renderers::RestrictedType
+        # Binding: module_opening, module_closing, registration_methods,
+        # registration_execution, rendered_class_name, parent_class,
+        # xml_namespace_line, restricted_simple_type_required_files,
+        # restricted_simple_type_cast_body, boilerplate_indent_str.
+        RESTRICTED_SIMPLE_TYPE = ERB.new(<<~TMPL, trim_mode: "-")
+          # frozen_string_literal: true
+          require "lutaml/model"
+          <%= restricted_simple_type_required_files -%>
+          <%= module_opening -%>
+          class <%= rendered_class_name %><%= " < \#{parent_class}" if parent_class %>
+          <%- if xml_namespace_line -%>
+          <%= boilerplate_indent_str %>xml do
+          <%= boilerplate_indent_str * 2 %><%= xml_namespace_line %>
+          <%= boilerplate_indent_str %>end
+          <%- end -%>
+          <%= boilerplate_indent_str %>def self.cast(value, options = {})
+          <%= boilerplate_indent_str * 2 %>return if value.nil?
+
+          <%= restricted_simple_type_cast_body -%>
+          <%= boilerplate_indent_str * 2 %>value = super(value, options)
+          <%= boilerplate_indent_str * 2 %>value
+          <%= boilerplate_indent_str %>end
+          <%= registration_methods -%>
+          end
+          <%= module_closing -%>
+          <%= registration_execution -%>
+        TMPL
+
+        # Lutaml::Model::Type::Value union subclass. Consumed by:
+        #   - Lutaml::Model::Schema::Renderers::Union
+        # `union_cast_body` selects the cast strategy from the spec
+        # (XSD: `||`-chained resolve_type; RNG: each+rescue).
+        UNION_TYPE = ERB.new(<<~TMPL, trim_mode: "-")
+          # frozen_string_literal: true
+          require "lutaml/model"
+          <%= union_required_files -%>
+          <%= module_opening -%>
+          class <%= rendered_class_name %> < Lutaml::Model::Type::Value
+          <%= boilerplate_indent_str %>def self.cast(value, options = {})
+          <%= boilerplate_indent_str * 2 %>return if value.nil?
+
+          <%= union_cast_body -%>
+          <%= boilerplate_indent_str %>end
+          <%= registration_methods -%>
+          end
+          <%= module_closing -%>
+          <%= registration_execution -%>
+        TMPL
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/xml_compiler/element_order.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        # Iteration helper for the Lutaml::Xml XSD AST. Wraps the
+        # `#element_order` array each AST node carries with the special
+        # cases the compiler relies on:
+        #   * built-in `Xsd::Base` nodes already produce a resolved order
+        #   * `text`-only entries and `<import>` / `<include>` siblings
+        #     are skipped
+        #   * placeholders in the order are mapped to the matching child
+        #     accessor on the node so callers receive concrete AST values.
+        module ElementOrder
+          module_function
+
+          def resolved(object)
+            return [] if object.element_order.nil?
+
+            if object.is_a?(Lutaml::Xml::Schema::Xsd::Base)
+              return object.resolved_element_order
+            end
+
+            object.element_order.each_with_object(object.element_order.dup) do |builder, array|
+              next array.delete(builder) if builder.text? || ELEMENT_ORDER_IGNORABLE.include?(builder.name)
+
+              index = 0
+              array.each_with_index do |element, i|
+                next unless element == builder
+
+                array[i] = Array(object.public_send(Utils.snake_case(builder.name)))[index]
+                index += 1
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/xml_compiler/registry_generator.rb

@@ -1,124 +1,48 @@
 # frozen_string_literal: true
 
-require "erb"
-
 module Lutaml
   module Model
     module Schema
       module XmlCompiler
-        class RegistryGenerator
-          TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
-            # frozen_string_literal: true
-            # Auto-generated central registry for <%= @module_namespace %>
-
-            <%= module_opening %>
-            <%= autoload_declarations %>
-
-              def self.register_all
-                # Ensure context exists before using it
-                context = Lutaml::Model::GlobalContext.context(:<%= @register_id %>) ||
-                          Lutaml::Model::GlobalContext.create_context(id: :<%= @register_id %>)
-
-                # Phase 1: Register all models (no imports)
-            <%= registration_calls %>
-
-                # Phase 2: Resolve model, choice, and restrict imports
-            <%= model_import_resolution_calls %>
-
-                # Phase 3: Resolve mapping and sequence imports
-            <%= mapping_import_resolution_calls %>
-              end
-            <%= module_closing %>
-          TEMPLATE
-
-          def self.generate(classes_hash, options = {})
-            new(classes_hash, options).generate
-          end
-
-          def initialize(classes_hash, options)
-            @classes = classes_hash
-            @module_namespace = options[:module_namespace]
-            @register_id = options[:register_id] || :default
-            # Cache split modules for reuse
-            @modules = @module_namespace&.split("::") || []
-          end
-
-          def generate
-            return nil unless @module_namespace
-
-            TEMPLATE.result(binding)
-          end
-
+        # XSD registry generator. Extends the shared base with an extra
+        # phase for resolving model imports — XSD-generated classes use
+        # ensure_imports! hooks that need to run after every model is
+        # registered.
+        class RegistryGenerator < Lutaml::Model::Schema::RegistryGenerator
           private
 
-          def module_opening
-            return "" if @modules.empty?
-
-            @modules.map.with_index do |mod, i|
-              "#{'  ' * i}module #{mod}"
-            end.join("\n")
-          end
-
-          def module_closing
-            return "" if @modules.empty?
-
-            @modules.reverse.map.with_index do |_mod, i|
-              "#{'  ' * (@modules.size - i - 1)}end"
-            end.join("\n")
-          end
-
-          def autoload_declarations
-            indent = "  " * module_depth
-            @classes.keys.filter_map do |name|
-              class_name = Utils.camel_case(name)
-              file_name = Utils.snake_case(name)
-              # Use relative path from registry file location
-              module_subdir = @module_namespace.split("::").last.downcase
-              "#{indent}autoload :#{class_name}, File.join(__dir__, \"#{module_subdir}\", \"#{file_name}\")"
-            end.join("\n")
-          end
-
-          def registration_calls
-            indent = "  " * (module_depth + 1)
-            @classes.keys.filter_map do |name|
-              # Skip namespace classes (check the name, not the content)
-              next if name.to_s.include?("Namespace")
-
-              class_name = Utils.camel_case(name)
-              id = Utils.snake_case(name).to_sym
-              "#{indent}#{class_name} # Trigger autoload\n#{indent}context.registry.register(:#{id}, #{class_name})\n#{indent}#{class_name}.instance_variable_set(:@register, :#{@register_id})"
-            end.join("\n")
+          # Override the shared `registration_body` hook with three phases.
+          def registration_body
+            [
+              "#{body_indent}# Phase 1: Register all models (no imports)",
+              registration_calls,
+              "",
+              "#{body_indent}# Phase 2: Resolve model, choice, and restrict imports",
+              model_import_resolution_calls,
+              "",
+              "#{body_indent}# Phase 3: Resolve serialization mapping imports (sequence imports)",
+              mapping_import_resolution_calls,
+            ].join("\n")
           end
 
           def model_import_resolution_calls
-            indent = "  " * (module_depth + 1)
-            "\n#{indent}# Resolve model structure imports (attributes, choices)\n" +
-              @classes.keys.filter_map do |name|
-                next if name.to_s.include?("Namespace")
-
-                class_name = Utils.camel_case(name)
-                "#{indent}#{class_name}.ensure_imports!(:#{@register_id}) if #{class_name}.respond_to?(:ensure_imports!)"
-              end.join("\n")
+            @classes.map do |entry|
+              class_name = Utils.camel_case(entry.name)
+              "#{body_indent}#{class_name}.ensure_imports!(:#{@register_id}) " \
+                "if #{class_name}.respond_to?(:ensure_imports!)"
+            end.join("\n")
           end
 
+          # Only Serializable subclasses have mappings; simple-type and
+          # union-type subclasses (Lutaml::Model::Type::Value) do not.
+          # The emitted code guards with respond_to? so it works
+          # uniformly across both kinds of generated class.
           def mapping_import_resolution_calls
-            indent = "  " * (module_depth + 1)
-            "\n#{indent}# Resolve serialization mapping imports (sequence imports)\n" +
-              @classes.keys.filter_map do |name|
-                next if name.to_s.include?("Namespace")
-                next unless @classes[name].is_a?(Class) && @classes[name].include?(Lutaml::Model::Serialize)
-
-                class_name = Utils.camel_case(name)
-                "#{indent}#{class_name}.mappings[:xml].ensure_mappings_imported!(:#{@register_id}) if #{class_name}.mappings[:xml]&.respond_to?(:ensure_mappings_imported!)"
-              end.join("\n")
-          end
-
-          def module_depth
-            @modules.size
-          end
-
-          def module_path
-            @modules.map(&:downcase).join("/")
+            @classes.map do |entry|
+              class_name = Utils.camel_case(entry.name)
+              "#{body_indent}#{class_name}.mappings[:xml].ensure_mappings_imported!(:#{@register_id}) " \
+                "if #{class_name}.respond_to?(:mappings) && #{class_name}.mappings[:xml]&.respond_to?(:ensure_mappings_imported!)"
+            end.join("\n")
           end
         end
       end