lutaml-model 0.7.3 → 0.7.5

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

@@ -4,40 +4,44 @@ module Lutaml
   module Model
     module Schema
       class XsdSchema
+        extend SharedMethods
+
         def self.generate(klass, options = {})
+          register = extract_register_from(klass)
           builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
             xml.schema(xmlns: "http://www.w3.org/2001/XMLSchema") do
-              generate_complex_type(xml, klass)
+              generate_complex_type(xml, klass, nil, register)
             end
           end
 
           options[:pretty] ? builder.to_xml(indent: 2) : builder.to_xml
         end
 
-        def self.generate_complex_type(xml, klass, element_name = nil)
+        def self.generate_complex_type(xml, klass, element_name = nil, register)
           xml.element(name: element_name || klass.name) do
             xml.complexType do
               xml.sequence do
-                generate_elements(xml, klass)
+                generate_elements(xml, klass, register)
               end
             end
           end
         end
 
-        def self.generate_elements(xml, klass)
+        def self.generate_elements(xml, klass, register)
           klass.attributes.each do |name, attr|
-            if attr.type <= Lutaml::Model::Serialize
-              generate_complex_type(xml, attr.type, name)
+            attr_type = attr.type(register)
+            if attr_type <= Lutaml::Model::Serialize
+              generate_complex_type(xml, attr_type, name, register)
             elsif attr.collection?
               xml.element(name: name, minOccurs: "0", maxOccurs: "unbounded") do
                 xml.complexType do
                   xml.sequence do
-                    xml.element(name: "item", type: get_xsd_type(attr.type))
+                    xml.element(name: "item", type: get_xsd_type(attr_type))
                   end
                 end
               end
             else
-              xml.element(name: name, type: get_xsd_type(attr.type))
+              xml.element(name: name, type: get_xsd_type(attr_type))
             end
           end
         end

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

@@ -1,49 +1,55 @@
+require_relative "base_schema"
 require "yaml"
 
 module Lutaml
   module Model
     module Schema
-      class YamlSchema
-        def self.generate(klass, options = {})
-          schema = generate_schema(klass)
-          options[:pretty] ? schema.to_yaml : YAML.dump(schema)
-        end
+      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,
+            }
 
-        def self.generate_schema(klass)
-          {
-            "type" => "map",
-            "mapping" => generate_mapping(klass),
-          }
-        end
+            super(klass, options)
+          end
 
-        def self.generate_mapping(klass)
-          klass.attributes.each_with_object({}) do |(name, attr), mapping|
-            mapping[name.to_s] = generate_attribute_schema(attr)
+          def format_schema(schema, options)
+            <<~SCHEMA
+              %YAML 1.1
+              #{options[:pretty] ? schema.to_yaml : YAML.dump(schema)}
+            SCHEMA
           end
-        end
 
-        def self.generate_attribute_schema(attr)
-          if attr.type <= Lutaml::Model::Serialize
-            generate_schema(attr.type)
-          elsif attr.collection?
-            {
-              "type" => "seq",
-              "sequence" => [{ "type" => get_yaml_type(attr.type) }],
-            }
-          else
-            { "type" => get_yaml_type(attr.type) }
+          def generate_model_classes(schema)
+            definitions = definition_collection_class.new(schema["$defs"])
+
+            definitions.transform_values do |definition|
+              generate_model_class(definition)
+            end
           end
-        end
 
-        def self.get_yaml_type(type)
-          {
-            Lutaml::Model::Type::String => "str",
-            Lutaml::Model::Type::Integer => "int",
-            Lutaml::Model::Type::Boolean => "bool",
-            Lutaml::Model::Type::Float => "float",
-            Lutaml::Model::Type::Decimal => "float",
-            Lutaml::Model::Type::Hash => "map",
-          }[type] || "str" # Default to string for unknown types
+          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
     end

data/lib/lutaml/model/schema.rb

@@ -1,3 +1,4 @@
+require_relative "schema/shared_methods"
 require_relative "schema/json_schema"
 require_relative "schema/xsd_schema"
 require_relative "schema/relaxng_schema"

data/lib/lutaml/model/sequence.rb

