lutaml-model 0.8.17 → 0.8.19

data/lib/lutaml/model/schema/definitions/member_walk.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Definitions
+        # Stateless traversal helpers for the heterogeneous `members`
+        # array of a Definitions::Model. Definitions stay as pure data;
+        # the walk logic lives here so consumers (XmlCompiler /
+        # RngCompiler dependency collection, future visitors) don't each
+        # re-implement the same case-dispatch.
+        module MemberWalk
+          module_function
+
+          # Yields every Attribute leaf, recursing into Sequence members
+          # and Choice alternatives. Returns an Enumerator when called
+          # without a block.
+          def each_attribute(members, &block)
+            return enum_for(:each_attribute, members) unless block
+
+            members.each do |member|
+              case member
+              when Attribute then yield member
+              when Sequence  then each_attribute(member.members, &block)
+              when Choice    then each_attribute(member.alternatives, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Definitions
+        # One generated Lutaml::Model::Serializable subclass.
+        class Model
+          attr_accessor :class_name, :xml_root, :members,
+                        :parent_class, :namespace_class_name,
+                        :mixed, :text_content, :imports,
+                        :documentation, :simple_content, :required_files,
+                        :module_wrappable, :lazy_register
+
+          def initialize(class_name:, xml_root:, members: [],
+                         parent_class: "Lutaml::Model::Serializable",
+                         namespace_class_name: nil,
+                         mixed: false, text_content: false,
+                         imports: [], documentation: nil,
+                         simple_content: nil, required_files: [],
+                         module_wrappable: true, lazy_register: false)
+            @class_name = class_name
+            @xml_root = xml_root
+            @members = members
+            @parent_class = parent_class
+            @namespace_class_name = namespace_class_name
+            @mixed = mixed
+            @text_content = text_content
+            @imports = imports
+            @documentation = documentation
+            @simple_content = simple_content
+            @required_files = required_files
+            @module_wrappable = module_wrappable
+            @lazy_register = lazy_register
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Definitions
+        # An XML namespace declaration (subclass of
+        # Lutaml::Xml::W3c::XmlNamespace).
+        class Namespace
+          attr_accessor :class_name, :uri, :prefix_default, :element_form_default
+
+          def initialize(class_name:, uri:, prefix_default: nil,
+                         element_form_default: nil)
+            @class_name = class_name
+            @uri = uri
+            @prefix_default = prefix_default
+            @element_form_default = element_form_default
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Definitions
+        # Restricted simple type — `class X < Lutaml::Model::Type::Y`
+        # with a cast body that applies facets and delegates to super.
+        class RestrictedType
+          attr_accessor :class_name, :parent_class, :facets,
+                        :transform_facet, :required_files,
+                        :keep_register_when_namespaced, :namespace_class_name
+
+          def initialize(class_name:, facets:, parent_class: nil,
+                         transform_facet: nil, required_files: [],
+                         keep_register_when_namespaced: false,
+                         namespace_class_name: nil)
+            @class_name = class_name
+            @parent_class = parent_class
+            @facets = facets
+            @transform_facet = transform_facet
+            @required_files = required_files
+            @keep_register_when_namespaced = keep_register_when_namespaced
+            @namespace_class_name = namespace_class_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/definitions/sequence.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Definitions
+        # A `sequence do ... end` group. Transparent in attribute
+        # declarations; wraps with `sequence do` only in xml mappings.
+        class Sequence
+          attr_accessor :members
+
+          def initialize(members:)
+            @members = members
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/definitions/simple_content.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Definitions
+        # XSD-only: a complex type with simple content (a typed text
+        # body plus optional decorating attributes). The renderer emits
+        # `attribute :content, :<base_type>` and any additional
+        # attributes after the regular members. RNG leaves this nil.
+        class SimpleContent
+          attr_accessor :base_class, :additional_attributes
+
+          def initialize(base_class:, additional_attributes: [])
+            @base_class = base_class
+            @additional_attributes = additional_attributes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/definitions/transform_facet.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Definitions
+        # XSD-only value transform applied during cast. The expression
+        # is raw Ruby emitted as `value = <expression>` before super.
+        # E.g. "value.gsub(/[\\r\\n\\t]/, ' ')" or "value.upcase". RNG
+        # leaves this nil.
+        class TransformFacet
+          attr_accessor :expression
+
+          def initialize(expression:)
+            @expression = expression
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/definitions/type_ref.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Definitions
+        # Reference to a Ruby type used in a generated attribute.
+        # kind ∈ {:symbol, :class_ref, :w3c}.
+        class TypeRef
+          attr_accessor :kind, :value
+
+          def initialize(kind:, value:)
+            @kind = kind
+            @value = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/definitions/union_type.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Definitions
+        # Union type — Lutaml::Model::Type::Value subclass whose cast
+        # tries each member type and returns the first that parses.
+        # cast_strategy ∈ {:resolve_type, :class_refs}.
+        class UnionType
+          attr_accessor :class_name, :members, :cast_strategy, :required_files,
+                        :lazy_register, :keep_register_when_namespaced
+
+          def initialize(class_name:, members:, cast_strategy:,
+                         required_files: [], lazy_register: false,
+                         keep_register_when_namespaced: false)
+            @class_name = class_name
+            @members = members
+            @cast_strategy = cast_strategy
+            @required_files = required_files
+            @lazy_register = lazy_register
+            @keep_register_when_namespaced = keep_register_when_namespaced
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/definitions/xml_root.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Definitions
+        # XML root directive of a generated class.
+        # kind ∈ {:element, :type_name, :fragment}. name is nil for :fragment.
+        class XmlRoot
+          attr_accessor :kind, :name
+
+          def initialize(kind:, name: nil)
+            @kind = kind
+            @name = name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Definitions
+        autoload :GroupImport,    "#{__dir__}/definitions/group_import"
+        autoload :MemberWalk,     "#{__dir__}/definitions/member_walk"
+        autoload :TypeRef,        "#{__dir__}/definitions/type_ref"
+        autoload :XmlRoot,        "#{__dir__}/definitions/xml_root"
+        autoload :Attribute,      "#{__dir__}/definitions/attribute"
+        autoload :Choice,         "#{__dir__}/definitions/choice"
+        autoload :Sequence,       "#{__dir__}/definitions/sequence"
+        autoload :Facet,          "#{__dir__}/definitions/facet"
+        autoload :TransformFacet, "#{__dir__}/definitions/transform_facet"
+        autoload :SimpleContent,  "#{__dir__}/definitions/simple_content"
+        autoload :Model,          "#{__dir__}/definitions/model"
+        autoload :RestrictedType, "#{__dir__}/definitions/restricted_type"
+        autoload :UnionType,      "#{__dir__}/definitions/union_type"
+        autoload :Namespace,      "#{__dir__}/definitions/namespace"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Lutaml
+  module Model
+    module Schema
+      # Writes a CompiledOutput to disk: per-class .rb files in a module
+      # subdirectory plus a central `*_registry.rb` (when a module
+      # namespace is set). Shared between XSD and RNG compilers.
+      #
+      # The `registry_generator:` parameter selects which RegistryGenerator
+      # subclass to use (XSD has a 2-phase template; RNG uses the default).
+      class FileWriter
+        def self.write(output, dir, registry_generator: RegistryGenerator)
+          new(output, dir, registry_generator).write
+        end
+
+        def initialize(output, dir, registry_generator)
+          @output = output
+          @dir = dir
+          @registry_generator = registry_generator
+        end
+
+        def write
+          if @output.module_namespace
+            write_namespaced
+          else
+            write_flat
+          end
+        end
+
+        private
+
+        def write_namespaced
+          module_path = @output.module_namespace.split("::").map(&:downcase).join("/")
+          full_dir = File.join(@dir, module_path)
+          FileUtils.mkdir_p(full_dir)
+
+          registry = @registry_generator.generate(
+            @output.models,
+            module_namespace: @output.module_namespace,
+            register_id: @output.register_id,
+            namespaces: @output.namespaces,
+          )
+          if registry
+            registry_name = module_path.split("/").last
+            File.write(File.join(@dir, "#{registry_name}_registry.rb"), registry)
+          end
+
+          write_sources_to(full_dir)
+        end
+
+        def write_flat
+          FileUtils.mkdir_p(@dir)
+          write_sources_to(@dir)
+        end
+
+        def write_sources_to(target_dir)
+          @output.sources.each { |name, src| write_source(target_dir, name, src) }
+        end
+
+        def write_source(target_dir, name, src)
+          file_name = Utils.snake_case(Utils.last_of_split(name.to_s))
+          File.write(File.join(target_dir, "#{file_name}.rb"), src)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/generator/definitions_collection.rb

@@ -19,9 +19,23 @@ module Lutaml
             def process_attributes(collection, klass)
               register = extract_register_from(klass)
               klass.attributes.each_value do |attribute|
-                next unless attribute.serializable?(register)
+                if attribute.union?
+                  process_union_members(collection, attribute)
+                elsif attribute.serializable?(register)
+                  process_attribute(collection, attribute, register)
+                end
+              end
+            end
+
+            # A union attribute's type is Type::Union, not a model, so collect
+            # definitions for each of its Serializable members directly (a
+            # union schema emits a $ref per model member).
+            def process_union_members(collection, attribute)
+              attribute.union_member_types.each do |member|
+                next unless member.is_a?(::Class) &&
+                  member.include?(Lutaml::Model::Serialize)
 
-                process_attribute(collection, attribute, register)
+                collection.merge(DefinitionsCollection.from_class(member))
               end
             end
 

data/lib/lutaml/model/schema/generator/property.rb

@@ -24,6 +24,8 @@ module Lutaml
             inside_collection = options.fetch(:inside_collection, false)
             if attr.collection? && !inside_collection
               collection_schema(attr)
+            elsif attr.union?
+              union_schema(attr, include_null: include_null)
             elsif attr.serializable?(register) && polymorphic?(attr)
               polymorphic_schema(attr)
             elsif attr.serializable?(register)
@@ -55,6 +57,22 @@ module Lutaml
             schema["maxItems"] = range.end if range.end
           end
 
+          # Union: anyOf (valid if the value matches at least one member), not
+          # oneOf (which would wrongly demand exactly one). A null branch is
+          # added for nullable attributes, mirroring primitive_schema, so an
+          # optional union still accepts null.
+          def union_schema(attr, include_null: true)
+            members = attr.union_member_types.map do |member|
+              if member.include?(Lutaml::Model::Serialize)
+                Ref.new(member).to_schema
+              else
+                { "type" => get_type(member) }
+              end
+            end
+            members << { "type" => "null" } if include_null
+            { "anyOf" => members }.merge(get_constraints(attr))
+          end
+
           def polymorphic_schema(attr)
             ref_schemas = attr.options[:polymorphic].map do |type|
               Ref.new(type).to_schema
@@ -82,10 +100,9 @@ module Lutaml
             constraints["pattern"] = attr.pattern.source if attr.pattern
 
             # Add default value
-            resolver = Lutaml::Model::Services::DefaultValueResolver.new(attr,
-                                                                         register, nil)
-            if resolver.default_set?
-              constraints["default"] = resolver.default
+            resolved = attr.default_value(register, nil)
+            unless Lutaml::Model::Utils.uninitialized?(resolved)
+              constraints["default"] = attr.cast_value(resolved, register)
             end
 
             # Add enumeration values

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      # Stateless helpers for emitting `module Foo ... end` wrappers around
+      # generated code, given an Array of module-name segments.
+      #
+      # Both helpers return a single newline-terminated block (no trailing
+      # newline) so ERB templates should use `<%= ... -%>` to avoid
+      # doubling the line break.
+      module ModuleNesting
+        module_function
+
+        def opening(modules)
+          return "" if modules.empty?
+
+          modules.map.with_index { |m, i| "#{'  ' * i}module #{m}\n" }.join
+        end
+
+        def closing(modules)
+          return "" if modules.empty?
+
+          modules.reverse.map.with_index do |_m, i|
+            "#{'  ' * (modules.size - i - 1)}end\n"
+          end.join
+        end
+      end
+    end
+  end
+end

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