servactory 2.1.0 → 2.2.0.rc1

data/lib/servactory/maintenance/attributes/translator/type.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Servactory
+  module Maintenance
+    module Attributes
+      module Translator
+        module Type
+          extend self
+
+          def default_message # rubocop:disable Metrics/MethodLength
+            lambda do |service_class_name:, attribute:, value:, key_name:, expected_type:, given_type:|
+              if attribute.collection_mode?
+                for_collection_mode_with(service_class_name: service_class_name, attribute: attribute, value: value,
+                                         expected_type: expected_type, given_type: given_type)
+              elsif attribute.hash_mode? && key_name.present?
+                for_hash_mode_with(service_class_name: service_class_name, attribute: attribute, key_name: key_name,
+                                   expected_type: expected_type, given_type: given_type)
+              else
+                for_others_with(service_class_name: service_class_name, attribute: attribute,
+                                expected_type: expected_type, given_type: given_type)
+              end
+            end
+          end
+
+          private
+
+          def for_collection_mode_with(service_class_name:, attribute:, value:, expected_type:, given_type:) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+            collection_message = attribute.consists_of.fetch(:message)
+
+            if collection_message.is_a?(Proc)
+              collection_message.call(
+                "#{attribute.system_name}_name": attribute.name,
+                expected_type: expected_type,
+                given_type: given_type
+              )
+            elsif collection_message.is_a?(String) && collection_message.present?
+              collection_message
+            elsif value.is_a?(attribute.types.fetch(0, Array))
+              I18n.t(
+                "servactory.#{attribute.i18n_name}.validations.type.default_error.for_collection.wrong_element_type",
+                service_class_name: service_class_name,
+                "#{attribute.system_name}_name": attribute.name,
+                expected_type: expected_type,
+                given_type: given_type
+              )
+            else
+              I18n.t(
+                "servactory.#{attribute.i18n_name}.validations.type.default_error.for_collection.wrong_type",
+                service_class_name: service_class_name,
+                "#{attribute.system_name}_name": attribute.name,
+                expected_type: attribute.types.fetch(0, Array),
+                given_type: value.class.name
+              )
+            end
+          end
+
+          def for_hash_mode_with(service_class_name:, attribute:, key_name:, expected_type:, given_type:) # rubocop:disable Metrics/MethodLength
+            hash_message = attribute.schema.fetch(:message)
+
+            if hash_message.is_a?(Proc)
+              hash_message.call(
+                "#{attribute.system_name}_name": attribute.name,
+                key_name: key_name,
+                expected_type: expected_type,
+                given_type: given_type
+              )
+            elsif hash_message.is_a?(String) && hash_message.present?
+              hash_message
+            else
+              I18n.t(
+                "servactory.#{attribute.i18n_name}.validations.type.default_error.for_hash.wrong_element_type",
+                service_class_name: service_class_name,
+                "#{attribute.system_name}_name": attribute.name,
+                key_name: key_name,
+                expected_type: expected_type,
+                given_type: given_type
+              )
+            end
+          end
+
+          def for_others_with(service_class_name:, attribute:, expected_type:, given_type:)
+            I18n.t(
+              "servactory.#{attribute.i18n_name}.validations.type.default_error.default",
+              service_class_name: service_class_name,
+              "#{attribute.system_name}_name": attribute.name,
+              expected_type: expected_type,
+              given_type: given_type
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/servactory/maintenance/attributes/validations/inclusion.rb

@@ -5,18 +5,6 @@ module Servactory
     module Attributes
       module Validations
         class Inclusion < Base
-          DEFAULT_MESSAGE = lambda do |service_class_name:, input:, value:|
-            I18n.t(
-              "servactory.#{input.i18n_name}.validations.inclusion.default_error",
-              service_class_name: service_class_name,
-              "#{input.system_name}_name": input.name,
-              input_inclusion: input.inclusion[:in],
-              value: value
-            )
-          end
-
-          private_constant :DEFAULT_MESSAGE
-
           def self.check(context:, attribute:, value:, check_key:, **)
             return unless should_be_checked_for?(attribute, value, check_key)
 
@@ -62,7 +50,7 @@ module Servactory
 
           def add_error_with(message)
             add_error(
-              message: message.presence || DEFAULT_MESSAGE,
+              message: message.presence || Servactory::Maintenance::Attributes::Translator::Inclusion.default_message,
               service_class_name: @context.class.name,
               "#{@attribute.system_name}": @attribute,
               value: @value

data/lib/servactory/maintenance/attributes/validations/must.rb

@@ -5,29 +5,6 @@ module Servactory
     module Attributes
       module Validations
         class Must < Base
-          DEFAULT_MESSAGE = lambda do |service_class_name:, input:, value:, code:|
-            I18n.t(
-              "servactory.#{input.i18n_name}.validations.must.default_error",
-              service_class_name: service_class_name,
-              "#{input.system_name}_name": input.name,
-              value: value,
-              code: code
-            )
-          end
-
-          SYNTAX_ERROR_MESSAGE = lambda do |service_class_name:, input:, value:, code:, exception_message:|
-            I18n.t(
-              "servactory.#{input.i18n_name}.validations.must.syntax_error",
-              service_class_name: service_class_name,
-              "#{input.system_name}_name": input.name,
-              value: value,
-              code: code,
-              exception_message: exception_message
-            )
-          end
-
-          private_constant :DEFAULT_MESSAGE, :SYNTAX_ERROR_MESSAGE
-
           def self.check(context:, attribute:, value:, check_key:, check_options:)
             return unless should_be_checked_for?(attribute, check_key)
 
@@ -68,9 +45,13 @@ module Servactory
 
             return if check.call(value: @value)
 
-            message.presence || DEFAULT_MESSAGE
+            message.presence || Servactory::Maintenance::Attributes::Translator::Must.default_message
           rescue StandardError => e
-            add_syntax_error_with(SYNTAX_ERROR_MESSAGE, code, e.message)
+            add_syntax_error_with(
+              Servactory::Maintenance::Attributes::Translator::Must.syntax_error_message,
+              code,
+              e.message
+            )
           end
 
           ########################################################################

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

@@ -10,10 +10,10 @@ module Servactory
           new(...).validate
         end
 
-        def initialize(attribute:, types:, value:)
-          @attribute = attribute
+        def initialize(types:, value:, consists_of:)
           @types = types
           @value = value
+          @consists_of = consists_of
 
           @errors = []
         end
@@ -28,7 +28,7 @@ module Servactory
             return self
           end
 
-          validate_value!
+          validate_for!(values: @value)
 
           self
         end
@@ -39,13 +39,21 @@ module Servactory
 
         private
 
-        def validate_value!
-          return if unnecessary_types.empty?
+        def validate_for!(values:) # rubocop:disable Metrics/MethodLength
+          values.each do |value|
+            value_type = value.class
 
-          add_error(
-            expected_type: attribute_consists_of_types.join(", "),
-            given_type: unnecessary_types.join(", ")
-          )
+            if value_type == Array
+              validate_for!(values: value)
+            else
+              next if attribute_consists_of_types.include?(value_type)
+
+              add_error(
+                expected_type: attribute_consists_of_types.join(", "),
+                given_type: value_type.name
+              )
+            end
+          end
         end
 
         ########################################################################
@@ -55,11 +63,7 @@ module Servactory
         end
 
         def attribute_consists_of_types
-          @attribute_consists_of_types ||= prepared_types_from(Array(@attribute.consists_of.fetch(:type, [])))
-        end
-
-        def unnecessary_types
-          @unnecessary_types ||= @value&.map(&:class)&.difference(attribute_consists_of_types).presence || []
+          @attribute_consists_of_types ||= prepared_types_from(Array(@consists_of.fetch(:type, [])))
         end
 
         def prepared_types_from(types)

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

@@ -21,7 +21,7 @@ module Servactory
         end
 
         def validate
-          validate_for(object: @object, schema: @schema)
+          validate_for!(object: @object, schema: @schema)
 
           self
         end
@@ -32,7 +32,7 @@ module Servactory
 
         private
 
-        def validate_for(object:, schema:, root_schema_key: nil) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        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
@@ -42,7 +42,7 @@ module Servactory
             attribute_type = schema_value.fetch(:type, String)
 
             if attribute_type == Hash
-              validate_for(
+              validate_for!(
                 object: object.fetch(schema_key, {}),
                 schema: schema_value.except(*RESERVED_ATTRIBUTES),
                 root_schema_key: schema_key

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

@@ -3,78 +3,7 @@
 module Servactory
   module Maintenance
     module Validations
-      class Types # rubocop:disable Metrics/ClassLength
-        DEFAULT_MESSAGE = lambda do | # rubocop:disable Metrics/BlockLength
-          service_class_name:,
-          attribute:,
-          value:,
-          key_name:,
-          expected_type:,
-          given_type:
-        | # do
-          if attribute.collection_mode?
-            collection_message = attribute.consists_of.fetch(:message)
-
-            if collection_message.is_a?(Proc)
-              collection_message.call(
-                "#{attribute.system_name}_name": attribute.name,
-                expected_type: expected_type,
-                given_type: given_type
-              )
-            elsif collection_message.is_a?(String) && collection_message.present?
-              collection_message
-            elsif value.is_a?(attribute.types.fetch(0, Array))
-              I18n.t(
-                "servactory.#{attribute.i18n_name}.validations.type.default_error.for_collection.wrong_element_type",
-                service_class_name: service_class_name,
-                "#{attribute.system_name}_name": attribute.name,
-                expected_type: expected_type,
-                given_type: given_type
-              )
-            else
-              I18n.t(
-                "servactory.#{attribute.i18n_name}.validations.type.default_error.for_collection.wrong_type",
-                service_class_name: service_class_name,
-                "#{attribute.system_name}_name": attribute.name,
-                expected_type: attribute.types.fetch(0, Array),
-                given_type: value.class.name
-              )
-            end
-          elsif attribute.hash_mode? && key_name.present?
-            hash_message = attribute.schema.fetch(:message)
-
-            if hash_message.is_a?(Proc)
-              hash_message.call(
-                "#{attribute.system_name}_name": attribute.name,
-                key_name: key_name,
-                expected_type: expected_type,
-                given_type: given_type
-              )
-            elsif hash_message.is_a?(String) && hash_message.present?
-              hash_message
-            else
-              I18n.t(
-                "servactory.#{attribute.i18n_name}.validations.type.default_error.for_hash.wrong_element_type",
-                service_class_name: service_class_name,
-                "#{attribute.system_name}_name": attribute.name,
-                key_name: key_name,
-                expected_type: expected_type,
-                given_type: given_type
-              )
-            end
-          else
-            I18n.t(
-              "servactory.#{attribute.i18n_name}.validations.type.default_error.default",
-              service_class_name: service_class_name,
-              "#{attribute.system_name}_name": attribute.name,
-              expected_type: expected_type,
-              given_type: given_type
-            )
-          end
-        end
-
-        private_constant :DEFAULT_MESSAGE
-
+      class Types
         def self.validate!(...)
           new(...).validate!
         end
@@ -93,9 +22,9 @@ module Servactory
 
           if @attribute.collection_mode?
             collection_validator = Servactory::Maintenance::Validations::Collection.validate(
-              attribute: @attribute,
               types: @types,
-              value: @value
+              value: @value,
+              consists_of: @attribute.consists_of
             )
 
             return if collection_validator.valid?
@@ -114,7 +43,7 @@ module Servactory
 
           if (first_error = collection_validator&.errors&.first).present?
             return @error_callback.call(
-              message: DEFAULT_MESSAGE,
+              message: Servactory::Maintenance::Attributes::Translator::Type.default_message,
               service_class_name: @context.class.name,
               attribute: @attribute,
               value: @value,
@@ -126,7 +55,7 @@ module Servactory
 
           if (first_error = object_schema_validator&.errors&.first).present?
             return @error_callback.call(
-              message: DEFAULT_MESSAGE,
+              message: Servactory::Maintenance::Attributes::Translator::Type.default_message,
               service_class_name: @context.class.name,
               attribute: @attribute,
               value: @value,
@@ -137,7 +66,7 @@ module Servactory
           end
 
           @error_callback.call(
-            message: DEFAULT_MESSAGE,
+            message: Servactory::Maintenance::Attributes::Translator::Type.default_message,
             service_class_name: @context.class.name,
             attribute: @attribute,
             value: @value,

data/lib/servactory/outputs/dsl.rb

@@ -16,11 +16,13 @@ module Servactory
 
         private
 
-        def output(name, **options)
+        def output(name, *helpers, **options)
           collection_of_outputs << Output.new(
             name,
+            *helpers,
             collection_mode_class_names: config.collection_mode_class_names,
             hash_mode_class_names: config.hash_mode_class_names,
+            option_helpers: config.output_option_helpers,
             **options
           )
         end

data/lib/servactory/outputs/output.rb

@@ -8,15 +8,18 @@ module Servactory
 
       def initialize(
         name,
+        *helpers,
         collection_mode_class_names:,
         hash_mode_class_names:,
+        option_helpers:,
         **options
       )
         @name = name
         @collection_mode_class_names = collection_mode_class_names
         @hash_mode_class_names = hash_mode_class_names
+        @option_helpers = option_helpers
 
-        register_options(options: options)
+        register_options(helpers: helpers, options: options)
       end
 
       def method_missing(name, *args, &block)
@@ -31,7 +34,9 @@ module Servactory
         @collection_of_options.names.include?(name) || super
       end
 
-      def register_options(options:) # rubocop:disable Metrics/MethodLength
+      def register_options(helpers:, options:) # rubocop:disable Metrics/MethodLength
+        options = apply_helpers_for_options(helpers: helpers, options: options) if helpers.present?
+
         options_registrar = Servactory::Maintenance::Attributes::Options::Registrar.register(
           attribute: self,
           collection_mode_class_names: @collection_mode_class_names,
@@ -40,13 +45,29 @@ module Servactory
           features: {
             types: true,
             collection: true,
-            hash: true
+            hash: true,
+            inclusion: true,
+            must: true
           }
         )
 
         @collection_of_options = options_registrar.collection
       end
 
+      def apply_helpers_for_options(helpers:, options:)
+        prepared_options = {}
+
+        helpers.each do |helper|
+          found_helper = @option_helpers.find_by(name: helper)
+
+          next if found_helper.blank?
+
+          prepared_options.merge!(found_helper.equivalent)
+        end
+
+        options.merge(prepared_options)
+      end
+
       def options_for_checks
         @collection_of_options.options_for_checks
       end

data/lib/servactory/result.rb

@@ -2,12 +2,25 @@
 
 module Servactory
   class Result
-    def self.success_for(...)
-      new(...).send(:as_success)
+    class Outputs
+      def initialize(outputs)
+        outputs.each_pair do |key, value|
+          define_singleton_method(:"#{key}?") { Servactory::Utils.query_attribute(value) }
+          define_singleton_method(key) { value }
+        end
+      end
     end
 
-    def self.failure_for(...)
-      new(...).send(:as_failure)
+    private_constant :Outputs
+
+    ############################################################################
+
+    def self.success_for(context:)
+      new(context: context).send(:as_success)
+    end
+
+    def self.failure_for(exception:)
+      new(exception: exception).send(:as_failure)
     end
 
     def initialize(context: nil, exception: nil)
@@ -19,15 +32,39 @@ module Servactory
       "#<#{self.class.name} #{draw_result}>"
     end
 
+    def on_success
+      yield(outputs: outputs) if success?
+
+      self
+    end
+
+    def on_failure(type = :all)
+      yield(exception: @exception) if failure? && [:all, @exception&.type].include?(type)
+
+      self
+    end
+
+    def method_missing(name, *_args)
+      super
+    rescue NoMethodError => e
+      rescue_no_method_error_with(exception: e)
+    end
+
+    def respond_to_missing?(*)
+      super
+    end
+
     private
 
     def as_success
       define_singleton_method(:success?) { true }
       define_singleton_method(:failure?) { false }
 
-      @context.send(:servactory_service_storage).fetch(:outputs).each_pair do |key, value|
-        define_singleton_method(:"#{key}?") { Servactory::Utils.query_attribute(value) }
-        define_singleton_method(key) { value }
+      outputs.methods(false).each do |method_name|
+        method_value = outputs.send(method_name)
+
+        define_singleton_method(:"#{method_name}?") { Servactory::Utils.query_attribute(method_value) }
+        define_singleton_method(method_name) { method_value }
       end
 
       self
@@ -37,7 +74,12 @@ module Servactory
       define_singleton_method(:error) { @exception }
 
       define_singleton_method(:success?) { false }
-      define_singleton_method(:failure?) { true }
+
+      define_singleton_method(:failure?) do |type = :all|
+        return true if [:all, @exception&.type].include?(type)
+
+        false
+      end
 
       self
     end
@@ -47,5 +89,25 @@ module Servactory
         "@#{method_name}=#{send(method_name)}"
       end.join(", ")
     end
+
+    def outputs
+      @outputs ||= Outputs.new(@context.send(:servactory_service_storage).fetch(:outputs))
+    end
+
+    ########################################################################
+
+    def rescue_no_method_error_with(exception:)
+      raise exception if @context.blank?
+
+      raise @context.class.config.failure_class.new(
+        type: :base,
+        message: I18n.t(
+          "servactory.common.undefined_method.missing_name",
+          service_class_name: @context.class.name,
+          method_name: exception.name,
+          missing_name: exception.missing_name.inspect
+        )
+      )
+    end
   end
 end

data/lib/servactory/utils.rb

@@ -4,6 +4,14 @@ module Servactory
   module Utils
     module_function
 
+    def define_attribute_with(input:, internal:, output:)
+      return input if input.present?
+      return internal if internal.present?
+      return output if output.present?
+
+      raise ArgumentError, "missing keyword: :input, :internal or :output"
+    end
+
     FALSE_VALUES = [
       false,
       nil, "",

data/lib/servactory/version.rb

@@ -3,9 +3,9 @@
 module Servactory
   module VERSION
     MAJOR = 2
-    MINOR = 1
+    MINOR = 2
     PATCH = 0
-    PRE = nil
+    PRE = "rc1"
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join(".")
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: servactory
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0.rc1
 platform: ruby
 authors:
 - Anton Sokolov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-18 00:00:00.000000000 Z
+date: 2024-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '5.1'
     - - "<"
       - !ruby/object:Gem::Version
         version: '7.2'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '5.1'
     - - "<"
       - !ruby/object:Gem::Version
         version: '7.2'
@@ -245,11 +245,12 @@ files:
 - lib/servactory/context/workspace/outputs.rb
 - lib/servactory/dsl.rb
 - lib/servactory/engine.rb
-- lib/servactory/errors/base.rb
 - lib/servactory/errors/failure.rb
 - lib/servactory/errors/input_error.rb
 - lib/servactory/errors/internal_error.rb
 - lib/servactory/errors/output_error.rb
+- lib/servactory/exceptions/base.rb
+- lib/servactory/exceptions/success.rb
 - lib/servactory/info/dsl.rb
 - lib/servactory/info/result.rb
 - lib/servactory/inputs/collection.rb
@@ -258,6 +259,7 @@ files:
 - lib/servactory/inputs/tools/rules.rb
 - lib/servactory/inputs/tools/unnecessary.rb
 - lib/servactory/inputs/tools/validation.rb
+- lib/servactory/inputs/translator/required.rb
 - lib/servactory/inputs/validations/base.rb
 - lib/servactory/inputs/validations/errors.rb
 - lib/servactory/inputs/validations/required.rb
@@ -274,6 +276,9 @@ files:
 - lib/servactory/maintenance/attributes/options_collection.rb
 - lib/servactory/maintenance/attributes/tools/check_errors.rb
 - lib/servactory/maintenance/attributes/tools/validation.rb
+- lib/servactory/maintenance/attributes/translator/inclusion.rb
+- lib/servactory/maintenance/attributes/translator/must.rb
+- lib/servactory/maintenance/attributes/translator/type.rb
 - lib/servactory/maintenance/attributes/validations/base.rb
 - lib/servactory/maintenance/attributes/validations/errors.rb
 - lib/servactory/maintenance/attributes/validations/inclusion.rb
@@ -317,7 +322,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.1
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: A set of tools for building reliable services of any complexity