lutaml-model 0.7.7 → 0.8.0

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

@@ -2,19 +2,8 @@
 
 require "erb"
 require "tmpdir"
-require "lutaml/xsd"
-require_relative "xml_compiler/complex_content_restriction"
-require_relative "xml_compiler/attribute_group"
-require_relative "xml_compiler/complex_content"
-require_relative "xml_compiler/simple_content"
-require_relative "xml_compiler/complex_type"
-require_relative "xml_compiler/restriction"
-require_relative "xml_compiler/simple_type"
-require_relative "xml_compiler/attribute"
-require_relative "xml_compiler/sequence"
-require_relative "xml_compiler/element"
-require_relative "xml_compiler/choice"
-require_relative "xml_compiler/group"
+
+# XSD schema compilation support - now integrated into lutaml-model
 
 module Lutaml
   module Model
@@ -22,12 +11,32 @@ module Lutaml
       module XmlCompiler
         extend self
 
+        # Autoload subdirectory classes
+        autoload :ComplexContentRestriction,
+                 "#{__dir__}/xml_compiler/complex_content_restriction"
+        autoload :AttributeGroup, "#{__dir__}/xml_compiler/attribute_group"
+        autoload :ComplexContent, "#{__dir__}/xml_compiler/complex_content"
+        autoload :SimpleContent, "#{__dir__}/xml_compiler/simple_content"
+        autoload :ComplexType, "#{__dir__}/xml_compiler/complex_type"
+        autoload :Restriction, "#{__dir__}/xml_compiler/restriction"
+        autoload :SimpleType, "#{__dir__}/xml_compiler/simple_type"
+        autoload :Attribute, "#{__dir__}/xml_compiler/attribute"
+        autoload :Sequence, "#{__dir__}/xml_compiler/sequence"
+        autoload :Element, "#{__dir__}/xml_compiler/element"
+        autoload :Choice, "#{__dir__}/xml_compiler/choice"
+        autoload :Group, "#{__dir__}/xml_compiler/group"
+        autoload :XmlNamespaceClass,
+                 "#{__dir__}/xml_compiler/xml_namespace_class"
+        autoload :RegistryGenerator,
+                 "#{__dir__}/xml_compiler/registry_generator"
+
         attr_reader :simple_types,
                     :group_types,
                     :complex_types,
                     :elements,
                     :attributes,
-                    :attribute_groups
+                    :attribute_groups,
+                    :namespace_classes
 
         ELEMENT_ORDER_IGNORABLE = %w[import include].freeze
 
@@ -35,27 +44,91 @@ module Lutaml
           Nokogiri is not set as XML Adapter.
           Make sure Nokogiri is installed and set as XML Adapter eg.
           execute: gem install nokogiri
-          require 'lutaml/model/adapter/nokogiri'
-          Lutaml::Model.xml_adapter = Lutaml::Model::Adapter::Nokogiri
+          require 'lutaml/xml'
+          Lutaml::Model::Config.xml_adapter = :nokogiri
         MSG
 
+        # NOTE: These must be full class names (strings), not symbols like :xml_id.
+        # The type resolver looks up these strings directly in the type registry,
+        # and symbols would be interpreted as literal type names rather than W3C types.
         XML_DEFINED_ATTRIBUTES = {
-          "id" => "id",
-          "lang" => "language",
-          "space" => "NCName",
-          "base" => "anyURI",
+          "id" => "Lutaml::Xml::W3c::XmlIdType",
+          "lang" => "Lutaml::Xml::W3c::XmlLangType",
+          "space" => "Lutaml::Xml::W3c::XmlSpaceType",
+          "base" => "Lutaml::Xml::W3c::XmlBaseType",
         }.freeze
+        XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace"
 
         def to_models(schema, options = {})
           as_models(schema, options: options)
           options[:indent] = options[:indent] ? options[:indent].to_i : 2
