lutaml-model 0.7.1 → 0.7.7

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

@@ -0,0 +1,54 @@
+module Lutaml
+  module Model
+    class Logger
+      def self.warn(message)
+        new.call(message, :warn)
+      end
+
+      # @param [String] old: The name of the deprecated class or method
+      # @param [String] replacement: The name of the replacement class or method
+      #
+      # 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_deprecation(old:, replacement:)
+        warn("Usage of `#{old}` is deprecated and will be removed in the next major release. Please use `#{replacement}` instead.")
+      end
+
+      # @param [String] name
+      # @param [String] caller_file
+      # @param [Integer] caller_line
+      #
+      # Outputs a warning message that
+      #   `<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 explicitly define at `#{caller_file}:#{caller_line}`")
+      end
+
+      def call(message, type)
+        Warning.warn format_message(message, type)
+      end
+
+      private
+
+      def colorize(message, type)
+        type_color = {
+          error: 31, # Red: 31
+          success: 32, # Green: 32
+          warn: 33, # Yellow: 33
+        }
+
+        io = type == :warn ? $stderr : $stdout
+        return message unless io.tty?
+
+        color = type_color[type]
+        "\e[#{color}m#{message}\e[0m"
+      end
+
+      def format_message(message, type)
+        colorize("\n[Lutaml::Model] #{type.upcase}: #{message}\n", type)
+      end
+    end
+  end
+end

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/transformer.rb

@@ -0,0 +1,48 @@
+module Lutaml
+  module Model
+    class Transformer
+      class << self
+        def call(value, rule, attribute)
+          new(rule, attribute).call(value)
+        end
+      end
+
+      attr_reader :rule, :attribute
+
+      def initialize(rule, attribute)
+        @rule = rule
+        @attribute = attribute
+      end
+
+      def call(value)
+        transformation_methods.reduce(value) do |transformed_value, method|
+          method.call(transformed_value)
+        end
+      end
+    end
+
+    class ImportTransformer < Transformer
+      # Precedene of transformations:
+      # 1. Rule transform
+      # 2. Attribute transform
+      def transformation_methods
+        [
+          rule.transform[:import],
+          attribute&.transform&.[](:import),
+        ].compact
+      end
+    end
+
+    class ExportTransformer < Transformer
+      # Precedene of transformations (reverse order):
+      # 1. Attribute transform
+      # 2. Rule transform
+      def transformation_methods
+        [
+          attribute&.transform&.[](:export),
+          rule.transform[:export],
+        ].compact
+      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

@@ -0,0 +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/toml/document.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Toml
+      # Base class for TOML documents
+      class Document < Lutaml::Model::KeyValueDocument
+      end
+    end
+  end
+end

data/lib/lutaml/model/toml/mapping.rb

@@ -0,0 +1,27 @@
+require_relative "../mapping/key_value_mapping"
+
+module Lutaml
+  module Model
+    module Toml
+      class Mapping < Lutaml::Model::KeyValueMapping
+        def initialize
+          super(:toml)
+        end
+
+        def deep_dup
+          self.class.new.tap do |new_mapping|
+            new_mapping.instance_variable_set(:@mappings, duplicate_mappings)
+          end
+        end
+
+        def validate!(key, to, with, render_nil, render_empty)
+          super
+
+          if [true, :as_nil].include?(render_nil) || render_empty == :as_nil
+            raise IncorrectMappingArgumentsError, "nil values are not supported in toml format"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/toml/mapping_rule.rb

@@ -0,0 +1,9 @@
+require_relative "../mapping/key_value_mapping_rule"
+
+module Lutaml
+  module Model
+    module Toml
+      class MappingRule < Lutaml::Model::KeyValueMappingRule; end
+    end
+  end
+end

data/lib/lutaml/model/{toml_adapter → toml}/toml_rb_adapter.rb

@@ -1,10 +1,10 @@
 require "toml-rb"
-require_relative "toml_document"
+require_relative "document"
 
 module Lutaml
   module Model
-    module TomlAdapter
-      class TomlRbAdapter < TomlDocument
+    module Toml
+      class TomlRbAdapter < Document
         def self.parse(toml, _options = {})
           TomlRB.parse(toml)
         end

data/lib/lutaml/model/toml/tomlib_adapter.rb

@@ -0,0 +1,19 @@
+require "tomlib"
+require_relative "document"
+
+module Lutaml
+  module Model
+    module Toml
+      class TomlibAdapter < Document
+        def self.parse(toml, _options = {})
+          Tomlib.load(toml)
+        end
+
+        def to_toml(*)
+          Tomlib.dump(to_h)
+          # Tomlib::Generator.new(to_h).toml_str
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Lutaml
+  module Model
+    module Toml
+      class Transform < Lutaml::Model::KeyValueTransform
+      end
+    end
+  end
+end

data/lib/lutaml/model/toml.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Toml
+      def self.detect_toml_adapter
+        return :tomlib if Object.const_defined?(:Tomlib)
+        return :toml_rb if Object.const_defined?(:TomlRb)
+
+        nil
+      end
+    end
+  end
+end
+
+require_relative "toml/document"
+require_relative "toml/mapping"
+require_relative "toml/mapping_rule"
+require_relative "toml/transform"
+
+Lutaml::Model::FormatRegistry.register(
+  :toml,
+  mapping_class: Lutaml::Model::Toml::Mapping,
+  adapter_class: nil,
+  transformer: Lutaml::Model::Toml::Transform,
+)
+
+if (adapter = Lutaml::Model::Toml.detect_toml_adapter)
+  Lutaml::Model::Config.toml_adapter_type = adapter
+end