lutaml-model 0.7.3 → 0.7.5

data/lib/lutaml/model/transform/xml_transform.rb

@@ -2,7 +2,12 @@ module Lutaml
   module Model
     class XmlTransform < Lutaml::Model::Transform
       def data_to_model(data, _format, options = {})
-        instance = model_class.new
+        if model_class.include?(Lutaml::Model::Serialize)
+          instance = model_class.new({}, register: register)
+        else
+          instance = model_class.new
+          register_accessor_methods_for(instance, register)
+        end
         apply_xml_mapping(data, instance, options)
       end
 
@@ -29,11 +34,11 @@ module Lutaml
         validate_sequence!(doc.root.order)
 
         mappings.each do |rule|
-          raise "Attribute '#{rule.to}' not found in #{context}" unless valid_rule?(rule)
-
           attr = attribute_for_rule(rule)
           next if attr&.derived?
 
+          raise "Attribute '#{rule.to}' not found in #{context}" unless valid_rule?(rule, attr)
+
           new_opts = options.dup
           if rule.namespace_set?
             new_opts[:default_namespace] = rule.namespace
@@ -46,9 +51,9 @@ module Lutaml
                   else
                     val = value_for_rule(doc, rule, new_opts, instance)
 
-                    if (Utils.uninitialized?(val) || val.nil?) && (instance.using_default?(rule.to) || rule.render_default)
+                    if (val.nil? || Utils.uninitialized?(val)) && (instance.using_default?(rule.to) || rule.render_default)
                       defaults_used << rule.to
-                      attr&.default || rule.to_value_for(instance)
+                      attr&.default(register) || rule.to_value_for(instance)
                     else
                       val
                     end
@@ -106,49 +111,45 @@ module Lutaml
 
       def value_for_rule(doc, rule, options, instance)
         rule_names = rule.namespaced_names(options[:default_namespace])
+        return doc.root.find_attribute_value(rule_names) if rule.attribute?
 
-        if rule.attribute?
-          doc.root.find_attribute_value(rule_names)
-        else
-          attr = attribute_for_rule(rule)
-          children = doc.children.select do |child|
-            rule_names.include?(child.namespaced_name) && !child.text?
-          end
+        attr = attribute_for_rule(rule)
+        attr_type = attr&.type(register)
 
-          if rule.has_custom_method_for_deserialization? || attr.type == Lutaml::Model::Type::Hash
-            return_child = attr.type == Lutaml::Model::Type::Hash || !attr.collection? if attr
-            return return_child ? children.first : children
-          end
+        children = doc.children.select do |child|
+          rule_names.include?(child.namespaced_name) && !child.text?
+        end
 
-          return handle_cdata(children) if rule.cdata
+        if rule.has_custom_method_for_deserialization? || attr_type == Lutaml::Model::Type::Hash
+          return_child = attr_type == Lutaml::Model::Type::Hash || !attr.collection? if attr
+          return return_child ? children.first : children
+        end
 
-          values = []
+        return handle_cdata(children) if rule.cdata
+        return Lutaml::Model::UninitializedClass.instance if children.empty?
 
-          if Utils.present?(children)
-            instance.value_set_for(attr.name)
-          else
-            children = nil
-            values = Lutaml::Model::UninitializedClass.instance
-          end
+        values = attr.build_collection
 
-          children&.each do |child|
-            if !rule.has_custom_method_for_deserialization? && attr.type <= Serialize
-              cast_options = options.except(:mappings)
-              cast_options[:polymorphic] = rule.polymorphic if rule.polymorphic
+        instance.value_set_for(attr.name)
 
-              values << attr.cast(child, :xml, cast_options)
-            elsif attr.raw?
-              values << inner_xml_of(child)
-            else
-              return nil if rule.render_nil_as_nil? && child.nil_element?
+        children.each do |child|
+          if !rule.has_custom_method_for_deserialization? && attr_type <= Serialize
+            cast_options = options.except(:mappings)
+            cast_options[:polymorphic] = rule.polymorphic if rule.polymorphic
+            cast_options[:register] = register
 
-              text = child.nil_element? ? nil : (child&.text&.+ child&.cdata)
-              values << text
-            end
-          end
+            values << attr.cast(child, :xml, register, cast_options)
+          elsif attr.raw?
+            values << inner_xml_of(child)
+          else
+            return nil if rule.render_nil_as_nil? && child.nil_element?
 
