lutaml-model 0.8.17 → 0.8.19

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

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Renderers
+        # Computes the `require_relative` / `require` lines that a
+        # generated Definitions::Model needs at the top of its file.
+        #
+        # XSD and RNG have different strategies because their type
+        # references mean different things:
+        #
+        # - XSD attributes carry TypeRef(:w3c | :symbol | :class_ref):
+        #     :w3c       -> require "lutaml/xml/w3c"
+        #     :symbol    -> require_relative "<value>"
+        #                    (unless the value is a skippable built-in)
+        #                    decimal is special: require "bigdecimal"
+        #     :class_ref -> no require (class is autoloaded by registry)
+        #   Plus any required_files surfaced by simple_content + the
+        #   namespace class.
+        #
+        # - RNG attributes only ever reference other generated classes
+        #   via :class_ref, so the calculator only collects class names
+        #   (imports + class_ref types + namespace) and the caller
+        #   formats them as `require_relative "snake_case_name"`.
+        module RequiredFilesCalculator
+          module_function
+
+          # XSD strategy. `skippable_type?` is a one-arg predicate the
+          # caller supplies so the calculator doesn't have to know the
+          # XSD built-in type table.
+          def for_xml(model, skippable_type:)
+            deps = []
+            Definitions::MemberWalk.each_attribute(model.members) do |attr|
+              deps.concat(xml_attribute_requires(attr, skippable_type))
+            end
+            deps.concat(simple_content_requires(model.simple_content, skippable_type))
+            deps << namespace_require(model.namespace_class_name) if model.namespace_class_name
+            deps.uniq
+          end
+
+          # RNG strategy. Returns the de-duplicated list of generated-class
+          # names the model depends on; caller wraps as `require_relative`.
+          def class_names_for_rng(model)
+            deps = model.imports.dup
+            Definitions::MemberWalk.each_attribute(model.members) do |attr|
+              deps << attr.type.value if attr.type.kind == :class_ref
+            end
+            deps << model.namespace_class_name if model.namespace_class_name
+            deps.uniq
+          end
+
+          def namespace_require(class_name)
+            %(require_relative "#{Utils.snake_case(class_name)}")
+          end
+
+          def xml_attribute_requires(attr, skippable_type)
+            ref = attr.type
+            return [] unless ref
+
+            case ref.kind
+            when :w3c       then ['require "lutaml/xml/w3c"']
+            when :symbol    then xml_symbol_requires(ref.value, skippable_type)
+            when :class_ref then []
+            else []
+            end
+          end
+
+          def xml_symbol_requires(value, skippable_type)
+            return [%(require "bigdecimal")] if value == "decimal"
+            return [] if skippable_type.call(value)
+
+            [%(require_relative "#{value}")]
+          end
+
+          # base_class arrives as a raw XSD name (e.g. "xs:dateTime"). The
+          # built-in skippable check keys on the XSD spelling (`:dateTime`),
+          # not the snake_case file form, so test against `local` directly
+          # before emitting the require_relative.
+          def simple_content_requires(simple_content, skippable_type)
+            return [] if simple_content.nil? || simple_content.base_class.nil?
+
+            local = Utils.last_of_split(simple_content.base_class)
+            return [%(require "bigdecimal")] if local == "decimal"
+            return [] if skippable_type.call(local)
+
+            [%(require_relative "#{Utils.snake_case(local)}")]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Lutaml
+  module Model
+    module Schema
+      module Renderers
+        # Renders a Definitions::RestrictedType into a Ruby class extending
+        # a Lutaml::Model::Type::* with a cast body that mutates options
+        # with facet values and delegates to super.
+        class RestrictedType < Base
+          def render
+            Templates::RESTRICTED_SIMPLE_TYPE.result(binding)
+          end
+
+          private
+
+          def rendered_class_name = @spec.class_name
+          def parent_class = @spec.parent_class
+
+          def xml_namespace_line
+            ns = @spec.namespace_class_name
+            ns && "namespace #{ns}"
+          end
+
+          def restricted_simple_type_required_files = required_files_block
+
+          def restricted_simple_type_cast_body
+            [
+              render_min_max,
+              render_pattern,
+              render_enumerations,
+              render_transform,
+            ].compact.join
+          end
+
+          def render_min_max
+            f = @spec.facets
+            max = f.max_inclusive || f.max_exclusive
+            min = f.min_inclusive || f.min_exclusive
+            return nil unless max || min
+
+            out = +""
+            out << "#{@extended_indent}options[:max] = #{max}\n" if max
+            out << "#{@extended_indent}options[:min] = #{min}\n" if min
+            out
+          end
+
+          def render_pattern
+            p = @spec.facets.pattern
+            p && "#{@extended_indent}options[:pattern] = %r{#{p}}\n"
+          end
+
+          def render_enumerations
+            e = @spec.facets.enumerations
+            return nil if e.nil? || e.empty?
+
+            casted = e.map { |v| "super(#{v.inspect})" }.join(", ")
+            "#{@extended_indent}options[:values] = [#{casted}]\n"
+          end
+
+          def render_transform
+            t = @spec.transform_facet
+            t && "#{@extended_indent}value = #{t.expression}\n"
+          end
+
+          def registration_methods
+            Registration.methods_block(
+              class_name: @spec.class_name,
+              module_namespace: @module_namespace,
+              indent: @indent,
+              lazy: true,
+              keep_when_namespaced: @spec.keep_register_when_namespaced,
+            )
+          end
+
+          def registration_execution
+            Registration.execution_line(
+              class_name: @spec.class_name,
+              module_namespace: @module_namespace,
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Lutaml
+  module Model
+    module Schema
+      module Renderers
+        # Renders a Definitions::UnionType into a
+        # Lutaml::Model::Type::Value subclass with a cast body whose
+        # strategy is chosen from the spec.
+        class Union < Base
+          def render
+            Templates::UNION_TYPE.result(binding)
+          end
+
+          private
+
+          def rendered_class_name = @spec.class_name
+
+          def union_required_files = required_files_block
+
+          def union_cast_body
+            case @spec.cast_strategy
+            when :resolve_type then resolve_type_body
+            when :class_refs   then class_refs_body
+            end
+          end
+
+          def resolve_type_body
+            chain = @spec.members.map { |m| resolve_type_call(m) }
+            "#{@extended_indent}#{chain.join(" ||\n  ")}\n"
+          end
+
+          def resolve_type_call(type_ref)
+            "Lutaml::Model::GlobalContext.resolve_type(:#{type_ref.value}, @register).cast(value, options)"
+          end
+
+          def class_refs_body
+            classes = @spec.members.map { |m| literal_class(m) }.join(", ")
+            sp2 = @extended_indent
+            <<~BODY
+              #{sp2}[#{classes}].each do |t|
+              #{sp2}  begin
+              #{sp2}    casted = t.cast(value, options)
+              #{sp2}    return casted unless casted.nil?
+              #{sp2}  rescue StandardError
+              #{sp2}    next
+              #{sp2}  end
+              #{sp2}end
+              #{sp2}value
+            BODY
+          end
+
+          def literal_class(type_ref)
+            case type_ref.kind
+            when :class_ref then type_ref.value
+            when :w3c       then "::#{type_ref.value}"
+            when :symbol    then "Lutaml::Model::GlobalContext.resolve_type(:#{type_ref.value})"
+            end
+          end
+
+          def registration_methods
+            Registration.methods_block(
+              class_name: @spec.class_name,
+              module_namespace: @module_namespace,
+              indent: @indent,
+              lazy: @spec.lazy_register,
+              keep_when_namespaced: @spec.keep_register_when_namespaced,
+            )
+          end
+
+          def registration_execution
+            Registration.execution_line(
+              class_name: @spec.class_name,
+              module_namespace: @module_namespace,
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Renderers
+        autoload :Base,         "#{__dir__}/renderers/base"
+        autoload :Registration, "#{__dir__}/renderers/registration"
+        autoload :RequiredFilesCalculator, "#{__dir__}/renderers/required_files_calculator"
+        autoload :MemberDecls,    "#{__dir__}/renderers/member_decls"
+        autoload :Mappings,       "#{__dir__}/renderers/mappings"
+        autoload :Model,          "#{__dir__}/renderers/model"
+        autoload :RestrictedType, "#{__dir__}/renderers/restricted_type"
+        autoload :Union,          "#{__dir__}/renderers/union"
+        autoload :Namespace,      "#{__dir__}/renderers/namespace"
+      end
+    end
+  end
+end