@@ -18,30 +18,16 @@ module Lutaml
         instance_eval(&block)
       end
 
-      def map_element(
-        name,
-        to: nil,
-        render_nil: false,
-        render_default: false,
-        with: {},
-        delegate: nil,
-        cdata: false,
-        namespace: nil,
-        prefix: nil,
-        transform: {}
-      )
-        @attributes << @model.map_element(
-          name,
-          to: to,
-          render_nil: render_nil,
-          render_default: render_default,
-          with: with,
-          delegate: delegate,
-          cdata: cdata,
-          namespace: namespace,
-          prefix: prefix,
-          transform: transform,
-        )
+      def map_element(name, **kwargs)
+        @attributes << @model.map_element(name, **kwargs)
+      end
+
+      def import_model_mappings(model)
+        return import_mappings_later(model) if later_importable?(model)
+        raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?
+
+        @model.import_model_mappings(model)
+        @attributes.concat(Utils.deep_dup(model.mappings_for(:xml).elements))
       end
 
       def map_attribute(*)
@@ -56,16 +42,60 @@ module Lutaml
         raise Lutaml::Model::UnknownSequenceMappingError.new("map_all")
       end
 
-      def validate_content!(element_order)
-        defined_order = @attributes.map { |rule| rule.name.to_s }
-        start_index = element_order.index(defined_order.first)
+      def validate_content!(element_order, model_class)
+        validate_sequence!(
+          extract_defined_order(model_class.attributes),
+          element_order,
+        )
+      end
 
-        defined_order.each.with_index(start_index) do |element, i|
-          unless element_order[i] == element
-            raise Lutaml::Model::IncorrectSequenceError.new(element, element_order[i])
+      private
+
+      def validate_sequence!(defined_order, element_order)
+        eo_index = element_order_index(element_order, defined_order)
+
+        defined_order.each do |element, klass_attr|
+          if klass_attr.collection?
+            if add_missing_element?(element_order, eo_index, element, klass_attr)
+              element_order.insert(eo_index, element)
+            else
+              occurrences = klass_attr.sequenced_appearance_count(element_order, element, eo_index)
+              next eo_index += occurrences if occurrences.positive?
+            end
           end
+
+          next eo_index += 1 if element_order[eo_index] == element
+
+          raise Lutaml::Model::IncorrectSequenceError.new(element, element_order[eo_index])
+        end
+      end
+
+      def add_missing_element?(element_order, eo_index, element, klass_attr)
+        return false unless klass_attr.collection_range.min.zero?
+
+        element_order[eo_index] != element && !element_order.include?(element)
+      end
+
+      def element_order_index(element_order, defined_order)
+        element_order.find_index { |d| defined_order.key?(d) } || 0
+      end
+
+      def extract_defined_order(model_attrs)
+        @attributes.each_with_object({}) do |rule, acc|
+          acc[rule.name.to_s] = model_attrs[rule.to.to_s] ||
+            model_attrs[rule.to.to_sym]
         end
       end
+
+      def later_importable?(model)
+        model.is_a?(Symbol) ||
+          model.is_a?(String)
+      end
+
+      def import_mappings_later(model)
+        @model.sequence_importable_mappings[self] << model.to_sym
+        @model.set_mappings_imported(false)
+      end
     end
   end
 end

data/lib/lutaml/model/serialize.rb

@@ -3,7 +3,6 @@ require_relative "config"
 require_relative "type"
 require_relative "attribute"
 require_relative "mapping_hash"
-# require_relative "mapping"
 require_relative "json_adapter"
 require_relative "comparable_model"
 require_relative "schema_location"
@@ -13,6 +12,7 @@ require_relative "choice"
 require_relative "sequence"
 require_relative "liquefiable"
 require_relative "transform"
+require_relative "registrable"
 
 module Lutaml
   module Model
@@ -20,6 +20,7 @@ module Lutaml
       include ComparableModel
       include Validation
       include Lutaml::Model::Liquefiable
+      include Lutaml::Model::Registrable
 
       def self.included(base)
         base.extend(ClassMethods)
@@ -29,7 +30,7 @@ module Lutaml
       module ClassMethods
         include Lutaml::Model::Liquefiable::ClassMethods
 