+
+          # Auto-generate module namespace from output directory if not explicitly set
+          unless options.key?(:module_namespace)
+            output_dir = options.fetch(:output_dir,
+                                       "lutaml_models_#{Time.now.to_i}")
+            # Generate a namespace from the directory name (e.g., "my_models" -> "MyModels")
+            dir_name = File.basename(output_dir).split("_").map(&:capitalize).join
+            options[:module_namespace] = dir_name
+          end
+
+          # Allow explicit nil to disable namespace
+          # only set default register_id if module_namespace is present
+          if options[:module_namespace]
+            options[:register_id] ||= :default
+          end
+
           @simple_types.merge!(XmlCompiler::SimpleType.setup_supported_types)
-          classes_list = @simple_types.merge(@complex_types).merge(@group_types)
-          classes_list = classes_list.transform_values { |type| type.to_class(options: options) }
+
+          # Generate namespace classes
+          namespace_classes_hash = {}
+          @namespace_classes.each do |name, ns_class|
+            namespace_classes_hash[name] = ns_class.to_class(options: options)
+          end
+
+          classes_list = namespace_classes_hash.merge(@simple_types).merge(@complex_types).merge(@group_types)
+          classes_list = classes_list.transform_values do |type|
+            # Skip namespace classes (already strings) and only process model types
+            next type if type.is_a?(String)
+
+            type.to_class(options: options.merge(
+              module_namespace: options[:module_namespace],
+              register_id: options[:register_id],
+            ))
+          end
           if options[:create_files]
             dir = options.fetch(:output_dir, "lutaml_models_#{Time.now.to_i}")
-            FileUtils.mkdir_p(dir)
-            classes_list.each { |name, klass| create_file(name, klass, dir) }
+
+            # If module_namespace provided, create subdirectories
+            if options[:module_namespace]
+              module_path = options[:module_namespace].split("::").map(&:downcase).join("/")
+              full_dir = File.join(dir, module_path)
+              FileUtils.mkdir_p(full_dir)
+
+              # Generate central registry file with autoload
+              registry_content = RegistryGenerator.generate(classes_list,
+                                                            options)
+              if registry_content
+                # Registry file goes in parent directory of module path
+                registry_name = module_path.split("/").last
+                registry_file = File.join(dir, "#{registry_name}_registry.rb")
+                File.write(registry_file, registry_content)
+              end
+
+              # Write class files
+              classes_list.each do |name, klass|
+                create_file(name, klass, full_dir)
+              end
+            else
+              # When no module_namespace, write files directly to output dir
+              # Generated files use require_relative for dependencies (traditional approach)
+              FileUtils.mkdir_p(dir)
+
+              # Write class files
+              classes_list.each do |name, klass|
+                create_file(name, klass, dir)
+              end
+            end
             true
           else
             require_classes(classes_list) if options[:load_classes]
@@ -70,16 +143,41 @@ module Lutaml
 
         def require_classes(classes_hash)
           Dir.mktmpdir do |dir|
-            classes_hash.each { |name, klass| create_file(name, klass, dir) }
-            # Some files are not created at the time of the require, so we need to require them after all the files are created.
-            classes_hash.each_key { |name| require "#{dir}/#{Utils.snake_case(name)}" }
+            # Create subdirectory for class files (matches autoload path in registry)
+            module_subdir = "generatedmodels"
+            full_dir = File.join(dir, module_subdir)
+            FileUtils.mkdir_p(full_dir)
+
+            # Generate registry file first with autoload
+            registry_content = RegistryGenerator.generate(classes_hash,
+                                                          module_namespace: "GeneratedModels",
+                                                          register_id: :default)
+            if registry_content
+              registry_file = File.join(dir, "registry.rb")
+              File.write(registry_file, registry_content)
+            end
+
+            # Write class files to subdirectory
+            classes_hash.each do |name, klass|
+              create_file(name, klass, full_dir)
+            end
+
+            # Require the registry first to set up autoloads
+            require "#{dir}/registry"
+
+            # Call register_all to register all classes
+            GeneratedModels.register_all if GeneratedModels.respond_to?(:register_all)
           end
         end
 
         def as_models(schema, options: {})
