lutaml-model 0.8.17 → 0.8.18

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Lutaml
+  module Model
+    module Schema
+      # Derives the class name and default prefix for a generated
+      # XmlNamespace subclass from a namespace URI.
+      #
+      # Used by both XSD and RNG compilers so the same URI always
+      # produces the same class name across formats.
+      module NamespaceNaming
+        module_function
+
+        def prefix_for(uri)
+          case uri
+          when %r{/math$}    then "m"
+          when %r{XMLSchema} then "xs"
+          when %r{/(\w+)\z}  then ::Regexp.last_match(1)[0..2]
+          else "ns"
+          end
+        end
+
+        def class_name_for(uri)
+          return "XmlSchemaNamespace" if uri.include?("XMLSchema")
+
+          parsed = URI.parse(uri)
+          host_parts = (parsed.host&.split(".") || []).reject(&:empty?)
+          path_parts = (parsed.path&.split("/") || []).reject(&:empty?)
+
+          name_parts = host_parts.reverse.take(2) + path_parts.last(2)
+          name_parts = name_parts.map do |p|
+            Utils.camel_case(p.gsub(/\d+/, "").gsub(/[^a-zA-Z]/, ""))
+          end.reject(&:empty?)
+
+          return "DefaultNamespace" if name_parts.empty?
+
+          "#{name_parts.join}Namespace"
+        rescue URI::InvalidURIError
+          "DefaultNamespace"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Lutaml
+  module Model
+    module Schema
+      # Base class for per-format registry generators (one Ruby file that
+      # declares autoloads + a `self.register_all` that registers every
+      # generated class with the model registry).
+      #
+      # Subclasses customize the ERB skeleton (e.g., XSD adds import
+      # resolution phases) but inherit the shared module-wrap and
+      # autoload/registration emit methods.
+      class RegistryGenerator
+        DEFAULT_TEMPLATE = ERB.new(<<~TMPL, trim_mode: "-")
+          # frozen_string_literal: true
+          # Auto-generated central registry for <%= @module_namespace %>
+
+          <%= module_opening -%>
+          <%= autoload_declarations %>
+
+            def self.register_all
+              context = Lutaml::Model::GlobalContext.context(:<%= @register_id %>) ||
+                        Lutaml::Model::GlobalContext.create_context(id: :<%= @register_id %>)
+
+          <%= registration_body %>
+            end
+          <%= module_closing -%>
+        TMPL
+
+        def self.generate(model_entries, options = {})
+          new(model_entries, options).generate
+        end
+
+        # `model_entries` is an Array of CompiledOutput::Entry with kind
+        # `:model`. `options[:namespaces]` is an Array of `:namespace`
+        # entries, autoloaded but never registered.
+        def initialize(model_entries, options)
+          @classes = model_entries
+          @namespaces = options[:namespaces] || []
+          @module_namespace = options[:module_namespace]
+          @register_id = options[:register_id] || :default
+          @modules = @module_namespace&.split("::") || []
+        end
+
+        def generate
+          return nil unless @module_namespace
+
+          template.result(binding)
+        end
+
+        private
+
+        # Subclasses can override to use a different ERB skeleton.
+        def template
+          self.class::DEFAULT_TEMPLATE
+        end
+
+        # The body of `def self.register_all`. Default is just the
+        # registration block; subclasses can override to add extra phases
+        # (e.g., XSD's ensure_imports! / ensure_mappings_imported! passes).
+        def registration_body
+          registration_calls
+        end
+
+        # Inside-`register_all` indent, used by phase-comment overrides.
+        def body_indent
+          "  " * (module_depth + 1)
+        end
+
+        # Autoload every generated constant: model classes AND namespace
+        # classes. Models are then registered with `register_all`;
+        # namespaces are only autoloaded (model classes reference them
+        # in their `namespace ...` mapping declarations).
+        def autoload_declarations
+          indent = "  " * module_depth
+          module_subdir = @module_namespace.split("::").last.downcase
+          (@classes + @namespaces).map do |entry|
+            class_name = Utils.camel_case(entry.name)
+            file_name = Utils.snake_case(entry.name)
+            "#{indent}autoload :#{class_name}, " \
+              "File.join(__dir__, \"#{module_subdir}\", \"#{file_name}\")"
+          end.join("\n")
+        end
+
+        def registration_calls
+          indent = "  " * (module_depth + 1)
+          @classes.map do |entry|
+            class_name = Utils.camel_case(entry.name)
+            id = Utils.snake_case(entry.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")
+        end
+
+        # Thin forwarders so the ERB template using `<%= module_opening %>`
+        # / `<%= module_closing %>` keeps working. Logic lives in
+        # `Lutaml::Model::Schema::ModuleNesting`.
+        def module_opening
+          ModuleNesting.opening(Array(@modules))
+        end
+
+        def module_closing
+          ModuleNesting.closing(Array(@modules))
+        end
+
+        def module_depth
+          @modules.size
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/renderers/base.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Lutaml
+  module Model
+    module Schema
+      module Renderers
+        # Shared constructor and helpers for the value/namespace renderers
+        # (Union, RestrictedType, Namespace). Model has its own constructor
+        # because it computes an opt-out (module-wrappable) namespace.
+        class Base
+          def self.render(spec, **)
+            new(spec, **).render
+          end
+
+          def initialize(spec, indent: 2, module_namespace: nil, register_id: :default)
+            @spec = spec
+            @indent = indent.is_a?(Integer) ? " " * indent : indent
+            @extended_indent = @indent * 2
+            @module_namespace = module_namespace
+            @modules = module_namespace&.split("::") || []
+            @register_id = register_id
+          end
+
+          private
+
+          def required_files_block
+            files = @spec.required_files
+            files.empty? ? "" : "#{files.uniq.join("\n")}\n"
+          end
+
+          def module_opening = ModuleNesting.opening(@modules)
+          def module_closing = ModuleNesting.closing(@modules)
+          def boilerplate_indent_str = @indent
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/renderers/mappings.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Renderers
+        # Renders the `map_element` / `map_attribute` / `sequence do` lines
+        # inside the `xml do ... end` block of a generated class. Used by
+        # Renderers::Model.
+        class Mappings
+          def self.render(members, indent:, base_indent:, simple_content: nil)
+            new(indent: indent, base_indent: base_indent,
+                simple_content: simple_content).render(members)
+          end
+
+          def initialize(indent:, base_indent:, simple_content:)
+            @indent = indent
+            @base_indent = base_indent
+            @simple_content = simple_content
+          end
+
+          def render(members)
+            members.map { |m| render_one(m, @indent) }.join +
+              simple_content_attribute_mappings
+          end
+
+          private
+
+          def render_one(member, indent)
+            case member
+            when Definitions::Sequence    then render_sequence(member, indent)
+            when Definitions::Choice      then member.alternatives.map { |a| render_one(a, indent) }.join
+            when Definitions::Attribute   then render_attribute(member, indent)
+            when Definitions::GroupImport then "#{indent}import_model_mappings :#{member.name}\n"
+            end
+          end
+
+          def render_sequence(sequence, indent)
+            inner_indent = indent + @base_indent
+            inner = sequence.members.map { |m| render_one(m, inner_indent) }.join
+            "#{indent}sequence do\n#{inner}#{indent}end\n"
+          end
+
+          def render_attribute(attr, indent)
+            case attr.kind
+            when :element   then map_member("map_element", attr, indent)
+            when :attribute then map_member("map_attribute", attr, indent)
+            else ""
+            end
+          end
+
+          def map_member(verb, attr, indent)
+            %(#{indent}#{verb} "#{attr.xml_name}", to: :#{attr.name}#{render_options(attr)}\n)
+          end
+
+          def render_options(attr)
+            opts = []
+            opts << "render_default: true" if attr.render_default
+            opts << "render_empty: true"   if attr.render_empty
+            opts.empty? ? "" : ", #{opts.join(', ')}"
+          end
+
+          def simple_content_attribute_mappings
+            return "" unless @simple_content
+
+            @simple_content.additional_attributes.map { |a| render_one(a, @indent) }.join
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/renderers/member_decls.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Renderers
+        # Renders the attribute-declaration block of a generated class:
+        # the lines between `class X < Parent` and `xml do`. Used by
+        # Renderers::Model.
+        class MemberDecls
+          def self.render(members, indent:, base_indent:, mixed: false,
+                          text_content: false, simple_content: nil)
+            new(indent: indent, base_indent: base_indent,
+                mixed: mixed,
+                text_content: text_content,
+                simple_content: simple_content).render(members)
+          end
+
+          def initialize(indent:, base_indent:, mixed:, text_content:,
+                         simple_content:)
+            @indent = indent
+            @base_indent = base_indent
+            @mixed = mixed
+            @text_content = text_content
+            @simple_content = simple_content
+          end
+
+          def render(members)
+            lines = members.map { |m| render_one(m, @indent) }.join
+            lines + content_attribute_line + simple_content_extras
+          end
+
+          private
+
+          def render_one(member, indent)
+            case member
+            when Definitions::Choice      then render_choice(member, indent)
+            when Definitions::Sequence    then member.members.map { |m| render_one(m, indent) }.join
+            when Definitions::Attribute   then render_attribute(member, indent)
+            when Definitions::GroupImport then "#{indent}import_model_attributes :#{member.name}\n"
+            end
+          end
+
+          def render_choice(choice, indent)
+            inner_indent = indent + @base_indent
+            inner = choice.alternatives.map { |alt| render_one(alt, inner_indent) }.join
+            "#{indent}#{choice.header} do\n#{inner}#{indent}end\n"
+          end
+
+          def render_attribute(attr, indent)
+            doc = format_doc(attr.documentation, indent)
+            "#{doc}#{indent}attribute :#{attr.name}, #{type_literal(attr.type)}#{options_suffix(attr)}\n"
+          end
+
+          def format_doc(doc, indent)
+            return "" if Utils.blank?(doc&.to_s&.strip)
+
+            doc.to_s.lines.map { |line| "#{indent}# #{line.strip}\n" }.join
+          end
+
+          def type_literal(type_ref)
+            case type_ref.kind
+            when :symbol    then ":#{type_ref.value}"
+            when :class_ref then type_ref.value
+            when :w3c       then "::#{type_ref.value}"
+            end
+          end
+
+          def options_suffix(attr)
+            opts = []
+            opts << collection_option(attr.collection) if attr.collection
+            opts << "default: -> { #{attr.default.inspect} }" if attr.default
+            opts << "initialize_empty: true" if attr.initialize_empty
+            opts.empty? ? "" : ", #{opts.join(', ')}"
+          end
+
+          def collection_option(coll)
+            case coll
+            when true  then "collection: true"
+            when Range then range_option(coll)
+            end
+          end
+
+          def range_option(range)
+            ending = if range.end.respond_to?(:infinite?) && range.end.infinite?
+                       "Float::INFINITY"
+                     else
+                       range.end
+                     end
+            "collection: #{range.begin}..#{ending}"
+          end
+
+          def content_attribute_line
+            return simple_content_attribute if @simple_content
+            return "#{@indent}attribute :content, :string, collection: true\n" if @mixed
+            return "#{@indent}attribute :content, :string\n" if @text_content
+
+            ""
+          end
+
+          def simple_content_attribute
+            type_sym = Utils.snake_case(Utils.last_of_split(@simple_content.base_class))
+            "#{@indent}attribute :content, :#{type_sym}\n"
+          end
+
+          def simple_content_extras
+            return "" unless @simple_content
+
+            @simple_content.additional_attributes.map { |a| render_attribute(a, @indent) }.join
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Lutaml
+  module Model
+    module Schema
+      module Renderers
+        # Renders a Definitions::Model into a Lutaml::Model::Serializable
+        # subclass as Ruby source. Member-declaration and xml-mapping
+        # rendering is delegated to MemberDecls and Mappings.
+        class Model
+          def self.render(spec, **)
+            new(spec, **).render
+          end
+
+          def initialize(spec, indent: 2, module_namespace: nil, register_id: :default)
+            @spec = spec
+            @indent = indent.is_a?(Integer) ? " " * indent : indent
+            @extended_indent = @indent * 2
+            @raw_module_namespace = module_namespace
+            @register_id = register_id
+          end
+
+          def render
+            Templates::SERIALIZABLE_CLASS.result(binding)
+          end
+
+          private
+
+          # Effective namespace (nil when spec opts out of module wrapping).
+          def module_namespace
+            @spec.module_wrappable ? @raw_module_namespace : nil
+          end
+
+          def modules
+            module_namespace&.split("::") || []
+          end
+
+          def rendered_class_name = @spec.class_name
+          def serializable_class_parent = @spec.parent_class
+          def serializable_class_required_files = format_files(@spec.required_files)
+          def serializable_class_documentation = format_doc_block(@spec.documentation)
+          def serializable_class_imports = render_imports
+
+          def serializable_class_attributes
+            MemberDecls.render(
+              @spec.members,
+              indent: @indent,
+              base_indent: @indent,
+              mixed: @spec.mixed,
+              text_content: @spec.text_content,
+              simple_content: @spec.simple_content,
+            )
+          end
+
+          def xml_attribute_mappings
+            Mappings.render(
+              @spec.members,
+              indent: @extended_indent,
+              base_indent: @indent,
+              simple_content: @spec.simple_content,
+            )
+          end
+
+          def xml_root_directive_line
+            case @spec.xml_root.kind
+            when :element   then %(element "#{@spec.xml_root.name}")
+            when :type_name then %(type_name "#{@spec.xml_root.name}")
+            end
+          end
+
+          def xml_namespace_line
+            ns = @spec.namespace_class_name
+            ns && "namespace #{ns}"
+          end
+
+          def xml_mixed_content? = @spec.mixed
+          def xml_text_content? = @spec.text_content || !!@spec.simple_content || @spec.mixed
+          def xml_extra_mappings = ""
+
+          def module_opening = ModuleNesting.opening(modules)
+          def module_closing = ModuleNesting.closing(modules)
+          def boilerplate_indent_str = @indent
+
+          def registration_methods
+            Registration.methods_block(
+              class_name: @spec.class_name,
+              module_namespace: module_namespace,
+              indent: @indent,
+              lazy: @spec.lazy_register,
+            )
+          end
+
+          def registration_execution
+            Registration.execution_line(
+              class_name: @spec.class_name,
+              module_namespace: module_namespace,
+            )
+          end
+
+          def format_files(files)
+            return "" if files.empty? || module_namespace
+
+            "#{files.uniq.join("\n")}\n"
+          end
+
+          def format_doc_block(doc)
+            return "" if Utils.blank?(doc&.to_s&.strip)
+
+            doc.to_s.lines.map { |line| "# #{line.strip}\n" }.join
+          end
+
+          def render_imports
+            @spec.imports.map { |name| "#{@indent}import_model #{name}\n" }.join
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/renderers/namespace.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Lutaml
+  module Model
+    module Schema
+      module Renderers
+        # Renders a Definitions::Namespace into a
+        # Lutaml::Xml::W3c::XmlNamespace subclass.
+        class Namespace < Base
+          def render
+            Templates::XML_NAMESPACE.result(binding)
+          end
+
+          private
+
+          def class_name = @spec.class_name
+          def uri = @spec.uri
+          def prefix_default = @spec.prefix_default
+
+          def element_form_default_line
+            efd = @spec.element_form_default
+            efd && "element_form_default #{efd.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/renderers/registration.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Renderers
+        # Stateless helper for emitting the `self.register` and
+        # `self.register_class_with_id` method block plus the trailing
+        # execution line, shared by the Model, RestrictedType, and Union
+        # renderers.
+        #
+        # Cases:
+        #   module_namespace = nil          -> emit both methods + execution
+        #   namespace + keep_when_namespaced -> emit only `self.register`
+        #   namespace + !keep              -> emit nothing
+        module Registration
+          module_function
+
+          def methods_block(class_name:, module_namespace:, indent:,
+                            lazy: false, keep_when_namespaced: false)
+            return "" if module_namespace && !keep_when_namespaced
+            return register_only_block(indent, lazy) if module_namespace
+
+            full_block(class_name, indent, lazy)
+          end
+
+          def execution_line(class_name:, module_namespace:)
+            return "" if module_namespace
+
+            "\n#{class_name}.register_class_with_id\n"
+          end
+
+          def register_only_block(indent, lazy)
+            <<~REG.gsub(/^/, indent)
+
+              def self.register
+              #{indent}#{register_body(lazy)}
+              end
+            REG
+          end
+
+          def full_block(class_name, indent, lazy)
+            target = Utils.snake_case(class_name).to_sym
+            <<~REG.gsub(/^/, indent)
+
+              def self.register
+              #{indent}#{register_body(lazy)}
+              end
+
+              def self.register_class_with_id
+              #{indent}context = Lutaml::Model::GlobalContext.context(Lutaml::Model::Config.default_register)
+              #{indent}context.registry.register(:#{target}, self)
+              end
+            REG
+          end
+
+          def register_body(lazy)
+            lazy ? "@register ||= Lutaml::Model::Config.default_register" : "Lutaml::Model::Config.default_register"
+          end
+        end
+      end
+    end
+  end
+end