lutaml-model 0.7.3 → 0.7.6

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

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

@@ -11,7 +11,7 @@ module Lutaml
       # Outputs a warning message that
       #   Usage of `old` name is deprecated will be removed in the next major
       #   release. Please use the `replacement`` instead.
-      def self.warn_future_deprication(old:, replacement:)
+      def self.warn_future_deprecation(old:, replacement:)
         warn("Usage of `#{old}` is deprecated and will be removed in the next major release. Please use `#{replacement}` instead.")
       end
 
@@ -23,7 +23,7 @@ module Lutaml
       #   `<name>` is handled by default. No need to explicitly
       #   define at `<caller_file>:<caller_line>`.
       def self.warn_auto_handling(name:, caller_file:, caller_line:)
-        warn("`#{name}` is handled by default. No need to explecitly define at `#{caller_file}:#{caller_line}`")
+        warn("`#{name}` is handled by default. No need to explicitly define at `#{caller_file}:#{caller_line}`")
       end
 
       def call(message, type)

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

@@ -0,0 +1,92 @@
+require_relative "base"
+
+module Lutaml
+  module Model
+    class RuleValueExtractor < Services::Base
+      def initialize(rule, doc, format, attr, register, options)
+        super()
+
+        @rule = rule
+        @doc = doc
+        @format = format
+        @attr = attr
+        @register = register
+        @options = options
+      end
+
+      def call
+        rule_names.each do |rule_name|
+          value = rule_value_for(rule_name)
+          value = transform_mapped_value(value) if should_transform_value?(value)
+          return value if Utils.initialized?(value)
+        end
+
+        uninitialized_value
+      end
+
+      private
+
+      attr_reader :rule, :doc, :format, :attr, :register, :options
+
+      def rule_names
+        rule.multiple_mappings? ? rule.name : [rule.name]
+      end
+
+      def rule_value_for(name)
+        return doc if root_or_nil?(name)
+        return convert_to_format(doc, format) if rule.raw_mapping?
+        return fetch_value(name) if Utils.string_or_symbol_key?(doc, name)
+        return attr.default(register) if attr&.default_set?(register)
+
+        uninitialized_value
+      end
+
+      def root_or_nil?(name)
+        name.nil? || rule.root_mapping?
+      end
+
+      def fetch_value(name)
+        Utils.fetch_str_or_sym(doc, name)
+      end
+
+      def transform_mapped_value(value)
+        value.map do |k, v|
+          if v.is_a?(Hash)
+            transform_hash_value(v, k, options)
+          else
+            transform_simple_value(k, v, options)
+          end
+        end
+      end
+
+      def transform_hash_value(hash_value, key, options)
+        hash_value.merge(
+          {
+            options[:key_mappings].to_instance.to_s => key,
+          },
+        )
+      end
+
+      def transform_simple_value(key, value, options)
+        {
+          options[:key_mappings].to_instance.to_s => key,
+          options[:value_mappings].as_attribute.to_s => value,
+        }
+      end
+
+      def should_transform_value?(value)
+        (options[:key_mappings] || options[:value_mappings]) &&
+          value.is_a?(Hash)
+      end
+
+      def convert_to_format(doc, format)
+        adapter = Lutaml::Model::Config.adapter_for(format)
+        adapter.new(doc).public_send(:"to_#{format}")
+      end
+
+      def uninitialized_value
+        Lutaml::Model::UninitializedClass.instance
+      end
+    end
+  end
+end

data/lib/lutaml/model/services/type/validator/number.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Services
+      module Type
+        class Validator
+          class Number < Validator
+            module ClassMethods
+              def validate!(value, options)
+                return if Utils.blank?(options)
+
+                validate_values!(value, options[:values])
+                validate_min_max_bounds!(value, options)
+              end
+            end
+
+            extend ClassMethods
+            include ClassMethods
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Lutaml
+  module Model
+    module Services
+      module Type
+        class Validator
+          class String < Validator
+            module ClassMethods
+              def validate!(value, options)
+                return if Utils.blank?(value)
+
+                validate_values!(value, options[:values])
+                validate_length!(value, options)
+                validate_pattern!(value, options)
+              end
+
+              def validate_length!(value, options)
+                min, max = options&.values_at(:min, :max)
+                return if min.nil? || max.nil?
+
+                validate_min_length!(value, min) if min
+                validate_max_length!(value, max) if max
+              end
+
+              def validate_pattern!(value, options)
+                pattern = options[:pattern]
+                return if Utils.blank?(pattern)
+                return if value.match?(pattern)
+
+                raise Lutaml::Model::Type::PatternNotMatchedError.new(value, pattern)
+              end
+
+              def validate_min_length!(value, min)
+                return if value.length >= min
+
+                raise Lutaml::Model::Type::MinLengthError.new(value, min)
+              end
+
+              def validate_max_length!(value, max)
+                return if value.length <= max
+
+                raise Lutaml::Model::Type::MaxLengthError.new(value, max)
+              end
+            end
+
+            extend ClassMethods
+            include ClassMethods
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/services/type/validator.rb