-          raise Error, XML_ADAPTER_NOT_SET_MESSAGE unless Config.xml_adapter.name.end_with?("NokogiriAdapter")
+          unless Config.xml_adapter.name.end_with?("NokogiriAdapter")
+            raise Error,
+                  XML_ADAPTER_NOT_SET_MESSAGE
+          end
 
-          parsed_schema = Xsd.parse(schema, location: options[:location])
+          parsed_schema = Lutaml::Xml::Schema::Xsd.parse(schema,
+                                                         location: options[:location])
 
           @elements = MappingHash.new
           @attributes = MappingHash.new
@@ -87,8 +185,10 @@ module Lutaml
           @simple_types = MappingHash.new
           @complex_types = MappingHash.new
           @attribute_groups = MappingHash.new
+          @namespace_classes = MappingHash.new
 
           populate_default_values
+          collect_namespaces(Array(parsed_schema), options)
           schema_to_models(Array(parsed_schema))
         end
 
@@ -97,6 +197,9 @@ module Lutaml
             @attributes[name] = Attribute.new(name: name)
             @attributes[name].type = value
           end
+
+          # W3C XmlNamespace is now auto-loaded via lutaml/model.rb
+          # Reference: Lutaml::Xml::W3c::XmlNamespace
         end
 
         def schema_to_models(schemas)
@@ -105,21 +208,26 @@ module Lutaml
           schemas.each do |schema|
             schema_to_models(schema.include) if schema.include&.any?
             schema_to_models(schema.import) if schema.import&.any?
-            resolved_element_order(schema).each do |order_item|
+            # Use schema's resolved_element_order which returns properly typed XSD objects
+            schema.resolved_element_order.each do |order_item|
               item_name = order_item.name if order_item.respond_to?(:name)
               case order_item
-              when Xsd::SimpleType
+              when Lutaml::Xml::Schema::Xsd::SimpleType
                 @simple_types[item_name] = setup_simple_type(order_item)
-              when Xsd::Group
-                @group_types[item_name] = setup_group_type(order_item, root_call: true)
-              when Xsd::ComplexType
+              when Lutaml::Xml::Schema::Xsd::Group
+                @group_types[item_name] =
+                  setup_group_type(order_item, root_call: true)
+              when Lutaml::Xml::Schema::Xsd::ComplexType
                 @complex_types[item_name] = setup_complex_type(order_item)
-              when Xsd::Element
+              when Lutaml::Xml::Schema::Xsd::Element
                 @elements[item_name] = setup_element(order_item)
-              when Xsd::Attribute
+              when Lutaml::Xml::Schema::Xsd::Attribute
+                next if xml_defined_attribute?(schema, item_name)
+
                 @attributes[item_name] = setup_attribute(order_item)
-              when Xsd::AttributeGroup
-                @attribute_groups[item_name] = setup_attribute_groups(order_item)
+              when Lutaml::Xml::Schema::Xsd::AttributeGroup
+                @attribute_groups[item_name] =
+                  setup_attribute_groups(order_item)
               end
             end
           end
@@ -140,17 +248,24 @@ module Lutaml
         def restriction_content(instance, restriction)
           return instance unless restriction.respond_to?(:max_length)
 
-          restriction_min_max(restriction, instance, field: :max_length, value_method: :min)
-          restriction_min_max(restriction, instance, field: :min_length, value_method: :max)
-          restriction_min_max(restriction, instance, field: :min_inclusive, value_method: :max)
-          restriction_min_max(restriction, instance, field: :max_inclusive, value_method: :min)
-          restriction_min_max(restriction, instance, field: :max_exclusive, value_method: :max)
-          restriction_min_max(restriction, instance, field: :min_exclusive, value_method: :min)
+          restriction_min_max(restriction, instance, field: :max_length,
+                                                     value_method: :min)
+          restriction_min_max(restriction, instance, field: :min_length,
+                                                     value_method: :max)
+          restriction_min_max(restriction, instance, field: :min_inclusive,
+                                                     value_method: :max)
+          restriction_min_max(restriction, instance, field: :max_inclusive,
+                                                     value_method: :min)
+          restriction_min_max(restriction, instance, field: :max_exclusive,
+                                                     value_method: :max)
+          restriction_min_max(restriction, instance, field: :min_exclusive,
+                                                     value_method: :min)
           instance.length = restriction_length(restriction.length) if restriction.length&.any?
         end
 
         # Use min/max to get the value from the field_value array.
