lutaml-model 0.8.17 → 0.8.18

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

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        class SpecBuilder
+          # Builds Definitions::RestrictedType / Definitions::UnionType
+          # specs from XSD <xs:simpleType> AST nodes, including the
+          # facet container that lives on the restricted type.
+          #
+          # Stateless. XSD built-in metadata comes from
+          # XmlCompiler::SupportedDataTypes; the back-reference to the
+          # parent SpecBuilder is kept for symmetry with other sub-builders.
+          class SimpleTypes
+            def initialize(parent)
+              @parent = parent
+            end
+
+            def build(simple_type)
+              if (union = simple_type.union)
+                build_union_type(simple_type.name, union.member_types.split)
+              else
+                build_restricted_type(simple_type.name, simple_type.restriction)
+              end
+            end
+
+            def build_supported(name, info)
+              base = Utils.base_class_snake_case(info[:class_name])
+              validations = info[:validations] || {}
+              facet = Definitions::Facet.new(
+                min_inclusive: validations[:min_inclusive],
+                max_inclusive: validations[:max_inclusive],
+                pattern: validations[:pattern],
+              )
+              transform = validations[:transform] &&
+                Definitions::TransformFacet.new(expression: validations[:transform])
+
+              Definitions::RestrictedType.new(
+                class_name: Utils.camel_case(name),
+                parent_class: restricted_parent_class(base),
+                facets: facet,
+                transform_facet: transform,
+                required_files: supported_required_files(base),
+                keep_register_when_namespaced: true,
+              )
+            end
+
+            private
+
+            def build_union_type(name, member_type_names)
+              type_refs = member_type_names.map do |raw|
+                snake = Utils.snake_case(Utils.last_of_split(raw))
+                Definitions::TypeRef.new(kind: :symbol, value: snake)
+              end
+              Definitions::UnionType.new(
+                class_name: Utils.camel_case(name),
+                members: type_refs,
+                cast_strategy: :resolve_type,
+                required_files: union_required_files(member_type_names),
+                lazy_register: true,
+                keep_register_when_namespaced: true,
+              )
+            end
+
+            def union_required_files(member_type_names)
+              member_type_names.filter_map do |raw|
+                local = Utils.last_of_split(raw)
+                next if skippable?(local)
+
+                %(require_relative "#{Utils.snake_case(local)}")
+              end
+            end
+
+            def build_restricted_type(name, restriction)
+              restriction_base = restriction&.base
+              base_class = restriction_base&.split(":")&.last
+              facet = restriction ? build_facet(restriction) : Definitions::Facet.new
+
+              Definitions::RestrictedType.new(
+                class_name: Utils.camel_case(name),
+                parent_class: restricted_parent_class(base_class),
+                facets: facet,
+                transform_facet: nil,
+                required_files: restricted_required_files(base_class),
+                keep_register_when_namespaced: true,
+              )
+            end
+
+            def restricted_parent_class(base_class)
+              type_info = SupportedDataTypes[base_class&.to_sym]
+              return type_info[:class_name] if type_info&.dig(:skippable)
+              return Utils.camel_case(base_class.to_s) if !type_info&.dig(:skippable) && Utils.present?(base_class)
+
+              "Lutaml::Model::Type::Value"
+            end
+
+            def restricted_required_files(base_class)
+              return [] if Utils.blank?(base_class)
+
+              return [%(require "bigdecimal")] if base_class == "decimal"
+              return [] if SupportedDataTypes.skippable?(base_class)
+
+              [%(require_relative "#{Utils.snake_case(base_class)}")]
+            end
+
+            def supported_required_files(base_class)
+              return [] if Utils.blank?(base_class) || SupportedDataTypes.skippable?(base_class)
+
+              [%(require_relative "#{Utils.snake_case(base_class)}")]
+            end
+
+            def skippable?(local)
+              SupportedDataTypes.skippable?(local)
+            end
+
+            # ----- Facets ---------------------------------------------------
+
+            def build_facet(restriction)
+              Definitions::Facet.new(
+                max_length: pick_minmax(restriction.max_length, :min),
+                min_length: pick_minmax(restriction.min_length, :max),
+                min_inclusive: pick_minmax(restriction.min_inclusive, :max),
+                max_inclusive: pick_minmax(restriction.max_inclusive, :min),
+                max_exclusive: pick_minmax(restriction.max_exclusive, :max),
+                min_exclusive: pick_minmax(restriction.min_exclusive, :min),
+                length: restriction.length&.any? ? restriction_length(restriction.length) : nil,
+                pattern: build_pattern(restriction.pattern),
+                enumerations: restriction.enumeration&.any? ? restriction.enumeration.map(&:value) : nil,
+              )
+            end
+
+            def pick_minmax(field_value, method)
+              return nil unless field_value&.any?
+
+              field_value.map(&:value).public_send(method).to_s
+            end
+
+            def restriction_length(lengths)
+              lengths.map { |l| { value: l.value, fixed: l.fixed } }
+            end
+
+            def build_pattern(patterns)
+              return nil if Utils.blank?(patterns)
+
+              patterns.map { |p| "(#{p.value})" }.join("|")
+            end
+          end
+        end
+      end
+    end
+  end
+end