@@ -0,0 +1,43 @@
+require_relative "validator/string"
+require_relative "validator/number"
+
+module Lutaml
+  module Model
+    module Services
+      module Type
+        class Validator
+          module ClassMethods
+            def validate_values!(value, values)
+              return if Utils.blank?(values) || values.include?(value)
+
+              raise Lutaml::Model::Type::InvalidValueError.new(value, values)
+            end
+
+            def validate_min_max_bounds!(value, options)
+              min, max = options&.values_at(:min, :max)
+              return if min.nil? && max.nil?
+
+              validate_min_bound!(value, min) if min
+              validate_max_bound!(value, max) if max
+            end
+
+            def validate_min_bound!(value, min)
+              return if value >= min
+
+              raise Lutaml::Model::Type::MinBoundError.new(value, min)
+            end
+
+            def validate_max_bound!(value, max)
+              return if value <= max
+
+              raise Lutaml::Model::Type::MaxBoundError.new(value, max)
+            end
+          end
+
+          extend ClassMethods
+          include ClassMethods
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+require_relative "base"
+
+module Lutaml
+  module Model
+    class ValidationRule
+      attr_reader :attribute, :options, :custom_method
+
+      def initialize(attribute: nil, custom_method: nil, options: {})
+        if Utils.blank?(attribute) && Utils.blank?(custom_method)
+          raise ArgumentError, "Missing attribute or custom method"
+        end
+
+        @attribute = attribute
+        @options = options
+        @custom_method = custom_method
+      end
+
+      def custom?
+        Utils.present?(custom_method)
+      end
+
+      def has_options?
+        options.is_a?(Hash)
+      end
+    end
+
+    class Validator < Services::Base
+      attr_reader :value, :validations, :errors, :memoization_container
+
+      def initialize(value, validations, memoization_container)
+        super()
+
+        @errors = Errors.new
+        @value = value
+        @memoization_container = memoization_container
+
+        resolve_validations(validations)
+      end
+
+      def call
+        return [] if Utils.blank?(validations)
+
+        @validations.each do |validation|
+          if validation.custom?
+            public_send(validation.custom_method, value)
+          else
+            validation.options.each do |key, rule|
+              send(:"validate_#{key}", value, validation.attribute, rule)
+            end
+          end
+        end
+
+        errors.messages
+      end
+
+      private
+
+      def resolve_validations(validations_block)
+        @validations ||= []
+        return unless validations_block
+
+        instance_eval(&validations_block)
+      end
+
+      def validate(method_name)
+        @validations << ValidationRule.new(custom_method: method_name)
+      end
+
+      def validates(attribute, options)
+        @validations <<
+          ValidationRule.new(attribute: attribute, options: options)
+      end
+
+      def validate_presence(model, attr, rule)
+        return if rule.nil?
+
+        if model.is_a?(Array)
+          model.each { |v| validate_presence(v, attr, rule) }
+          return
+        end
+
+        value = model.public_send(attr)
+        return if Utils.present?(value)
+
+        errors.add(attr, "`#{attr}` is required")
+      end
+
+      def validate_numericality(model, attr, rule)
+        return if rule.nil?
+
+        if model.is_a?(Array)
+          model.each { |v| validate_numericality(v, attr, rule) }
+          return
+        end
+
+        value = model.public_send(attr)
+        return unless validate_integer(attr, value)
+
+        validate_comparison_rules(attr, value, rule)
+      end
+
+      def validate_integer(attr, value)
+        return true if value.is_a?(Integer)
+
+        errors.add(
+          attr,
+          "`#{attr}` value is `#{value.class}`, but expected integer",
+        )
+      end
+
+      def validate_comparison_rules(attr, value, options)
+        validate_less_than(attr, value, options[:less_than])
+        validate_greater_than(attr, value, options[:greater_than])
+        validate_equal_to(attr, value, options[:equal_to])
+      end
+
+      def validate_less_than(attr, value, limit)
+        return if !limit || value < limit
+
+        errors.add(
+          attr,
+          "#{attr} value is `#{value}`, which is not less than #{limit}",
+        )
+      end
+
+      def validate_greater_than(attr, value, limit)
+        return if !limit || value > limit
+
+        errors.add(
+          attr,
+          "#{attr} value is `#{value}`, which is not greater than #{limit}",
+        )
+      end
+
+      def validate_equal_to(attr, value, target)
+        return if !target || value == target
+
+        errors.add(
+          attr,
+          "#{attr} value is `#{value}`, which is not equal to #{target}",
+        )
+      end
+    end
+  end
+end