-        def restriction_min_max(restriction, instance, field:, value_method: :min)
+        def restriction_min_max(restriction, instance, field:,
+  value_method: :min)
           field_value = restriction.public_send(field)
           return unless field_value&.any?
 
@@ -176,19 +291,20 @@ module Lutaml
             instance.mixed = complex_type.mixed
             resolved_element_order(complex_type).each do |element|
               case element
-              when Xsd::Attribute
+              when Lutaml::Xml::Schema::Xsd::Attribute
                 instance << setup_attribute(element)
-              when Xsd::Sequence
+              when Lutaml::Xml::Schema::Xsd::Sequence
                 instance << setup_sequence(element)
-              when Xsd::Choice
+              when Lutaml::Xml::Schema::Xsd::Choice
                 instance << setup_choice(element)
-              when Xsd::ComplexContent
-                instance << setup_complex_content(element, instance.name, instance)
-              when Xsd::AttributeGroup
+              when Lutaml::Xml::Schema::Xsd::ComplexContent
+                instance << setup_complex_content(element, instance.name,
+                                                  instance)
+              when Lutaml::Xml::Schema::Xsd::AttributeGroup
                 instance << setup_attribute_groups(element)
-              when Xsd::Group
+              when Lutaml::Xml::Schema::Xsd::Group
                 instance << setup_group_type(element)
-              when Xsd::SimpleContent
+              when Lutaml::Xml::Schema::Xsd::SimpleContent
                 instance.simple_content = setup_simple_content(element)
               end
             end
@@ -210,17 +326,17 @@ module Lutaml
         def setup_sequence(sequence)
           Sequence.new.tap do |instance|
             resolved_element_order(sequence).each do |object|
-              # No implementation yet for Xsd::Any!
-              next if object.is_a?(Xsd::Any)
+              # No implementation yet for Lutaml::Xml::Schema::Xsd::Any!
+              next if object.is_a?(Lutaml::Xml::Schema::Xsd::Any)
 
               instance << case object
-                          when Xsd::Sequence
+                          when Lutaml::Xml::Schema::Xsd::Sequence
                             setup_sequence(object)
-                          when Xsd::Element
+                          when Lutaml::Xml::Schema::Xsd::Element
                             setup_element(object)
-                          when Xsd::Choice
+                          when Lutaml::Xml::Schema::Xsd::Choice
                             setup_choice(object)
-                          when Xsd::Group
+                          when Lutaml::Xml::Schema::Xsd::Group
                             setup_group_type(object)
                           end
             end
@@ -248,13 +364,13 @@ module Lutaml
             instance.max_occurs = choice.max_occurs
             resolved_element_order(choice).each do |element|
               instance << case element
-                          when Xsd::Element
+                          when Lutaml::Xml::Schema::Xsd::Element
                             setup_element(element)
-                          when Xsd::Sequence
+                          when Lutaml::Xml::Schema::Xsd::Sequence
                             setup_sequence(element)
-                          when Xsd::Group
+                          when Lutaml::Xml::Schema::Xsd::Group
                             setup_group_type(element)
-                          when Xsd::Choice
+                          when Lutaml::Xml::Schema::Xsd::Choice
                             setup_choice(element)
                           end
             end
@@ -281,13 +397,14 @@ module Lutaml
         end
 
         def setup_attribute_groups(attribute_group)
-          instance = AttributeGroup.new(name: attribute_group.name, ref: attribute_group.ref)
+          instance = AttributeGroup.new(name: attribute_group.name,
+                                        ref: attribute_group.ref)
           if attribute_group.name
             resolved_element_order(attribute_group).each do |object|
               group_attribute = case object
-                                when Xsd::Attribute
+                                when Lutaml::Xml::Schema::Xsd::Attribute
                                   setup_attribute(object)
-                                when Xsd::AttributeGroup
+                                when Lutaml::Xml::Schema::Xsd::AttributeGroup
                                   setup_attribute_groups(object)
                                 end
               instance << group_attribute if group_attribute