-        attr_accessor :attributes, :mappings, :choice_attributes
+        attr_accessor :choice_attributes, :mappings
 
         def inherited(subclass)
           super
@@ -48,6 +49,16 @@ module Lutaml
           instance_variable_set(:@model, self)
         end
 
+        def attributes(register = nil)
+          ensure_imports!(register) if finalized?
+          @attributes
+        end
+
+        def ensure_imports!(register = nil)
+          ensure_model_imports!(register)
+          ensure_choice_imports!(register)
+        end
+
         def model(klass = nil)
           if klass
             @model = klass
@@ -112,7 +123,7 @@ module Lutaml
             end
             define_method(:"#{name}=") do |value|
               value_set_for(name)
-              instance_variable_set(:"@#{name}", attr.cast_value(value))
+              instance_variable_set(:"@#{name}", attr.cast_value(value, register))
             end
           end
         end
@@ -131,6 +142,25 @@ module Lutaml
           attr
         end
 
+        def restrict(name, options = {})
+          validate_attribute_options!(name, options)
+          attr = attributes[name]
+          attr.options.merge!(options)
+          attr.process_options!
+          name
+        end
+
+        def validate_attribute_options!(name, options)
+          invalid_opts = options.keys - Attribute::ALLOWED_OPTIONS
+          return if invalid_opts.empty?
+
+          raise Lutaml::Model::InvalidAttributeOptionsError.new(name, invalid_opts)
+        end
+
+        def register(name)
+          name&.to_sym
+        end
+
         def root?
           mappings_for(:xml)&.root?
         end
@@ -142,6 +172,14 @@ module Lutaml
         end
 
         def import_model_attributes(model)
+          if model.is_a?(Symbol) || model.is_a?(String)
+            importable_models[:import_model_attributes] << model.to_sym
+            @models_imported = false
+            @choices_imported = false
+            setup_trace_point
+            return
+          end
+
           model.attributes.each_value do |attr|
             define_attribute_methods(attr)
           end
@@ -151,8 +189,14 @@ module Lutaml
         end
 
         def import_model_mappings(model)
-          import_model_with_root_error(model)
+          if model.is_a?(Symbol) || model.is_a?(String)
+            importable_models[:import_model_mappings] << model.to_sym
+            @models_imported = false
+            setup_trace_point
+            return
+          end
 
+          import_model_with_root_error(model)
           Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
             next unless model.mappings.key?(format)
 
@@ -178,11 +222,27 @@ module Lutaml
         end
 
         def import_model(model)
+          if model.is_a?(Symbol) || model.is_a?(String)
+            importable_models[:import_model] << model.to_sym
+            @models_imported = false
+            @choices_imported = false
+            setup_trace_point
+            return
+          end
+
           import_model_with_root_error(model)
           import_model_attributes(model)
           import_model_mappings(model)
         end
 
+        def importable_models
+          @importable_models ||= MappingHash.new { |h, k| h[k] = [] }
+        end
+
+        def importable_choices
+          @importable_choices ||= MappingHash.new { |h, k| h[k] = MappingHash.new { |h1, k1| h1[k1] = [] } }
+        end
+
         def add_enum_methods_to_model(klass, enum_name, values, collection: false)
           add_enum_getter_if_not_defined(klass, enum_name, collection)
           add_enum_setter_if_not_defined(klass, enum_name, values, collection)
@@ -264,15 +324,8 @@ module Lutaml
         end
 
         def process_mapping(format, &block)
-          # klass = Lutaml::Model.const_get("#{format.to_s.capitalize}Mapping")
-          # mappings[format] ||= klass.new
-          # mappings[format].instance_eval(&block)
-
-          # handle_root_assignment(mappings, format)
-
           klass = ::Lutaml::Model::Config.mappings_class_for(format)
           mappings[format] ||= klass.new
-
           mappings[format].instance_eval(&block)
 
           if mappings[format].respond_to?(:finalize)
@@ -281,24 +334,24 @@ module Lutaml
         end
 
         def from(format, data, options = {})
-          return data if Utils.uninitialized?(data)
-
           adapter = Lutaml::Model::Config.adapter_for(format)
 
           doc = adapter.parse(data, options)
