lutaml-model 0.8.17 → 0.8.18

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

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        # Walks parsed XSD AST objects and emits Definitions::* specs.
+        # Holds the in-progress class hashes that ref resolution looks
+        # up by name. Stateful by design (refs and forward references
+        # demand it); kept out of XmlCompiler.rb so the orchestrator
+        # stays focused on parse/dispatch.
+        class SpecBuilder
+          autoload :SimpleTypes,  "#{__dir__}/spec_builder/simple_types"
+          autoload :Members,      "#{__dir__}/spec_builder/members"
+          autoload :ComplexTypes, "#{__dir__}/spec_builder/complex_types"
+
+          attr_reader :simple_types, :complex_types, :group_types,
+                      :elements, :attributes, :attribute_groups,
+                      :namespace_classes, :namespace_class_name,
+                      :members_builder
+
+          def initialize
+            @simple_types = MappingHash.new
+            @complex_types = MappingHash.new
+            @group_types = MappingHash.new
+            @elements = MappingHash.new
+            @attributes = MappingHash.new
+            @attribute_groups = MappingHash.new
+            @namespace_classes = MappingHash.new
+            @simple_types_builder  = SimpleTypes.new(self)
+            @members_builder       = Members.new(self)
+            @complex_types_builder = ComplexTypes.new(self)
+          end
+
+          def populate_default_attributes
+            XmlCompiler::XML_DEFINED_ATTRIBUTES.each do |name, w3c_class|
+              @attributes[name] = Definitions::Attribute.new(
+                name: Utils.snake_case(name),
+                type: Definitions::TypeRef.new(kind: :w3c, value: w3c_class),
+                xml_name: name,
+                kind: :attribute,
+              )
+            end
+          end
+
+          def collect_namespaces(schemas, options)
+            requested_uri = options[:namespace]
+            uris = []
+            uris << requested_uri if requested_uri
+            schemas.each do |schema|
+              uris << schema.target_namespace if schema.target_namespace
+            end
+            uris.uniq.each do |uri|
+              next if uri.nil? || uri.empty?
+
+              prefix = options[:prefix] if requested_uri == uri
+              ns = Definitions::Namespace.new(
+                class_name: NamespaceNaming.class_name_for(uri),
+                uri: uri,
+                prefix_default: prefix || NamespaceNaming.prefix_for(uri),
+              )
+              @namespace_classes[ns.class_name] = ns
+            end
+            # Resolve the namespace_class_name once. When the caller
+            # passed :namespace, every generated complex type gets this
+            # name. Mirrors XmlCompiler::ComplexType#setup_options on main.
+            @namespace_class_name =
+              requested_uri && @namespace_classes.values.find { |ns| ns.uri == requested_uri }&.class_name
+          end
+
+          def walk_schemas(schemas)
+            return if schemas.empty?
+
+            # Two-pass walk: register top-level Elements / Attributes /
+            # AttributeGroups / SimpleTypes first so forward references
+            # from ComplexTypes / Groups resolve in pass 2.
+            collect_lookups(schemas)
+            build_complex_types(schemas)
+          end
+
+          def collect_lookups(schemas)
+            each_schema_item(schemas) { |item, schema| dispatch_lookup(item, schema) }
+          end
+
+          def build_complex_types(schemas)
+            each_schema_item(schemas) { |item, schema| dispatch_complex(item, schema) }
+          end
+
+          def dispatch_lookup(item, schema)
+            case item
+            when Lutaml::Xml::Schema::Xsd::SimpleType
+              @simple_types[item.name] = build_simple_type(item)
+            when Lutaml::Xml::Schema::Xsd::Element
+              @elements[item.name] = @members_builder.build_top_level_attribute(item, kind: :element)
+            when Lutaml::Xml::Schema::Xsd::Attribute
+              return if xml_defined_attribute?(schema, item.name)
+
+              @attributes[item.name] = @members_builder.build_top_level_attribute(item, kind: :attribute)
+            when Lutaml::Xml::Schema::Xsd::AttributeGroup
+              @attribute_groups[item.name] = @complex_types_builder.build_attribute_group(item)
+            end
+          end
+
+          def dispatch_complex(item, _schema)
+            case item
+            when Lutaml::Xml::Schema::Xsd::ComplexType
+              @complex_types[item.name] = @complex_types_builder.build(item)
+            when Lutaml::Xml::Schema::Xsd::Group
+              @group_types[item.name] = @complex_types_builder.build_group(item)
+            end
+          end
+
+          # Add the built-in XSD types (NonNegativeInteger, NormalizedString,
+          # etc.) as Definitions::RestrictedType entries.
+          def add_supported_types
+            SupportedDataTypes.each do |name, info|
+              next if info[:skippable]
+
+              str_name = name.to_s
+              @simple_types[str_name] = @simple_types_builder.build_supported(str_name, info)
+            end
+          end
+
+          # Every generated class spec keyed by name. Used by the orchestrator
+          # to build CompiledOutput entries without reaching into the builder's
+          # internal hashes.
+          def all_models
+            @simple_types.merge(@complex_types).merge(@group_types)
+          end
+
+          # Stamp `required_files` on every walked complex / group model.
+          # The skippable predicate is supplied by SupportedDataTypes —
+          # the orchestrator never has to thread the type table through.
+          def finalize_required_files!
+            (@complex_types.each_value.to_a + @group_types.each_value.to_a).each do |model|
+              model.required_files = Renderers::RequiredFilesCalculator
+                .for_xml(model, skippable_type: SupportedDataTypes.method(:skippable?))
+            end
+          end
+
+          # Public surface used by the Members sub-builder to register
+          # nested anonymous types it encounters during attribute /
+          # element resolution.
+          def build_simple_type(simple_type) = @simple_types_builder.build(simple_type)
+          def build_complex_type(complex_type) = @complex_types_builder.build(complex_type)
+
+          private
+
+          # Recursively walks `schemas` (following include / import) and
+          # yields each resolved element-order item with its owning schema.
+          def each_schema_item(schemas, &dispatch)
+            schemas.each do |schema|
+              each_schema_item(schema.include, &dispatch) if schema.include&.any?
+              each_schema_item(schema.import, &dispatch)  if schema.import&.any?
+              schema.resolved_element_order.each { |item| yield(item, schema) }
+            end
+          end
+
+          def xml_defined_attribute?(schema, name)
+            schema.target_namespace == XmlCompiler::XML_NAMESPACE_URI &&
+              XmlCompiler::XML_DEFINED_ATTRIBUTES.key?(name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        # XSD built-in type table. Keys are the XSD type names; values
+        # describe how to render the generated subclass.
+        # `skippable: true` means the XSD type maps directly to a
+        # Lutaml primitive symbol and needs no generated class.
+        module SupportedDataTypes
+          TC = Lutaml::Model::Type::TYPE_CODES
+
+          TABLE = {
+            nonNegativeInteger: { skippable: false, class_name: TC[:string],
+                                  validations: { pattern: /\+?[0-9]+/ } },
+            normalizedString: { skippable: false, class_name: TC[:string],
+                                validations: { transform: "value.gsub(/[\\r\\n\\t]/, ' ')" } },
+            positiveInteger: { skippable: false, class_name: TC[:integer],
+                               validations: { min_inclusive: 0 } },
+            unsignedShort: { skippable: false, class_name: TC[:integer],
+                             validations: { min_inclusive: 0, max_inclusive: 65535 } },
+            base64Binary: { skippable: false, class_name: TC[:string],
+                            validations: { pattern: /\A([A-Za-z0-9+\/]+={0,2}|\s)*\z/ } },
+            unsignedLong: { skippable: false, class_name: TC[:integer],
+                            validations: { min_inclusive: 0, max_inclusive: 18446744073709551615 } },
+            unsignedByte: { skippable: false, class_name: TC[:integer],
+                            validations: { min_inclusive: 0, max_inclusive: 255 } },
+            unsignedInt: { skippable: false, class_name: TC[:integer],
+                           validations: { min_inclusive: 0, max_inclusive: 4294967295 } },
+            hexBinary: { skippable: false, class_name: TC[:string],
+                         validations: { pattern: /([0-9a-fA-F]{2})*/ } },
+            language: { skippable: false, class_name: TC[:string],
+                        validations: { pattern: /\A[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*\z/ } },
+            dateTime: { skippable: true, class_name: TC[:date_time] },
+            boolean: { skippable: true, class_name: TC[:boolean] },
+            integer: { skippable: true, class_name: TC[:integer] },
+            decimal: { skippable: true, class_name: TC[:decimal] },
+            string: { skippable: true, class_name: TC[:string] },
+            double: { skippable: true, class_name: TC[:float] },
+            NCName: { skippable: false, class_name: TC[:string],
+                      validations: { pattern: /\A[a-zA-Z_][\w.-]*\z/ } },
+            anyURI: { skippable: false, class_name: TC[:string],
+                      validations: { pattern: "\\A\#{URI::DEFAULT_PARSER.make_regexp(%w[http https ftp])}\\z" } },
+            token: { skippable: false, class_name: TC[:string],
+                     validations: { pattern: /\A[^\t\n\f\r ]+(?: [^\t\n\f\r ]+)*\z/ } },
+            byte: { skippable: false, class_name: TC[:integer],
+                    validations: { min_inclusive: -128, max_inclusive: 127 } },
+            long: { skippable: false, class_name: TC[:decimal] },
+            int: { skippable: true, class_name: TC[:integer] },
+            id: { skippable: false, class_name: TC[:string],
+                  validations: { pattern: /\A[a-zA-Z_][\w.-]*\z/ } },
+          }.freeze
+
+          module_function
+
+          # XSD-name lookup (`SupportedDataTypes[:dateTime]`).
+          def [](name)
+            TABLE[name]
+          end
+
+          def each(&)
+            TABLE.each(&)
+          end
+
+          # `TypeRef.value` and `simple_content.base_class` ask the same
+          # "is this a built-in primitive?" question but pass two different
+          # spellings: `simple_content` keeps the XSD name (`"dateTime"`),
+          # while attribute TypeRefs store the snake_case rendering
+          # (`"date_time"`). Precompute both spellings so neither caller
+          # has to know which form the other uses.
+          SKIPPABLE_NAMES = TABLE
+            .select { |_, info| info[:skippable] }
+            .flat_map { |name, _| [name.to_s, Utils.snake_case(name.to_s)] }
+            .uniq.freeze
+
+          # True when the XSD type maps to a Lutaml primitive symbol that
+          # doesn't need a generated subclass. Accepts XSD-spelled
+          # (`"dateTime"`) or snake_case (`"date_time"`) input.
+          def skippable?(value)
+            SKIPPABLE_NAMES.include?(value.to_s)
+          end
+        end
+      end
+    end
+  end
+end