-          normalized_value_for_attr(values, attr)
+            text = child.nil_element? ? nil : (child&.text&.+ child&.cdata)
+            values << text
+          end
         end
+
+        normalized_value_for_attr(values, attr)
       end
 
       def handle_cdata(children)
@@ -173,30 +174,16 @@ module Lutaml
       end
 
       def normalize_xml_value(value, rule, attr, options = {})
-        value = [value].compact if attr&.collection? && !value.is_a?(Array) && !value.nil?
+        collection_class = attr&.collection_class || Array
+        value = [value].compact if !value.nil? && attr&.collection? && !value.is_a?(collection_class)
 
         return value unless cast_value?(attr, rule)
 
-        options.merge(caller_class: self, mixed_content: rule.mixed_content)
-        attr.cast(
-          value,
-          :xml,
-          options,
-        )
+        attr.cast(value, :xml, register, options)
       end
 
       def cast_value?(attr, rule)
-        attr &&
-          !rule.raw_mapping? &&
-          !rule.content_mapping? &&
-          !rule.custom_methods[:from]
-      end
-
-      def text_hash?(attr, value)
-        return false unless value.is_a?(Hash)
-        return value.one? && value.text? unless attr
-
-        !(attr.type <= Serialize) && attr.type != Lutaml::Model::Type::Hash
+        attr && rule.castable?
       end
 
       def ensure_utf8(value)
@@ -228,10 +215,12 @@ module Lutaml
 
       def validate_sequence!(element_order)
         mapping_sequence = mappings_for(:xml).element_sequence
+        return if mapping_sequence.empty?
+
         current_order = element_order.filter_map(&:element_tag)
 
         mapping_sequence.each do |mapping|
-          mapping.validate_content!(current_order)
+          mapping.validate_content!(current_order, context)
         end
       end
     end

data/lib/lutaml/model/transform.rb

@@ -2,18 +2,19 @@ module Lutaml
   module Model
     class Transform
       def self.data_to_model(context, data, format, options = {})
-        new(context).data_to_model(data, format, options)
+        new(context, options[:register]).data_to_model(data, format, options)
       end
 
       def self.model_to_data(context, model, format, options = {})
-        new(context).model_to_data(model, format, options)
+        new(context, model.register).model_to_data(model, format, options)
       end
 
-      attr_reader :context, :attributes
+      attr_reader :context, :attributes, :register
 
-      def initialize(context)
+      def initialize(context, register = nil)
         @context = context
         @attributes = context.attributes
+        @register = register || Lutaml::Model::Config.default_register
       end
 
       def model_class
@@ -59,16 +60,29 @@ module Lutaml
         context.mappings_for(format)
       end
 
-      def valid_rule?(rule)
-        attribute = attribute_for_rule(rule)
+      def defined_mappings_for(format)
+        context.mappings[format]
+      end
 
-        !!attribute || rule.custom_methods[:from]
+      def valid_rule?(rule, attribute)
+        attribute || rule.custom_methods[:from]
       end
 
       def attribute_for_rule(rule)
         return attributes[rule.to] unless rule.delegate
 
-        attributes[rule.delegate].type.attributes[rule.to]
+        attributes[rule.delegate].type(register).attributes[rule.to]
+      end
+
+      def register_accessor_methods_for(object, register)
+        klass = object.class
+        Utils.add_method_if_not_defined(klass, :register) do
+          @register
+        end
+        Utils.add_method_if_not_defined(klass, :register=) do |value|
+          @register = value
+        end
+        object.register = register
       end
     end
   end

data/lib/lutaml/model/type/boolean.rb

@@ -2,7 +2,7 @@ module Lutaml
   module Model
     module Type
       class Boolean < Value
-        def self.cast(value)
+        def self.cast(value, _options = {})
           return nil if value.nil?
           return true if value == true || value.to_s.match?(/^(true|t|yes|y|1)$/i)
           return false if value == false || value.to_s.match?(/^(false|f|no|n|0)$/i)

data/lib/lutaml/model/type/date.rb

@@ -2,7 +2,7 @@ module Lutaml
   module Model
     module Type
       class Date < Value
-        def self.cast(value)
+        def self.cast(value, _options = {})
           return value if value.nil? || Utils.uninitialized?(value)
 
           case value

data/lib/lutaml/model/type/date_time.rb

@@ -5,7 +5,7 @@ module Lutaml
     module Type
       # Date and time representation
       class DateTime < Value
-        def self.cast(value)
+        def self.cast(value, _options = {})
           return value if value.nil? || Utils.uninitialized?(value)
 
           case value