@@ -314,17 +431,26 @@ module Lutaml
         def setup_element_type(element, _instance)
           return element.type if element.type
 
-          type, prefix = element.simple_type ? ["simple", "ST"] : ["complex", "CT"]
+          type, prefix = if element.simple_type
+                           ["simple",
+                            "ST"]
+                         else
+                           ["complex", "CT"]
+                         end
           type_instance = element.public_send(:"#{type}_type")
           type_instance.name = [prefix, element.name].join("_")
-          instance_variable_get(:"@#{type}_types")[type_instance.name] = public_send(:"setup_#{type}_type", type_instance)
+          instance_variable_get(:"@#{type}_types")[type_instance.name] =
+            public_send(:"setup_#{type}_type", type_instance)
           type_instance.name
         end
 
         def setup_restriction(restriction)
           Restriction.new.tap do |instance|
             instance.base_class = restriction.base
-            restriction_patterns(restriction.pattern, instance) if restriction.respond_to?(:pattern)
+            if restriction.respond_to?(:pattern)
+              restriction_patterns(restriction.pattern,
+                                   instance)
+            end
             restriction_content(instance, restriction)
             if restriction.respond_to?(:enumeration) && restriction.enumeration&.any?
               instance.enumerations = restriction.enumeration.map(&:value)
@@ -332,20 +458,26 @@ module Lutaml
           end
         end
 
-        def setup_complex_content_restriction(restriction, compiler_complex_type)
+        def setup_complex_content_restriction(restriction,
+  compiler_complex_type)
           ComplexContentRestriction.new.tap do |instance|
             compiler_complex_type.base_class = restriction.base
             resolved_element_order(restriction).each do |element|
+              # For restrictions, only add attributes and attribute groups.
+              # Sequence/choice/group elements are inherited from the base class
+              # and adding them here causes duplicate mappings.
+              next if element.is_a?(Lutaml::Xml::Schema::Xsd::Sequence) || element.is_a?(Lutaml::Xml::Schema::Xsd::Choice) || element.is_a?(Lutaml::Xml::Schema::Xsd::Group)
+
               instance << case element
-                          when Xsd::Attribute
+                          when Lutaml::Xml::Schema::Xsd::Attribute
                             setup_attribute(element)
-                          when Xsd::AttributeGroup
+                          when Lutaml::Xml::Schema::Xsd::AttributeGroup
                             setup_attribute_groups(element)
-                          when Xsd::Sequence
+                          when Lutaml::Xml::Schema::Xsd::Sequence
                             setup_sequence(element)
-                          when Xsd::Choice
+                          when Lutaml::Xml::Schema::Xsd::Choice
                             setup_choice(element)
-                          when Xsd::Group
+                          when Lutaml::Xml::Schema::Xsd::Group
                             setup_group_type(element)
                           end
             end
@@ -358,7 +490,8 @@ module Lutaml
           instance.pattern = patterns.map { |p| "(#{p.value})" }.join("|")
         end
 
-        def setup_complex_content(complex_content, name, compiler_complex_type)
+        def setup_complex_content(complex_content, name,
+compiler_complex_type)
           @complex_types[name] = ComplexContent.new.tap do |instance|
             compiler_complex_type.mixed = complex_content.mixed
             if extension = complex_content.extension
@@ -373,15 +506,15 @@ module Lutaml
           instance.base_class = extension.base
           resolved_element_order(extension).each do |element|
             instance << case element
-                        when Xsd::Attribute
+                        when Lutaml::Xml::Schema::Xsd::Attribute
                           setup_attribute(element)
-                        when Xsd::AttributeGroup
+                        when Lutaml::Xml::Schema::Xsd::AttributeGroup
                           setup_attribute_groups(element)
-                        when Xsd::Sequence
+                        when Lutaml::Xml::Schema::Xsd::Sequence
                           setup_sequence(element)
-                        when Xsd::Choice
+                        when Lutaml::Xml::Schema::Xsd::Choice
                           setup_choice(element)