data/lib/lutaml/model/services.rb

@@ -1,2 +1,5 @@
 require_relative "services/logger"
+require_relative "services/rule_value_extractor"
 require_relative "services/transformer"
+require_relative "services/validator"
+require_relative "services/type/validator"

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

@@ -2,10 +2,18 @@ module Lutaml
   module Model
     class KeyValueTransform < 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
         mappings = extract_mappings(options, format)
 
-        mappings.each do |rule|
+        Utils.add_if_present(options, :key_mappings, mappings.key_mappings)
+        Utils.add_if_present(options, :value_mappings, mappings.value_mappings)
+
+        mappings.mappings.each do |rule|
           process_mapping_rule(data, instance, format, rule, options)
         end
 
@@ -13,18 +21,30 @@ module Lutaml
       end
 
       def model_to_data(instance, format, options = {})
-        mappings = mappings_for(format).mappings
+        mappings = extract_mappings(options, format)
 
-        mappings.each_with_object({}) do |rule, hash|
+        hash = {}
+        mappings.mappings.each do |rule|
           next unless valid_mapping?(rule, options)
-          next handle_delegate(instance, rule, hash, format) if rule.delegate
 
-          process_mapping_for_instance(instance, hash, format, rule, options)
+          process_rule!(instance, rule, hash, format, mappings, options)
         end
+
+        hash.keys == [""] ? hash[""] : hash
       end
 
       private
 
+      def process_rule!(instance, rule, hash, format, mappings, options)
+        return handle_delegate(instance, rule, hash, format) if rule.delegate
+
+        value = process_mapping_for_instance(instance, hash, format, rule, options)
+
+        return unless mappings.key_value_mappings? && value
+
+        hash[rule_from_name(rule)] = handle_key_value_mappings(value, mappings)
+      end
+
       def process_mapping_for_instance(instance, hash, format, rule, options)
         if rule.custom_methods[:to]
           return instance.send(rule.custom_methods[:to], instance, hash)
@@ -74,9 +94,11 @@ module Lutaml
       end
 
       def serialize_value(value, rule, attr, format, options)
-        return attr.serialize(value, format, options) unless rule.child_mappings
+        return attr.serialize(value, format, __register, options) unless rule.child_mappings
 
-        generate_hash_from_child_mappings(attr, value, format, rule.child_mappings)
+        generate_hash_from_child_mappings(
+          attr, value, format, rule.child_mappings
+        )
       end
 
       def rule_from_name(rule)
@@ -90,11 +112,12 @@ module Lutaml
 
         generate_remaining_mappings_for_value(child_mappings, value, format)
 
+        attr_type = attr.type(__register)
         value.each do |child_obj|
-          rules = attr.type.mappings_for(format)
+          rules = attr_type.mappings_for(format)
 
           hash.merge!(
-            extract_hash_for_child_mapping(child_mappings, child_obj, rules),
+            extract_hash_for_child_mapping(child_mappings, child_obj, rules, format),
           )
         end
 
@@ -119,17 +142,16 @@ module Lutaml
       end
 
       def child_mapping_for(name, mappings)
-        mappings.find_by_to(name)&.name.to_s || name.to_s
+        mappings.find_by_to(name)&.name.to_s
       end
 
-      def extract_hash_for_child_mapping(child_mappings, child_obj, rules)
+      def extract_hash_for_child_mapping(child_mappings, child_obj, rules, format)
         key = nil
         value = {}
 
         child_mappings.each do |attr_name, path|
           rule = rules.find_by_to(attr_name)
-
-          attr_value = normalize_attribute_value(child_obj.send(attr_name))
+          attr_value = normalize_attribute_value(child_obj, rule.from, format)
 
           next unless rule&.render?(attr_value, nil)
           next key = attr_value if path == :key
@@ -141,14 +163,10 @@ module Lutaml
         { key => value }
       end
 