data/lib/lutaml/model/type/decimal.rb

@@ -2,18 +2,20 @@ module Lutaml
   module Model
     module Type
       class Decimal < Value
-        def self.cast(value)
+        def self.cast(value, options = {})
           return nil if value.nil?
 
           check_dependencies!(value)
-          case value
-          when BigDecimal
-            # If already a BigDecimal, return as-is
-            value
-          else
-            # Convert to string first to handle various input types
-            BigDecimal(value.to_s)
-          end
+          value = case value
+                  when BigDecimal
+                    # If already a BigDecimal, return as-is
+                    value
+                  else
+                    # Convert to string first to handle various input types
+                    BigDecimal(value.to_s)
+                  end
+          Model::Services::Type::Validator::Number.validate!(value, options)
+          value
         rescue ArgumentError
           nil
         end

data/lib/lutaml/model/type/float.rb

@@ -2,9 +2,10 @@ module Lutaml
   module Model
     module Type
       class Float < Value
-        def self.cast(value)
+        def self.cast(value, options = {})
           return nil if value.nil?
 
+          Model::Services::Type::Validator::Number.validate!(value, options)
           value.to_f
         end
 

data/lib/lutaml/model/type/integer.rb

@@ -2,31 +2,34 @@ module Lutaml
   module Model
     module Type
       class Integer < Value
-        def self.cast(value)
+        def self.cast(value, options = {})
           return nil if value.nil?
           return 1 if value === true
           return 0 if value === false
 
-          case value
-          when ::String
-            if value.match?(/^0[0-7]+$/) # Octal
-              value.to_i(8)
-            elsif value.match?(/^-?\d+(\.\d+)?(e-?\d+)?$/i) # Float/exponential
-              Float(value).to_i
-            else
-              begin
-                Integer(value, 10)
-              rescue StandardError
-                nil
-              end
-            end
-          else
-            begin
-              Integer(value)
-            rescue StandardError
-              nil
-            end
-          end
+          value = case value
+                  when ::String
+                    if value.match?(/^0[0-7]+$/) # Octal
+                      value.to_i(8)
+                    elsif value.match?(/^-?\d+(\.\d+)?(e-?\d+)?$/i) # Float/exponential
+                      Float(value).to_i
+                    else
+                      begin
+                        Integer(value, 10)
+                      rescue StandardError
+                        nil
+                      end
+                    end
+                  else
+                    begin
+                      Integer(value)
+                    rescue StandardError
+                      nil
+                    end
+                  end
+
+          Model::Services::Type::Validator::Number.validate!(value, options)
+          value
         end
 
         # Override serialize to return Integer instead of String

data/lib/lutaml/model/type/string.rb

@@ -2,10 +2,12 @@ module Lutaml
   module Model
     module Type
       class String < Value
-        def self.cast(value)
+        def self.cast(value, options = {})
           return nil if value.nil?
 
-          value.to_s
+          value = value.to_s
+          Model::Services::Type::Validator::String.validate!(value, options)
+          value
         end
 
         # xs:string format

data/lib/lutaml/model/type/time.rb

@@ -4,7 +4,7 @@ module Lutaml
   module Model
     module Type
       class Time < Value
-        def self.cast(value)
+        def self.cast(value, _options = {})
           return value if value.nil? || Utils.uninitialized?(value)
 
           case value

data/lib/lutaml/model/type/time_without_date.rb

@@ -10,7 +10,7 @@ module Lutaml
         # time = ::Time.parse(value.to_s)
         # ::Time.new(1, 1, 1, time.hour, time.min, time.sec)
 
-        def self.cast(value)
+        def self.cast(value, _options = {})
           return value if value.nil? || Utils.uninitialized?(value)
 
           case value

data/lib/lutaml/model/type/value.rb

@@ -11,7 +11,11 @@ module Lutaml
           @value = self.class.cast(value)
         end
 
-        def self.cast(value)
+        def initialized?
+          true
+        end
+
+        def self.cast(value, _options = {})
           return nil if value.nil?
 
           value

data/lib/lutaml/model/type.rb

@@ -5,6 +5,7 @@ module Lutaml
         string: "Lutaml::Model::Type::String",
         integer: "Lutaml::Model::Type::Integer",
         float: "Lutaml::Model::Type::Float",
+        double: "Lutaml::Model::Type::Float",
         decimal: "Lutaml::Model::Type::Decimal",
         date: "Lutaml::Model::Type::Date",
         time: "Lutaml::Model::Type::Time",