-                        when Xsd::Group
+                        when Lutaml::Xml::Schema::Xsd::Group
                           setup_group_type(element)
                         end
           end
@@ -390,6 +523,13 @@ module Lutaml
         def resolved_element_order(object)
           return [] if object.element_order.nil?
 
+          # If the object has its own resolved_element_order method (like XSD objects),
+          # use it instead of processing element_order which returns generic XML elements
+          if object.respond_to?(:resolved_element_order) &&
+              object.class.name.start_with?("Lutaml::Xml::Schema::Xsd", "Lutaml::Xml::Schema::Xsd")
+            return object.resolved_element_order
+          end
+
           object.element_order.each_with_object(object.element_order.dup) do |builder_instance, array|
             next array.delete(builder_instance) if builder_instance.text? || ELEMENT_ORDER_IGNORABLE.include?(builder_instance.name)
 
@@ -397,10 +537,44 @@ module Lutaml
             array.each_with_index do |element, i|
               next unless element == builder_instance
 
-              array[i] = Array(object.send(Utils.snake_case(builder_instance.name)))[index]
+              array[i] =
+                Array(object.send(Utils.snake_case(builder_instance.name)))[index]
               index += 1
             end
           end
+
+          object.element_order
+        end
+
+        def collect_namespaces(schemas, options)
+          # Collect unique namespace URIs from the schemas
+          namespace_uris = Set.new
+
+          # Add the main namespace from options if provided
+          if options[:namespace]
+            namespace_uris.add(options[:namespace])
+          end
+
+          # Extract namespaces from schema elements
+          schemas.each do |schema|
+            namespace_uris.add(schema.target_namespace) if schema.target_namespace
+          end
+
+          # Create XmlNamespaceClass for each unique namespace
+          namespace_uris.each do |uri|
+            next if uri.nil? || uri.empty?
+
+            # Use provided prefix if available
+            prefix = options[:prefix] if options[:namespace] == uri
+
+            ns_class = XmlNamespaceClass.new(uri: uri, prefix: prefix)
+            @namespace_classes[ns_class.class_name] = ns_class
+          end
+        end
+
+        def xml_defined_attribute?(schema, item_name)
+          schema.target_namespace == XML_NAMESPACE_URI &&
+            XML_DEFINED_ATTRIBUTES.key?(item_name)
         end
       end
     end

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

@@ -1,57 +1,17 @@
-require_relative "base_schema"
-require "yaml"
+# frozen_string_literal: true
+
+# Backwards compatibility alias
+# YamlSchema has moved to Lutaml::Yaml::Schema::YamlSchema
+#
+# @deprecated Use Lutaml::Yaml::Schema::YamlSchema instead
+
+require_relative "../../yaml/schema/yaml_schema"
 
 module Lutaml
   module Model
     module Schema
-      class YamlSchema < BaseSchema
-        class << self
-          def generate(
-            klass,
-            id: nil,
-            title: nil,
-            description: nil,
-            pretty: false
-          )
-            options = {
-              schema: "https://json-schema.org/draft/2020-12/schema",
-              id: id,
-              title: title,
-              description: description,
-              pretty: pretty,
-            }
-
-            super(klass, options)
-          end
-
-          def format_schema(schema, options)
-            <<~SCHEMA
-              %YAML 1.1
-              #{options[:pretty] ? schema.to_yaml : YAML.dump(schema)}
-            SCHEMA
-          end
-
-          def generate_model_classes(schema)
-            definitions = definition_collection_class.new(schema["$defs"])
-
-            definitions.transform_values do |definition|
-              generate_model_class(definition)
-            end
-          end
-
-          private
-
-          def generate_model_class(schema)
-            template = File.join(__dir__, "templates", "model.erb")
-
-            Lutaml::Model::Schema::Renderer.render(template, schema: schema)
-          end
-
-          def definition_collection_class
-            Lutaml::Model::Schema::Decorators::DefinitionCollection
-          end
-        end
-      end
+      # For backwards compatibility, delegate to the new location
+      YamlSchema = ::Lutaml::Yaml::Schema::YamlSchema
     end
   end
 end