-      def normalize_attribute_value(value)
-        if value.is_a?(Lutaml::Model::Serialize)
-          value.to_hash
-        elsif value.is_a?(Array) && value.first.is_a?(Lutaml::Model::Serialize)
-          value.map(&:to_hash)
-        else
-          value
-        end
+      def normalize_attribute_value(value, attr_name, format)
+        Lutaml::Model::Config.adapter_for(format).parse(
+          value.public_send(:"to_#{format}"),
+        )[attr_name.to_s]
       end
 
       def extract_hash_value_for_child_mapping(path, value, map_value)
@@ -167,7 +185,7 @@ module Lutaml
         return if value.nil? && !rule.render_nil
 
         attribute = instance.send(rule.delegate).class.attributes[rule.to]
-        hash[rule_from_name(rule)] = attribute.serialize(value, format)
+        hash[rule_from_name(rule)] = attribute.serialize(value, format, __register)
       end
 
       def extract_value_for_delegate(instance, rule)
@@ -175,16 +193,16 @@ module Lutaml
       end
 
       def extract_mappings(options, format)
-        options[:mappings] || mappings_for(format).mappings
+        options[:mappings] || mappings_for(format)
       end
 
       def process_mapping_rule(doc, instance, format, rule, options = {})
-        raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule)
-
         attr = attribute_for_rule(rule)
         return if attr&.derived?
 
-        value = extract_rule_value(doc, rule, format, attr)
+        raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule, attr)
+
+        value = rule_value_extractor_class.call(rule, doc, format, attr, __register, options)
         value = apply_value_map(value, rule.value_map(:from, options), attr)
 
         return process_custom_method(rule, instance, value) if rule.has_custom_method_for_deserialization?
@@ -196,37 +214,6 @@ module Lutaml
         rule.deserialize(instance, value, attributes, self)
       end
 
-      def extract_rule_value(doc, rule, format, attr)
-        rule_names = rule.multiple_mappings? ? rule.name : [rule.name]
-
-        rule_names.each do |rule_name|
-          value = rule_value_for(rule_name, doc, rule, format, attr)
-
-          return value if Utils.initialized?(value)
-        end
-
-        Lutaml::Model::UninitializedClass.instance
-      end
-
-      def rule_value_for(name, doc, rule, format, attr)
-        if rule.root_mapping?
-          doc
-        elsif rule.raw_mapping?
-          convert_to_format(doc, format)
-        elsif Utils.string_or_symbol_key?(doc, name)
-          Utils.fetch_with_string_or_symbol_key(doc, name)
-        elsif attr&.default_set?
-          attr.default
-        else
-          Lutaml::Model::UninitializedClass.instance
-        end
-      end
-
-      def convert_to_format(doc, format)
-        adapter = Lutaml::Model::Config.adapter_for(format)
-        adapter.new(doc).public_send(:"to_#{format}")
-      end
-
       def process_custom_method(rule, instance, value)
         return unless Utils.present?(value)
 
@@ -235,7 +222,7 @@ module Lutaml
 
       def cast_value(value, attr, format, rule)
         cast_options = rule.polymorphic ? { polymorphic: rule.polymorphic } : {}
-        attr.cast(value, format, cast_options)
+        attr.cast(value, format, __register, cast_options)
       end
 
       def translate_mappings(hash, child_mappings, attr, format)
@@ -257,9 +244,10 @@ module Lutaml
       end
 
       def build_child_hash(key, value, child_mappings, attr, format)
+        attr_type = attr.type(__register)
         child_mappings.to_h do |attr_name, path|
           attr_value = extract_attr_value(path, key, value)
-          attr_rule = attr.type.mappings_for(format).find_by_to(attr_name)
+          attr_rule = attr_type.mappings_for(format).find_by_to(attr_name)
           [attr_rule.from.to_s, attr_value]
         end
       end
@@ -279,13 +267,31 @@ module Lutaml
       end
 
       def map_child_data(child_hash, attr, format)
+        attr_type = attr.type(__register)
         self.class.data_to_model(
-          attr.type,
+          attr_type,
           child_hash,
           format,
-          { mappings: attr.type.mappings_for(format).mappings },
+          { mappings: attr_type.mappings_for(format) },
         )
       end
+
+      def handle_key_value_mappings(value, mappings)
+        value.to_h do |v|
+          [
+            v[mappings.key_mappings.to_instance.to_s],
+            if mappings.value_mappings
+              v[mappings.value_mappings.as_attribute.to_s]
+            else
+              v.except(mappings.key_mappings.to_instance.to_s)
+            end,
+          ]
+        end
+      end
+
+      def rule_value_extractor_class
+        Lutaml::Model::RuleValueExtractor
+      end
     end
   end
 end