convenient_service 0.23.0 → 0.25.0

data/lib/convenient_service/service/plugins/can_have_inline_services/entities/proxy.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveInlineServices
+        module Entities
+          ##
+          # @internal
+          #   TODO: Specs.
+          #
+          class Proxy
+            ##
+            # @param chain [Hash{Symbol => Object}]
+            # @param block [Proc, nil]
+            # @return [void]
+            #
+            def initialize(chain: {}, &block)
+              @chain = chain
+
+              if block
+                chain[:block] = block
+
+                define
+              end
+            end
+
+            ##
+            # @return [Boolean]
+            #
+            def defined?
+              chain.has_key?(:defined)
+            end
+
+            ##
+            # @return [Boolean]
+            #
+            def define
+              return false if self.defined?
+
+              klass.include config
+
+              variables.each_pair { |key, value| klass.define_method(key) { value } }
+
+              klass.class_exec(arguments, &block)
+
+              mark_as_defined!
+
+              true
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveInlineServices::Entities::Proxy]
+            #
+            def with_arguments(...)
+              assert_not_defined!
+
+              chain[:arguments] = Support::Arguments.new(...)
+
+              self
+            end
+
+            ##
+            # @param variables [Hash{Symbol => Object}]
+            # @return [ConvenientService::Service::Plugins::CanHaveInlineServices::Entities::Proxy]
+            #
+            def with_variables(**variables)
+              assert_not_defined!
+
+              chain[:variables] = variables
+
+              self
+            end
+
+            ##
+            # @param config [ConvenientService::Config]
+            # @return [ConvenientService::Service::Plugins::CanHaveInlineServices::Entities::Proxy]
+            #
+            def with_config(config)
+              assert_not_defined!
+
+              chain[:config] = config
+
+              self
+            end
+
+            ##
+            # @param block [Proc, nil]
+            # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+            #
+            def result(&block)
+              if block
+                assert_not_defined!
+
+                chain[:block] = block
+
+                define
+              end
+
+              klass.result
+            end
+
+            ##
+            # @param block [Proc, nil]
+            # @return [Class<ConvenientService::Service>]
+            #
+            def to_class(&block)
+              if block
+                assert_not_defined!
+
+                chain[:block] = block
+
+                define
+              end
+
+              klass
+            end
+
+            ##
+            # @return [Class<ConvenientService::Service>]
+            #
+            alias_method :service, :to_class
+
+            ##
+            # @param other [Object] Can be any type.
+            # @return [Boolean, nil]
+            #
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              return false if chain != other.chain
+
+              true
+            end
+
+            protected
+
+            ##
+            # @!attribute [r] value
+            #   @return [Hash{Symbol => Object}]
+            #
+            attr_reader :chain
+
+            private
+
+            ##
+            # @return [Class]
+            #
+            def klass
+              @klass ||= ::Class.new
+            end
+
+            ##
+            # @return [ConvenientService::Support::Arguments]
+            #
+            def arguments
+              chain[:arguments] || Support::Arguments.null_arguments
+            end
+
+            ##
+            # @return [Hash{Symbol => Object}]
+            #
+            def variables
+              chain[:variables] || {}
+            end
+
+            ##
+            # @return [ConvenientService::Config]
+            #
+            def config
+              chain[:config] || ::ConvenientService::Standard::Config
+            end
+
+            ##
+            # @return [Proc]
+            #
+            def block
+              chain[:block] || proc {}
+            end
+
+            ##
+            # @return [void]
+            # @raise [ConvenientService::Service::Plugins::CanHaveInlineServices::Exceptions::InlineServiceIsAlreadyDefined]
+            #
+            def assert_not_defined!
+              ::ConvenientService.raise Exceptions::InlineServiceIsAlreadyDefined if self.defined?
+            end
+
+            ##
+            # @return [void]
+            #
+            def mark_as_defined!
+              chain[:defined] = true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/{can_have_steps/entities/step/plugins/can_be_completed.rb → can_have_inline_services/entities.rb}

@@ -5,4 +5,4 @@
 # @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
 ##
 
-require_relative "can_be_completed/concern"
+require_relative "entities/proxy"