@@ -32,6 +33,8 @@ module Lutaml
         end
 
         def lookup(type_name)
+          return type_name if type_name.is_a?(Class)
+
           @registry ||= {}
           klass = @registry[type_name.to_sym]
 
@@ -43,13 +46,13 @@ module Lutaml
         def cast(value, type)
           return nil if value.nil?
 
-          type.cast(value)
+          lookup(type).cast(value)
         end
 
         def serialize(value, type)
           return nil if value.nil?
 
-          type.serialize(value)
+          lookup(type).serialize(value)
         end
       end
     end

data/lib/lutaml/model/utils.rb

@@ -4,6 +4,8 @@ module Lutaml
   module Model
     module Utils
       class << self
+        UNINITIALIZED = Lutaml::Model::UninitializedClass.instance
+
         # Convert string to camel case
         def camel_case(str)
           return "" if str.nil? || str.empty?
@@ -34,14 +36,22 @@ module Lutaml
             .downcase
         end
 
-        def initialized?(value)
-          return true unless value.respond_to?(:initialized?)
+        # Extract the base name of the class
+        def base_class_name(klass)
+          klass.to_s.split("::").last
+        end
 
-          value.initialized?
+        # Convert the extracted base class to snake case format
+        def base_class_snake_case(klass)
+          snake_case(base_class_name(klass))
+        end
+
+        def initialized?(value)
+          !value.equal?(UNINITIALIZED)
         end
 
         def uninitialized?(value)
-          !initialized?(value)
+          value.equal?(UNINITIALIZED)
         end
 
         def present?(value)
@@ -63,6 +73,10 @@ module Lutaml
           value.respond_to?(:empty?) ? value.empty? : false
         end
 
+        def add_if_present(hash, key, value)
+          hash[key] = value if value
+        end
+
         # Check if the hash contains the given key in string or symbol format
         # @param hash [Hash] the hash to check
         # @param key [String, Symbol] the key to check
@@ -82,17 +96,25 @@ module Lutaml
         # @return [Object] the value associated with the key
         # @example
         #   hash = { "key" => "value" }
-        #   fetch_with_string_or_symbol_key(hash, "key") # => "value"
-        #   fetch_with_string_or_symbol_key(hash, :key) # => "value"
-        #   fetch_with_string_or_symbol_key(hash, "invalid_key") # => nil
-        def fetch_with_string_or_symbol_key(hash, key)
+        #   fetch_str_or_sym(hash, "key") # => "value"
+        #   fetch_str_or_sym(hash, :key) # => "value"
+        #   fetch_str_or_sym(hash, "invalid_key") # => nil
+        def fetch_str_or_sym(hash, key, default = nil)
           if hash.key?(key.to_s)
             hash[key.to_s]
           elsif hash.key?(key.to_sym)
             hash[key.to_sym]
+          else
+            default
           end
         end
 
+        def add_singleton_method_if_not_defined(instance, method_name, &block)
+          return if instance.respond_to?(method_name)
+
+          instance.define_singleton_method(method_name, &block)
+        end
+
         def add_method_if_not_defined(klass, method_name, &block)
           unless klass.method_defined?(method_name)
             klass.class_eval do

data/lib/lutaml/model/validation.rb

@@ -1,20 +1,22 @@
 module Lutaml
   module Model
     module Validation
-      def validate
+      def validate(register: Lutaml::Model::Config.default_register)
         errors = []
+
         self.class.attributes.each do |name, attr|
           value = public_send(:"#{name}")
           begin
             if value.respond_to?(:validate)
               errors.concat(value.validate)
             else
-              attr.validate_value!(value)
+              attr.validate_value!(value, register)
             end
           rescue Lutaml::Model::InvalidValueError,
                  Lutaml::Model::CollectionCountOutOfRangeError,
                  Lutaml::Model::CollectionTrueMissingError,
                  Lutaml::Model::PolymorphicError,
+                 Lutaml::Model::ValidationFailedError,
                  PatternNotMatchedError => e
             errors << e
           end
@@ -23,8 +25,8 @@ module Lutaml
         validate_helper(errors)
       end
 
-      def validate!
-        errors = validate
+      def validate!(register: Lutaml::Model::Config.default_register)
+        errors = validate(register: register)
         raise Lutaml::Model::ValidationError.new(errors) if errors.any?
       end
 

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.7.3"
+    VERSION = "0.7.5"
   end
 end