servactory 2.12.0.rc2 → 2.12.0.rc3

data/lib/servactory/tool_kit/dynamic_options/schema.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Servactory
+  module ToolKit
+    module DynamicOptions
+      class Schema < Must # rubocop:disable Metrics/ClassLength
+        RESERVED_ATTRIBUTES = %i[type required default].freeze
+        private_constant :RESERVED_ATTRIBUTES
+
+        def self.use(option_name = :schema, default_hash_mode_class_names:)
+          instance = new(option_name, :is, false)
+          instance.assign(default_hash_mode_class_names)
+          instance.must(:schema)
+        end
+
+        def assign(default_hash_mode_class_names)
+          @default_hash_mode_class_names = default_hash_mode_class_names
+        end
+
+        def condition_for_input_with(input:, value:, option:)
+          common_condition_with(attribute: input, value:, option:)
+        end
+
+        def condition_for_internal_with(internal:, value:, option:)
+          common_condition_with(attribute: internal, value:, option:)
+        end
+
+        def condition_for_output_with(output:, value:, option:)
+          common_condition_with(attribute: output, value:, option:)
+        end
+
+        def common_condition_with(attribute:, value:, option:)
+          return true if option.value == false
+          return [false, :wrong_type] if @default_hash_mode_class_names.intersection(attribute.types).empty?
+
+          schema = option.value.fetch(:is, option.value)
+
+          is_success, reason, meta = validate_for!(object: value, schema:)
+
+          prepare_object_with!(object: value, schema:) if is_success
+
+          [is_success, reason, meta]
+        end
+
+        def validate_for!(object:, schema:, root_schema_key: nil) # rubocop:disable Metrics/MethodLength
+          unless object.respond_to?(:fetch)
+            return [
+              false,
+              :wrong_element_value,
+              {
+                key_name: root_schema_key,
+                expected_type: Hash.name,
+                given_type: object.class.name
+              }
+            ]
+          end
+
+          errors = schema.map do |schema_key, schema_value|
+            attribute_type = schema_value.fetch(:type, String)
+
+            if attribute_type == Hash
+              validate_for!(
+                object: object.fetch(schema_key, {}),
+                schema: schema_value.except(*RESERVED_ATTRIBUTES),
+                root_schema_key: schema_key
+              )
+            else
+              is_success, given_type = validate_with(
+                object:,
+                schema_key:,
+                schema_value:,
+                attribute_type:,
+                attribute_required: schema_value.fetch(:required, true)
+              )
+
+              next if is_success
+
+              [false, :wrong_element_type, { key_name: schema_key, expected_type: attribute_type, given_type: }]
+            end
+          end
+
+          errors.compact.first || true
+        end
+
+        def validate_with(object:, schema_key:, schema_value:, attribute_type:, attribute_required:) # rubocop:disable Metrics/MethodLength
+          unless should_be_checked_for?(
+            object:,
+            schema_key:,
+            schema_value:,
+            required: attribute_required
+          ) # do
+            return true
+          end
+
+          value = object.fetch(schema_key, nil)
+          prepared_value = prepare_value_from(schema_value:, value:, required: attribute_required)
+
+          [
+            Array(attribute_type).uniq.any? { |type| prepared_value.is_a?(type) },
+            prepared_value.class.name
+          ]
+        end
+
+        def should_be_checked_for?(object:, schema_key:, schema_value:, required:)
+          required || (
+            !required && !fetch_default_from(schema_value).nil?
+          ) || (
+            !required && !object.fetch(schema_key, nil).nil?
+          )
+        end
+
+        def prepare_value_from(schema_value:, value:, required:)
+          if !required && !fetch_default_from(schema_value).nil? && value.blank?
+            fetch_default_from(schema_value)
+          else
+            value
+          end
+        end
+
+        def fetch_default_from(value)
+          value.fetch(:default, nil)
+        end
+
+        ########################################################################
+
+        def prepare_object_with!(object:, schema:) # rubocop:disable Metrics/MethodLength
+          schema.map do |schema_key, schema_value|
+            attribute_type = schema_value.fetch(:type, String)
+
+            if attribute_type == Hash
+              prepare_object_with!(
+                object: object.fetch(schema_key, {}),
+                schema: schema_value.except(*RESERVED_ATTRIBUTES)
+              )
+            else
+              next object unless object[schema_key].nil?
+
+              next object if (default = schema_value.fetch(:default, nil)).nil?
+
+              object[schema_key] = default
+            end
+          end
+        end
+
+        ########################################################################
+        ########################################################################
+        ########################################################################
+
+        def message_for_input_with(service:, input:, reason:, meta:, **)
+          i18n_key = "inputs.validations.must.dynamic_options.schema"
+          i18n_key += reason.present? ? ".#{reason}" : ".default"
+
+          service.translate(
+            i18n_key,
+            service_class_name: service.class_name,
+            input_name: input.name,
+            key_name: meta.fetch(:key_name),
+            expected_type: meta.fetch(:expected_type),
+            given_type: meta.fetch(:given_type)
+          )
+        end
+
+        def message_for_internal_with(service:, internal:, reason:, meta:, **)
+          i18n_key = "internals.validations.must.dynamic_options.schema"
+          i18n_key += reason.present? ? ".#{reason}" : ".default"
+
+          service.translate(
+            i18n_key,
+            service_class_name: service.class_name,
+            internal_name: internal.name,
+            key_name: meta.fetch(:key_name),
+            expected_type: meta.fetch(:expected_type),
+            given_type: meta.fetch(:given_type)
+          )
+        end
+
+        def message_for_output_with(service:, output:, reason:, meta:, **)
+          i18n_key = "outputs.validations.must.dynamic_options.schema"
+          i18n_key += reason.present? ? ".#{reason}" : ".default"
+
+          service.translate(
+            i18n_key,
+            service_class_name: service.class_name,
+            output_name: output.name,
+            key_name: meta.fetch(:key_name),
+            expected_type: meta.fetch(:expected_type),
+            given_type: meta.fetch(:given_type)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/servactory/version.rb

@@ -5,7 +5,7 @@ module Servactory
     MAJOR = 2
     MINOR = 12
     PATCH = 0
-    PRE = "rc2"
+    PRE = "rc3"
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join(".")
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: servactory
 version: !ruby/object:Gem::Version
-  version: 2.12.0.rc2
+  version: 2.12.0.rc3
 platform: ruby
 authors:
 - Anton Sokolov
 bindir: bin
 cert_chain: []
-date: 2025-02-18 00:00:00.000000000 Z
+date: 2025-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -298,7 +298,6 @@ files:
 - lib/servactory/maintenance/attributes/validations/errors.rb
 - lib/servactory/maintenance/attributes/validations/must.rb
 - lib/servactory/maintenance/attributes/validations/type.rb
-- lib/servactory/maintenance/validations/object_schema.rb
 - lib/servactory/maintenance/validations/types.rb
 - lib/servactory/outputs/collection.rb
 - lib/servactory/outputs/dsl.rb
@@ -310,7 +309,9 @@ files:
 - lib/servactory/test_kit/rspec/matchers.rb
 - lib/servactory/test_kit/rspec/matchers/have_service_attribute_matchers/consists_of_matcher.rb
 - lib/servactory/test_kit/rspec/matchers/have_service_attribute_matchers/inclusion_matcher.rb
+- lib/servactory/test_kit/rspec/matchers/have_service_attribute_matchers/message_matcher.rb
 - lib/servactory/test_kit/rspec/matchers/have_service_attribute_matchers/must_matcher.rb
+- lib/servactory/test_kit/rspec/matchers/have_service_attribute_matchers/schema_matcher.rb
 - lib/servactory/test_kit/rspec/matchers/have_service_attribute_matchers/types_matcher.rb
 - lib/servactory/test_kit/rspec/matchers/have_service_input_matcher.rb
 - lib/servactory/test_kit/rspec/matchers/have_service_input_matchers/default_matcher.rb
@@ -326,6 +327,7 @@ files:
 - lib/servactory/tool_kit/dynamic_options/min.rb
 - lib/servactory/tool_kit/dynamic_options/multiple_of.rb
 - lib/servactory/tool_kit/dynamic_options/must.rb
+- lib/servactory/tool_kit/dynamic_options/schema.rb
 - lib/servactory/utils.rb
 - lib/servactory/version.rb
 homepage: https://github.com/servactory/servactory

data/lib/servactory/maintenance/validations/object_schema.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-module Servactory
-  module Maintenance
-    module Validations
-      class ObjectSchema
-        RESERVED_ATTRIBUTES = %i[type required default].freeze
-        private_constant :RESERVED_ATTRIBUTES
-
-        attr_reader :errors
-
-        def self.validate(...)
-          new(...).validate
-        end
-
-        def initialize(object:, schema:)
-          @object = object
-          @schema = schema.fetch(:is)
-
-          @errors = []
-        end
-
-        def validate
-          validate_for!(object: @object, schema: @schema)
-
-          self
-        end
-
-        def valid?
-          @errors.empty?
-        end
-
-        private
-
-        def validate_for!(object:, schema:, root_schema_key: nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-          unless object.respond_to?(:fetch)
-            add_error(key_name: root_schema_key, expected_type: Hash.name, given_type: object.class.name)
-            return
-          end
-
-          schema.each do |schema_key, schema_value|
-            attribute_type = schema_value.fetch(:type, String)
-
-            if attribute_type == Hash
-              validate_for!(
-                object: object.fetch(schema_key, {}),
-                schema: schema_value.except(*RESERVED_ATTRIBUTES),
-                root_schema_key: schema_key
-              )
-            else
-              is_success = validate_with(
-                object:,
-                schema_key:,
-                schema_value:,
-                attribute_type:,
-                attribute_required: schema_value.fetch(:required, true)
-              )
-
-              next if is_success
-
-              add_error(
-                key_name: schema_key,
-                expected_type: attribute_type,
-                given_type: object.fetch(schema_key, nil).class.name
-              )
-            end
-          end
-        end
-
-        def validate_with(object:, schema_key:, schema_value:, attribute_type:, attribute_required:) # rubocop:disable Metrics/MethodLength
-          unless should_be_checked_for?(
-            object:,
-            schema_key:,
-            schema_value:,
-            required: attribute_required
-          ) # do
-            return true
-          end
-
-          value = object.fetch(schema_key, nil)
-          prepared_value = prepare_value_from(schema_value:, value:, required: attribute_required)
-
-          Array(attribute_type).uniq.any? { |type| prepared_value.is_a?(type) }
-        end
-
-        def should_be_checked_for?(object:, schema_key:, schema_value:, required:)
-          required || (
-            !required && !fetch_default_from(schema_value).nil?
-          ) || (
-            !required && !object.fetch(schema_key, nil).nil?
-          )
-        end
-
-        def prepare_value_from(schema_value:, value:, required:)
-          if !required && !fetch_default_from(schema_value).nil? && value.blank?
-            fetch_default_from(schema_value)
-          else
-            value
-          end
-        end
-
-        def fetch_default_from(value)
-          value.fetch(:default, nil)
-        end
-
-        def add_error(key_name:, expected_type:, given_type:)
-          @errors << {
-            key_name:,
-            expected_type:,
-            given_type:
-          }
-        end
-      end
-    end
-  end
-end