-          public_send(:"of_#{format}", doc, options)
+          send("of_#{format}", doc, options)
         end
 
         def of(format, doc, options = {})
-          if doc.is_a?(Array)
+          if doc.is_a?(Array) && format != :jsonl
             return doc.map { |item| send(:"of_#{format}", item) }
           end
 
           if format == :xml
-            raise Lutaml::Model::NoRootMappingError.new(self) unless root?
+            valid = root? || options[:from_collection]
+            raise Lutaml::Model::NoRootMappingError.new(self) unless valid
 
             options[:encoding] = doc.encoding
           end
+          options[:register] = extract_register_id(options[:register])
 
           transformer = Lutaml::Model::Config.transformer_for(format)
           transformer.data_to_model(self, doc, format, options)
@@ -309,7 +362,6 @@ module Lutaml
           adapter = Lutaml::Model::Config.adapter_for(format)
 
           options[:mapper_class] = self if format == :xml
-
           adapter.new(value).public_send(:"to_#{format}", options)
         end
 
@@ -335,6 +387,7 @@ module Lutaml
         end
 
         def mappings_for(format)
+          @mappings[:xml]&.ensure_mappings_imported! if @mappings&.dig(:xml)&.finalized?
           mappings[format] || default_mappings(format)
         end
 
@@ -350,12 +403,21 @@ module Lutaml
               )
             end
 
-            mapping.root(to_s.split("::").last) if format == :xml
+            mapping.root(Utils.base_class_name(self)) if format == :xml
           end
         end
 
         def apply_mappings(doc, format, options = {})
-          instance = options[:instance] || model.new
+          register = options[:register] || Lutaml::Model::Config.default_register
+          instance = if options.key?(:instance)
+                       options[:instance]
+                     elsif model.include?(Lutaml::Model::Serialize)
+                       model.new({}, register: register)
+                     else
+                       object = model.new
+                       register_accessor_methods_for(object, register)
+                       object
+                     end
           return instance if Utils.blank?(doc)
 
           mappings = mappings_for(format)
@@ -364,7 +426,6 @@ module Lutaml
             return resolve_polymorphic(doc, format, mappings, instance, options)
           end
 
-          # options[:mappings] = mappings.mappings
           transformer = Lutaml::Model::Config.transformer_for(format)
           transformer.data_to_model(self, doc, format, options)
         end
@@ -377,7 +438,7 @@ module Lutaml
           klass_name = polymorphic_mapping.polymorphic_map[klass_key]
           klass = Object.const_get(klass_name)
 
-          klass.apply_mappings(doc, format, options)
+          klass.apply_mappings(doc, format, options.merge(register: instance.register))
         end
 
         def apply_value_map(value, value_map, attr)
@@ -400,7 +461,7 @@ module Lutaml
         end
 
         def empty_object(attr)
-          return [] if attr.collection?
+          return attr.build_collection if attr.collection?
 
           ""
         end
@@ -422,6 +483,72 @@ module Lutaml
             value
           end
         end
+
+        def register_accessor_methods_for(object, register)
+          Utils.add_singleton_method_if_not_defined(object, :register) do
+            @register
+          end
+          Utils.add_singleton_method_if_not_defined(object, :register=) do |value|
+            @register = value
+          end
+          object.register = register
+        end
+
+        def extract_register_id(register)
+          if register
+            register.is_a?(Lutaml::Model::Register) ? register.id : register
+          elsif class_variable_defined?(:@@register)
+            class_variable_get(:@@register)
+          else
+            Lutaml::Model::Config.default_register
+          end
+        end
+
+        def ensure_model_imports!(register_id = nil)
+          return if @models_imported
+
+          register_id ||= Lutaml::Model::Config.default_register
+          register = Lutaml::Model::GlobalRegister.lookup(register_id)
+          importable_models.each do |method, models|
+            models.uniq.each do |model|
+              model_class = register.get_class_without_register(model)
+              import_model_with_root_error(model_class)
+
+              @model.public_send(method, model_class)
+            end
+          end
+
+          @models_imported = true
+        end
+
+        def ensure_choice_imports!(register_id = nil)
+          return if @choices_imported
+
+          register_id ||= Lutaml::Model::Config.default_register
+          register = Lutaml::Model::GlobalRegister.lookup(register_id)
+          importable_choices.each do |choice, choice_imports|
+            choice_imports.each do |method, models|
+              models.uniq!
+              choice.public_send(method, register.get_class_without_register(models.shift)) until models.empty?
+            end
+          end
+
+          @choices_imported = true
+        end
+
+        def setup_trace_point
+          @trace ||= TracePoint.new(:end) do |_tp|
+            if include?(Lutaml::Model::Serialize)
+              @finalized = true
+              @trace.disable
+            end
+          end
+          @trace.enable unless @trace.enabled?
+        end
+
+        def finalized?
+          @finalized
+        end
       end
 
       def self.register_format_mapping_method(format)
