lutaml-model 0.8.17 → 0.8.18

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      # Pure value object holding the output of compilation. No I/O — just
+      # data. FileWriter / ClassLoader collaborators consume this to perform
+      # the impure parts of `to_models`. Shared across schema compilers (RNG,
+      # XSD, future formats).
+      #
+      # Entries are an ordered list of tagged records, each carrying a
+      # CamelCase class name, a payload (either a Definitions::* spec or a
+      # pre-rendered Ruby source String), and a `kind` of `:model` or
+      # `:namespace`.
+      #
+      # `:model` entries are written to disk AND registered with
+      # `register_all`. `:namespace` entries are written and autoloaded but
+      # never registered.
+      class CompiledOutput
+        Entry = Struct.new(:name, :payload, :kind)
+
+        attr_reader :entries, :module_namespace, :register_id,
+                    :source_module_namespace
+
+        # `module_namespace` is what the central registry file wraps in
+        # (and where `register_all` lives). `source_module_namespace`
+        # is what the per-class files wrap in — defaults to the same,
+        # but ClassLoader can pass a different value when the caller
+        # asked for unwrapped classes but a registry constant is still
+        # needed to drive autoload.
+        def initialize(entries:, module_namespace: nil, register_id: :default,
+                       source_module_namespace: :inherit)
+          @entries = entries
+          @module_namespace = module_namespace
+          @register_id = register_id
+          @source_module_namespace =
+            source_module_namespace == :inherit ? module_namespace : source_module_namespace
+        end
+
+        # Model-only entries — what the registry generator and ClassLoader
+        # iterate when emitting `register_all` calls.
+        def models
+          @models ||= entries.select { |e| e.kind == :model }
+        end
+
+        # Namespace-only entries — autoloaded but never registered.
+        def namespaces
+          @namespaces ||= entries.select { |e| e.kind == :namespace }
+        end
+
+        # Flat `name => Ruby source` hash covering every entry (models +
+        # namespaces). Used by FileWriter for the per-file write loop and
+        # by RNG / XSD compilers as the public `to_models` return value.
+        # Class files are rendered against `source_module_namespace`,
+        # which usually equals `module_namespace` but differs when the
+        # caller wanted unwrapped class files inside a registry module.
+        def sources
+          @sources ||= entries.to_h { |e| [e.name, source_for(e)] }
+        end
+
+        private
+
+        def source_for(entry)
+          renderer_for(entry.payload).render(
+            entry.payload,
+            module_namespace: @source_module_namespace,
+            register_id: @register_id,
+          )
+        end
+
+        def renderer_for(spec)
+          case spec
+          when Definitions::Model          then Renderers::Model
+          when Definitions::RestrictedType then Renderers::RestrictedType
+          when Definitions::UnionType      then Renderers::Union
+          when Definitions::Namespace      then Renderers::Namespace
+          else raise ArgumentError, "Unknown spec type: #{spec.class}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Definitions
+        # One attribute on a generated class.
+        class Attribute
+          attr_accessor :name, :type, :xml_name, :kind, :collection,
+                        :default, :documentation, :initialize_empty,
+                        :render_default, :render_empty
+
+          def initialize(name:, type:, xml_name:, kind:,
+                         collection: false, default: nil,
+                         documentation: nil, initialize_empty: false,
+                         render_default: false, render_empty: false)
+            @name = name
+            @type = type
+            @xml_name = xml_name
+            @kind = kind
+            @collection = collection
+            @default = default
+            @documentation = documentation
+            @initialize_empty = initialize_empty
+            @render_default = render_default
+            @render_empty = render_empty
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Definitions
+        # A `choice do ... end` block. Alternatives may be Attribute,
+        # Sequence, or nested Choice specs.
+        class Choice
+          attr_accessor :alternatives, :header
+
+          def initialize(alternatives:, header:)
+            @alternatives = alternatives
+            @header = header
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Definitions
+        # Facet container for restricted simple types. Every field is
+        # optional; nil means "facet not present".
+        class Facet
+          attr_accessor :min_inclusive, :max_inclusive,
+                        :min_exclusive, :max_exclusive,
+                        :pattern, :enumerations,
+                        :min_length, :max_length, :length,
+                        :total_digits, :fraction_digits,
+                        :white_space
+
+          def initialize(min_inclusive: nil, max_inclusive: nil,
+                         min_exclusive: nil, max_exclusive: nil,
+                         pattern: nil, enumerations: nil,
+                         min_length: nil, max_length: nil, length: nil,
+                         total_digits: nil, fraction_digits: nil,
+                         white_space: nil)
+            @min_inclusive = min_inclusive
+            @max_inclusive = max_inclusive
+            @min_exclusive = min_exclusive
+            @max_exclusive = max_exclusive
+            @pattern = pattern
+            @enumerations = enumerations
+            @min_length = min_length
+            @max_length = max_length
+            @length = length
+            @total_digits = total_digits
+            @fraction_digits = fraction_digits
+            @white_space = white_space
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Definitions
+        # An inline `<xs:group ref="..."/>` reference appearing as a
+        # member inside a Choice / Sequence / Model. Renders as
+        # `import_model_attributes :name` in the attribute-decl block
+        # and `import_model_mappings :name` in the xml-mapping block.
+        # name is the snake_case symbol form (without leading colon).
+        class GroupImport
+          attr_accessor :name
+
+          def initialize(name:)
+            @name = name
+          end
+        end
+      end
+    end
+  end
+end

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