data/lib/convenient_service/service/plugins/can_have_inline_services/exceptions.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveInlineServices
+        module Exceptions
+          class InlineServiceIsAlreadyDefined < ::ConvenientService::Exception
+            ##
+            # @param object [Object] Can be any type.
+            # @return [void]
+            #
+            def initialize_with_kwargs(object:)
+              message = <<~TEXT
+                Definition of already defined inline service can NOT be modified.
+              TEXT
+
+              initialize(message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/can_have_inline_services.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+require_relative "can_have_inline_services/concern"
+require_relative "can_have_inline_services/entities"
+require_relative "can_have_inline_services/exceptions"
+
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveInlineServices
+        class << self
+          ##
+          # @api private
+          # @param block [Proc, nil]
+          # @return [ConvenientService::Service::Plugins::CanHaveInlineServices::Entities::Proxy]
+          #
+          def proxy(&block)
+            Entities::Proxy.new(&block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/can_have_sequential_steps/concern.rb

@@ -22,6 +22,8 @@ module ConvenientService
             # @param kwargs [Hash{Symbol => Object}]
             # @return [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step]
             #
+            # @see https://userdocs.convenientservice.org/comprehensive_docs/docs/best_practices/declare_in_out_explicitly_on_method_steps.html
+            #
             def step(*args, **kwargs)
               steps.create(*args, **kwargs)
             end

data/lib/convenient_service/service/plugins/can_have_sequential_steps/middleware.rb

@@ -52,11 +52,7 @@ module ConvenientService
           #   Do NOT spend too much time on that again, you have a lot of other tasks to do.
           #
           def find_first_not_successful_step_with_side_effects_during_lookup
-            entity.steps.find do |step|
-              step.status.unsafe_not_success?
-                .tap { step.save_outputs_in_organizer! }
-                .tap { step.mark_as_evaluated! }
-            end
+            entity.steps.find { |step| step.organizer_result.status.unsafe_not_success? }
           end
 
           ##

data/lib/convenient_service/service/plugins/can_have_steps/concern.rb

@@ -24,13 +24,8 @@ module ConvenientService
             ##
             # @api public
             #
-            # Allows to pass a value to `in` method without its intermediate processing.
             # @see https://userdocs.convenientservice.org/basics/step_to_result_translation_table
-            #
-            # @example `:chat_v2` is passed to `AssertFeatureEnabled` as it is.
-            #   step AssertFeatureEnabled, in: {name: raw(:chat_v2)}
-            #   # that is converted to the following service invocation:
-            #   AssertFeatureEnabled.result(name: :chat_v2)
+            # @see https://userdocs.convenientservice.org/comprehensive_docs/docs/the_what/what_is_a_step_raw_input.html
             #
             # @param value [Object] Can be any type.
             # @return [ConvenientService::Support::RawValue]

data/lib/convenient_service/service/plugins/can_have_steps/entities/method/commands/cast_method_factory.rb

@@ -27,7 +27,7 @@ module ConvenientService
                 end
 
                 ##
-                # @return [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Entities::Factries::Base, nil]
+                # @return [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Entities::Factories::Base, nil]
                 #
                 def call
                   return unless factory_class
@@ -59,28 +59,25 @@ module ConvenientService
                 end
 
                 ##
-                # @return [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Entities::Factries::Base, nil]
+                # @return [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Entities::Factories::Base, nil]
                 #
                 def cast_symbol
                   Entities::Factories::Symbol
                 end
 
                 ##
-                # @return [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Entities::Factries::Base, nil]
+                # @return [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Entities::Factories::Base, nil]
                 #
                 def cast_string
                   Entities::Factories::String
                 end
 
                 ##
-                # @return [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Entities::Factries::Base, nil]
+                # @return [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Entities::Factories::Base, nil]
                 #
                 def cast_hash
                   return unless other.keys.one?
 
-                  ##
-                  # TODO: Add `other.keys.first.is_a?(Integer)` and `other.keys.first == Support::BLOCK` to support args and block via `step`?
-                  #
                   value = other.values.first
 
                   case value
@@ -96,7 +93,7 @@ module ConvenientService
                 end
 
                 ##
-                # @return [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Entities::Factries::Base, nil]
+                # @return [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Entities::Factories::Base, nil]
                 #
                 def cast_method
                   Entities::Factories::Method

data/lib/convenient_service/service/plugins/can_have_steps/entities/method/entities/callers/proc.rb

@@ -26,7 +26,7 @@ module ConvenientService
                   end
 
                   def define_output_in_container!(container, index:, method:)
-                    false
+                    Commands::DefineMethodInContainer.call(method: method, container: container, index: index)
                   end
 
                   private

data/lib/convenient_service/service/plugins/can_have_steps/entities/method/entities/callers/raw.rb

@@ -26,7 +26,7 @@ module ConvenientService
                   end
 
                   def define_output_in_container!(container, index:, method:)
-                    false
+                    Commands::DefineMethodInContainer.call(method: method, container: container, index: index)
                   end
 
                   private

data/lib/convenient_service/service/plugins/can_have_steps/entities/method/entities/factories/string.rb

@@ -18,7 +18,7 @@ module ConvenientService
                   # @return [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Method::Entities::Key]
                   #
                   def create_key
-                    Entities::Key.new(other)
+                    Entities::Key.new(other.to_sym)
                   end
 
                   ##

data/lib/convenient_service/service/plugins/can_have_steps/entities/method/entities/key.rb

@@ -25,7 +25,7 @@ module ConvenientService
                 ##
                 # @return [String]
                 #
-                delegate :to_s, :to_sym, to: :value
+                delegate :to_s, to: :value
 
                 ##
                 # @return [Symbol]

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/concern/instance_methods.rb

@@ -174,6 +174,19 @@ module ConvenientService
                   @organizer
                 end
 
+                ##
+                # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+                #
+                def organizer_result
+                  original_result = result
+
+                  save_outputs_in_organizer!
+
+                  mark_as_evaluated!
+
+                  original_result
+                end
+
                 ##
                 # @api public
                 #

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/plugins/{can_be_completed → can_be_evaluated}/concern.rb

@@ -12,7 +12,7 @@ module ConvenientService
         module Entities
           class Step
             module Plugins
-              module CanBeCompleted
+              module CanBeEvaluated
                 module Concern
                   include Support::Concern
 

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/plugins/can_be_evaluated.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+require_relative "can_be_evaluated/concern"

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/plugins.rb

@@ -7,7 +7,7 @@
 
 require_relative "plugins/has_result"
 
-require_relative "plugins/can_be_completed"
+require_relative "plugins/can_be_evaluated"
 require_relative "plugins/can_be_service_step"
 require_relative "plugins/can_be_method_step"
 require_relative "plugins/can_be_used_in_service_aware_enumerables"

data/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_from_exception/concern.rb

@@ -22,8 +22,8 @@ module ConvenientService
                     #
                     # @return [Boolean]
                     #
-                    def from_unhandled_exception?
-                      Utils.to_bool(unhandled_exception)
+                    def from_exception?
+                      Utils.to_bool(exception)
                     end
 
                     ##
@@ -31,8 +31,8 @@ module ConvenientService
                     #
                     # @return [StandardError, nil]
                     #
-                    def unhandled_exception
-                      extra_kwargs[:unhandled_exception]
+                    def exception
+                      extra_kwargs[:exceptions]&.values&.first
                     end
                   end
                 end

data/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_from_handled_exception/concern.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasJSendResult
+        module Entities
+          class Result
+            module Plugins
+              module CanBeFromHandledException
+                module Concern
+                  include Support::Concern
+
+                  instance_methods do
+                    ##
+                    # @api public
+                    #
+                    # @return [Boolean]
+                    #
+                    def from_handled_exception?
+                      Utils.to_bool(handled_exception)
+                    end
+
+                    ##
+                    # @api public
+                    #
+                    # @return [StandardError, nil]
+                    #
+                    def handled_exception
+                      extra_kwargs.dig(:exceptions, :handled)
+                    end
+
+                    def from_exception(exception, **kwargs)
+                      ::ConvenientService.raise Exceptions::FromExceptionOnNotErrorResult.new(result: self) unless status.unsafe_error?
+                      data =
+                        if Service::Plugins::HasJSendResult.default_error_data == unsafe_data.to_h
+                          {handled_exception: exception}
+                        else
+                          unsafe_data
+                        end
+
+                      message =
+                        if Service::Plugins::HasJSendResult.default_error_message == unsafe_message.to_s
+                          Service::Plugins::CanHaveFormattedExceptions.format_exception(exception, **kwargs)
+                        else
+                          unsafe_message
+                        end
+
+                      code =
+                        if Service::Plugins::HasJSendResult.default_error_code == unsafe_code.to_sym
+                          :handled_exception
+                        else
+                          unsafe_code
+                        end
+
+                      copy(
+                        overrides: {
+                          kwargs: {
+                            data: data,
+                            message: message,
+                            code: code,
+                            exceptions: {handled: exception}
+                          }
+                        }
+                      )
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_from_handled_exception/exceptions.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasJSendResult
+        module Entities
+          class Result
+            module Plugins
+              module CanBeFromHandledException
+                module Exceptions
+                  class FromExceptionOnNotErrorResult < ::ConvenientService::Exception
+                    ##
+                    # @param result [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+                    # @return [void]
+                    #
+                    def initialize_with_kwargs(result:)
+                      message = <<~TEXT
+                        `#{result.status}(...).from_exception(exception, ...)` is NOT allowed. Only `error` results can be from exceptions.
+                      TEXT
+
+                      initialize(message)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_from_handled_exception.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+require_relative "can_be_from_handled_exception/concern"
+require_relative "can_be_from_handled_exception/exceptions"

data/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_from_unhandled_exception/concern.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasJSendResult
+        module Entities
+          class Result
+            module Plugins
+              module CanBeFromUnhandledException
+                module Concern
+                  include Support::Concern
+
+                  instance_methods do
+                    ##
+                    # @api public
+                    #
+                    # @return [Boolean]
+                    #
+                    def from_unhandled_exception?
+                      Utils.to_bool(unhandled_exception)
+                    end
+
+                    ##
+                    # @api public
+                    #
+                    # @return [StandardError, nil]
+                    #
+                    def unhandled_exception
+                      extra_kwargs.dig(:exceptions, :unhandled)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_from_unhandled_exception.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+require_relative "can_be_from_unhandled_exception/concern"

data/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins.rb

@@ -11,6 +11,8 @@ require_relative "plugins/can_be_strict"
 require_relative "plugins/can_be_from_fallback"
 require_relative "plugins/can_have_fallbacks"
 require_relative "plugins/can_be_from_exception"
+require_relative "plugins/can_be_from_handled_exception"
+require_relative "plugins/can_be_from_unhandled_exception"
 require_relative "plugins/can_be_own_result"
 require_relative "plugins/can_be_stubbed_result"
 require_relative "plugins/can_be_used_in_service_aware_enumerables"