@@ -452,25 +579,27 @@ module Lutaml
         end
 
         define_method(:"to_#{format}") do |options = {}|
-          raise Lutaml::Model::NoRootMappingError.new(self.class) if format == :xml && !self.class.root?
-
-          options[:parse_encoding] = encoding if encoding
-          self.class.to(format, self, options)
+          to_format(format, options)
         end
       end
 
-      attr_accessor :element_order, :schema_location, :encoding
+      attr_accessor :element_order, :schema_location, :encoding, :register
       attr_writer :ordered, :mixed
 
       def initialize(attrs = {}, options = {})
         @using_default = {}
         return unless self.class.attributes
 
+        @register = extract_register_id(options[:register])
         set_ordering(attrs)
         set_schema_location(attrs)
         initialize_attributes(attrs, options)
       end
 
+      def extract_register_id(register)
+        self.class.extract_register_id(register)
+      end
+
       def value_map(options)
         {
           omitted: options[:omitted] || :nil,
@@ -479,30 +608,9 @@ module Lutaml
         }
       end
 
-      def attr_value(attrs, name, attr_rule)
-        value = if attrs.key?(name.to_sym)
-                  attrs[name.to_sym]
-                elsif attrs.key?(name.to_s)
-                  attrs[name.to_s]
-                else
-                  attr_rule.default
-                end
-
-        if attr_rule.collection? || value.is_a?(Array)
-          value&.map do |v|
-            if v.is_a?(Hash)
-              attr_rule.type.new(v)
-            else
-              # TODO: This code is problematic because Type.cast does not know
-              # about all the types.
-              Lutaml::Model::Type.cast(v, attr_rule.type)
-            end
-          end
-        else
-          # TODO: This code is problematic because Type.cast does not know
-          # about all the types.
-          Lutaml::Model::Type.cast(value, attr_rule.type)
-        end
+      def attr_value(attrs, name, attribute)
+        value = Utils.fetch_str_or_sym(attrs, name, attribute.default(register))
+        attribute.cast_value(value, register)
       end
 
       def using_default_for(attribute_name)
@@ -569,8 +677,22 @@ module Lutaml
         self.class.as_yaml(self)
       end
 
+      def to_format(format, options = {})
+        validate_root_mapping!(format, options)
+
+        options[:parse_encoding] = encoding if encoding
+        self.class.to(format, self, options)
+      end
+
       private
 
+      def validate_root_mapping!(format, options)
+        return if format != :xml
+        return if options[:collection] || self.class.root?
+
+        raise Lutaml::Model::NoRootMappingError.new(self.class)
+      end
+
       def set_ordering(attrs)
         return unless attrs.respond_to?(:ordered?)
 
@@ -600,9 +722,9 @@ module Lutaml
       def determine_value(attrs, name, attr)
         if attrs.key?(name) || attrs.key?(name.to_s)
           attr_value(attrs, name, attr)
-        elsif attr.default_set?
+        elsif attr.default_set?(register)
           using_default_for(name)
-          attr.default
+          attr.default(register)
         else
           Lutaml::Model::UninitializedClass.instance
         end

data/lib/lutaml/model/services/base.rb

@@ -0,0 +1,11 @@
+module Lutaml
+  module Model
+    module Services
+      class Base
+        def self.call(*args)
+          new(*args).call
+        end
+      end
+    end
+  end
+end