lutaml-model 0.8.17 → 0.8.19

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

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

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

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

data/lib/lutaml/model/schema/xml_compiler/spec_builder/complex_types.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        class SpecBuilder
+          # Builds Definitions::Model specs for XSD <complexType>, named
+          # <group>, and <attributeGroup> nodes, plus the SimpleContent
+          # sidecar.
+          #
+          # Reads from the parent SpecBuilder:
+          #   - @parent.attribute_groups for ref resolution
+          #   - @parent.group_types as the destination for anonymous
+          #     named groups discovered while walking complexType bodies
+          #   - @parent.namespace_class_name to stamp on built Models
+          # Delegates leaf-member building (attribute/element/sequence/
+          # choice) back to @parent.members for shared resolution rules.
+          class ComplexTypes
+            def initialize(parent)
+              @parent = parent
+            end
+
+            # <xs:complexType> -> Definitions::Model.
+            def build(complex_type)
+              model = Definitions::Model.new(
+                class_name: Utils.camel_case(complex_type.name),
+                xml_root: Definitions::XmlRoot.new(kind: :element, name: complex_type.name),
+                mixed: !!complex_type.mixed,
+                namespace_class_name: @parent.namespace_class_name,
+              )
+
+              ElementOrder.resolved(complex_type).each do |element|
+                add_child(model, element)
+              end
+              model
+            end
+
+            # <xs:group> at top level -> Definitions::Model with
+            # module_wrappable: false. Used by both the registry walker
+            # and by `add_group_to_model` when it discovers a named-but-
+            # not-yet-registered anonymous group.
+            def build_group(group)
+              inner_members = []
+              if (built = build_group_inner(group))
+                inner_members << built
+              end
+
+              base_name = group.name || Utils.last_of_split(group.ref)
+              Definitions::Model.new(
+                class_name: Utils.camel_case(base_name),
+                xml_root: Definitions::XmlRoot.new(kind: :type_name, name: base_name),
+                members: inner_members,
+                module_wrappable: false,
+                lazy_register: true,
+              )
+            end
+
+            # <xs:attributeGroup> -> Array of Definitions::Attribute. Top
+            # level groups are registered for ref resolution; inline ones
+            # are flattened directly into a Model's members.
+            def build_attribute_group(attribute_group)
+              ref = attribute_group.ref
+              if ref && !attribute_group.name
+                target = @parent.attribute_groups[Utils.last_of_split(ref)]
+                return Array(target)
+              end
+
+              collect_attributes(attribute_group)
+            end
+
+            # <xs:simpleContent> -> Definitions::SimpleContent sidecar.
+            def build_simple_content(simple_content)
+              additional = []
+              base_class = nil
+              if simple_content.extension
+                ext = simple_content.extension
+                base_class = ext.base
+                additional = collect_attributes(ext)
+              elsif simple_content.restriction
+                base_class = simple_content.restriction.base
+              end
+
+              Definitions::SimpleContent.new(
+                base_class: base_class,
+                additional_attributes: additional,
+              )
+            end
+
+            private
+
+            # Flattens the <attribute> / <attributeGroup> children of
+            # `container` into an array of Definitions::Attribute.
+            def collect_attributes(container)
+              members = []
+              ElementOrder.resolved(container).each do |item|
+                case item
+                when Lutaml::Xml::Schema::Xsd::Attribute
+                  attr = @parent.members_builder.build_attribute(item)
+                  members << attr if attr
+                when Lutaml::Xml::Schema::Xsd::AttributeGroup
+                  members.concat(build_attribute_group(item))
+                end
+              end
+              members
+            end
+
+            def add_child(model, element)
+              case element
+              when Lutaml::Xml::Schema::Xsd::Attribute
+                attr = @parent.members_builder.build_attribute(element)
+                model.members << attr if attr
+              when Lutaml::Xml::Schema::Xsd::Sequence
+                model.members << @parent.members_builder.build_sequence(element)
+              when Lutaml::Xml::Schema::Xsd::Choice
+                model.members << @parent.members_builder.build_choice(element)
+              when Lutaml::Xml::Schema::Xsd::ComplexContent
+                apply_complex_content(element, model)
+              when Lutaml::Xml::Schema::Xsd::AttributeGroup
+                model.members.concat(build_attribute_group(element))
+              when Lutaml::Xml::Schema::Xsd::Group
+                add_group_to_model(element, model)
+              when Lutaml::Xml::Schema::Xsd::SimpleContent
+                model.simple_content = build_simple_content(element)
+              end
+            end
+
+            def apply_complex_content(content, model)
+              model.mixed = true if content.mixed
+
+              if (ext = content.extension)
+                model.parent_class = qualified_class(ext.base)
+                ElementOrder.resolved(ext).each { |c| add_child(model, c) }
+              elsif (res = content.restriction)
+                model.parent_class = qualified_class(res.base)
+                ElementOrder.resolved(res).each do |c|
+                  # XSD: restrictions on complex content inherit
+                  # sequence/choice/group from base.
+                  next if c.is_a?(Lutaml::Xml::Schema::Xsd::Sequence) ||
+                    c.is_a?(Lutaml::Xml::Schema::Xsd::Choice) ||
+                    c.is_a?(Lutaml::Xml::Schema::Xsd::Group)
+
+                  add_child(model, c)
+                end
+              end
+            end
+
+            def qualified_class(raw)
+              return "Lutaml::Model::Serializable" if raw.nil?
+
+              Utils.camel_case(Utils.last_of_split(raw))
+            end
+
+            def add_group_to_model(group, model)
+              # Anonymous group OR named-but-not-referenced group: unwrap
+              # the inner sequence/choice inline into the model. (Matches
+              # the old XmlCompiler::Group rendering, which only emitted
+              # import_model_attributes/mappings when `ref` was set.)
+              if group.ref.nil?
+                add_anonymous_group_contents(group, model)
+                if group.name && !@parent.group_types.key?(group.name)
+                  @parent.group_types[group.name] = build_group(group)
+                end
+                return
+              end
+
+              model.members << Definitions::GroupImport.new(
+                name: Utils.snake_case(Utils.last_of_split(group.ref)),
+              )
+            end
+
+            def add_anonymous_group_contents(group, model)
+              built = build_group_inner(group)
+              model.members << built if built
+            end
+
+            def build_group_inner(group)
+              inner = group.sequence || group.choice
+              return nil unless inner
+
+              case inner
+              when Lutaml::Xml::Schema::Xsd::Sequence then @parent.members_builder.build_sequence(inner)
+              when Lutaml::Xml::Schema::Xsd::Choice   then @parent.members_builder.build_choice(inner)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/xml_compiler/spec_builder/members.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        class SpecBuilder
+          # Builds the leaf member specs that live inside generated
+          # classes: Attribute / Element (both surface as
+          # Definitions::Attribute with different `kind:` values),
+          # Sequence, Choice, GroupImport, plus the TypeRef wrapper.
+          #
+          # Holds @parent (SpecBuilder) so it can:
+          #   - look up @parent.attributes / @parent.elements for refs
+          #   - write anonymous simple/complex types into @parent's hashes
+          #   - delegate complex-type building back to @parent for nested
+          #     anonymous types
+          class Members
+            def initialize(parent)
+              @parent = parent
+            end
+
+            # ----- Attributes ------------------------------------------------
+
+            def build_attribute(attr)
+              return resolve_attribute_ref(attr) if attr.ref && !attr.name
+
+              Definitions::Attribute.new(
+                name: Utils.snake_case(attr.name),
+                type: build_type_ref(resolve_attribute_type(attr)),
+                xml_name: attr.name,
+                kind: :attribute,
+                default: attr.default,
+              )
+            end
+
+            def build_top_level_attribute(item, kind:)
+              return item unless item.respond_to?(:name)
+
+              type_str = top_level_type_str(item)
+              Definitions::Attribute.new(
+                name: Utils.snake_case(item.name.to_s),
+                type: build_type_ref(type_str || "string"),
+                xml_name: item.name.to_s,
+                kind: kind,
+              )
+            end
+
+            # ----- Elements --------------------------------------------------
+
+            def build_element(element)
+              return resolve_element_ref(element) if element.ref && !element.name
+
+              Definitions::Attribute.new(
+                name: Utils.snake_case(element.name),
+                type: build_type_ref(resolve_element_type(element)),
+                xml_name: element.name,
+                kind: :element,
+                collection: collection_from_occurs(element.min_occurs, element.max_occurs),
+                default: element.default,
+                render_default: !element.default.nil?,
+                render_empty: element_required?(element.min_occurs),
+              )
+            end
+
+            # ----- Sequence / Choice -----------------------------------------
+
+            def build_sequence(sequence)
+              members = ElementOrder.resolved(sequence).filter_map do |item|
+                next if item.is_a?(Lutaml::Xml::Schema::Xsd::Any)
+
+                build_member(item)
+              end
+              Definitions::Sequence.new(members: members)
+            end
+
+            def build_choice(choice)
+              alternatives = ElementOrder.resolved(choice).filter_map { |item| build_member(item) }
+              Definitions::Choice.new(
+                alternatives: alternatives,
+                header: choice_header(choice),
+              )
+            end
+
+            # A `<xs:group ref="..."/>` appearing inside a sequence/choice
+            # becomes an inline import directive. Anonymous in-place groups
+            # (no name, no ref) are flattened by the complex-type walker
+            # before they reach this method.
+            def build_group_member(group)
+              return nil if group.ref.nil?
+
+              Definitions::GroupImport.new(
+                name: Utils.snake_case(Utils.last_of_split(group.ref)),
+              )
+            end
+
+            # ----- TypeRef ---------------------------------------------------
+
+            def build_type_ref(raw_type)
+              return Definitions::TypeRef.new(kind: :symbol, value: "string") if raw_type.nil?
+              return Definitions::TypeRef.new(kind: :w3c, value: raw_type) if w3c_type?(raw_type)
+
+              local = Utils.last_of_split(raw_type)
+              Definitions::TypeRef.new(kind: :symbol, value: Utils.snake_case(local))
+            end
+
+            private
+
+            def build_member(item)
+              case item
+              when Lutaml::Xml::Schema::Xsd::Sequence then build_sequence(item)
+              when Lutaml::Xml::Schema::Xsd::Element  then build_element(item)
+              when Lutaml::Xml::Schema::Xsd::Choice   then build_choice(item)
+              when Lutaml::Xml::Schema::Xsd::Group    then build_group_member(item)
+              end
+            end
+
+            def resolve_attribute_ref(attr)
+              target = @parent.attributes[Utils.last_of_split(attr.ref)]
+              return nil unless target
+
+              Definitions::Attribute.new(
+                name: target.name,
+                type: target.type,
+                xml_name: target.xml_name,
+                kind: :attribute,
+                default: target.default,
+              )
+            end
+
+            def resolve_attribute_type(attr)
+              return attr.type if attr.type
+
+              register_anonymous_simple_type("ST_#{attr.name}", attr.simple_type)
+            end
+
+            def resolve_element_ref(element)
+              target = @parent.elements[Utils.last_of_split(element.ref)]
+              return nil unless target
+
+              Definitions::Attribute.new(
+                name: target.name,
+                type: target.type,
+                xml_name: target.xml_name,
+                kind: :element,
+                collection: collection_from_occurs(element.min_occurs, element.max_occurs),
+                default: target.default,
+                render_default: !target.default.nil?,
+                render_empty: element_required?(element.min_occurs),
+              )
+            end
+
+            def resolve_element_type(element)
+              return element.type if element.type
+              return register_anonymous_simple_type("ST_#{element.name}", element.simple_type) if element.simple_type
+              return register_anonymous_complex_type("CT_#{element.name}", element.complex_type) if element.complex_type
+
+              "string"
+            end
+
+            def top_level_type_str(item)
+              return item.type if item.respond_to?(:type) && item.type
+              return register_anonymous_simple_type("ST_#{item.name}", item.simple_type) if item.respond_to?(:simple_type) && item.simple_type
+
+              register_anonymous_complex_type("CT_#{item.name}", item.complex_type) if item.respond_to?(:complex_type) && item.complex_type
+            end
+
+            def register_anonymous_simple_type(anon_name, anon_node)
+              anon_node.name = anon_name
+              @parent.simple_types[anon_name] = @parent.build_simple_type(anon_node)
+              anon_name
+            end
+
+            def register_anonymous_complex_type(anon_name, anon_node)
+              anon_node.name = anon_name
+              @parent.complex_types[anon_name] = @parent.build_complex_type(anon_node)
+              anon_name
+            end
+
+            def collection_from_occurs(min_occurs, max_occurs)
+              return false if min_occurs.nil? && max_occurs.nil?
+
+              min = min_occurs.nil? ? 1 : min_occurs.to_i
+              max = case max_occurs
+                    when "unbounded" then Float::INFINITY
+                    when NilClass    then 1
+                    else max_occurs.to_i
+                    end
+              return false if min == 1 && max == 1
+
+              (min..max)
+            end
+
+            def element_required?(min_occurs)
+              min_occurs.nil? || min_occurs.to_i >= 1
+            end
+
+            def choice_header(choice)
+              min = choice.min_occurs.nil? ? 1 : choice.min_occurs.to_i
+              max = case choice.max_occurs
+                    when "unbounded" then "Float::INFINITY"
+                    when NilClass    then 1
+                    else choice.max_occurs.to_i
+                    end
+              "choice(min: #{min}, max: #{max})"
+            end
+
+            def w3c_type?(raw_type)
+              raw_type.to_s.start_with?("Lutaml::Xml::W3c::")
+            end
+          end
+        end
+      end
+    end
+  end
+end