convenient_service 0.21.0 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc0b70a8a73f6bffd654e90e8ad332f0132b7ea83255ad56860c6e3ac454492c
-  data.tar.gz: e9be9fdaf668c6fdd510b27af3a04b9fa01582891478c95cab72320236926939
+  metadata.gz: 1c8f0f45805d314b21afa5fdafc59cb20a5bdfb3d1bd2805b4cdab85953229c9
+  data.tar.gz: b92a6f6ea00c8ea45d328d667d6612dfe4f9d884ee227fbb66eb83907518a06b
 SHA512:
-  metadata.gz: 372f4e96c265835df11321a7e30e2a8aaf5544ab6fea1d9b89084e4f1687a6399dbb72bea80b730fab31c5bc44722e0647260e717f518201c36a5e575f2cf074
-  data.tar.gz: 84852e20f09454a0181fc1438205f4ef446aba65d86c3c391838f4b340eb31546fe7e2bdd226da8bfc94c9d2ef80bf5e23c884d00282ef966c5384840f79e207
+  metadata.gz: 1154d803aeca510b922a468eb816a5d26d8c2ac12d089b744f491969f2b1d6ace8f2b98ba183585aca5a28d2c31b5cab993970fedea6ddffa9fd9ef1a77a1acc
+  data.tar.gz: 71a5f43b90cf24bad64bdf6de40dc4087f36e505c7781e1c563cdf42b411056b32d94b96ce44496d3b6bfa2f8b290c5b5392a56420881f58ff60e20963372c1a

data/lib/convenient_service/dependencies/built_in.rb

@@ -15,14 +15,19 @@
 #   - https://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Lint/RedundantRequireStatement
 ##
 
+##
+# NOTE: Dependencies must be kept in sync with `convenient_service.gemspec`.
+##
+
 ##
 # @internal
-#   - https://ruby-doc.org/stdlib-2.7.0/libdoc/pathname/rdoc/Pathname.html
-#   - https://github.com/ruby/pathname
+#   - https://ruby-doc.org/stdlib-2.7.0/libdoc/rubygems/rdoc/Gem/Version.html
+#   - https://github.com/rubygems/rubygems
+#   - https://github.com/rubygems/rubygems/blob/master/lib/rubygems/version.rb
 #
 # @!visibility private
 #
-require "pathname"
+require "rubygems"
 
 ##
 # @internal
@@ -44,13 +49,21 @@ require "logger"
 
 ##
 # @internal
-#   - https://ruby-doc.org/stdlib-2.7.0/libdoc/rubygems/rdoc/Gem/Version.html
-#   - https://github.com/rubygems/rubygems
-#   - https://github.com/rubygems/rubygems/blob/master/lib/rubygems/version.rb
+#   - https://ruby-doc.org/stdlib-2.7.0/libdoc/pathname/rdoc/Pathname.html
+#   - https://github.com/ruby/pathname
 #
 # @!visibility private
 #
-require "rubygems"
+require "pathname"
+
+##
+# @internal
+#   - https://ruby-doc.org/stdlib-2.7.0/libdoc/set/rdoc/Set.html
+#   - https://github.com/ruby/set
+#
+# @!visibility private
+#
+require "set"
 
 ##
 # @internal
@@ -71,12 +84,3 @@ require "singleton"
 # rubocop:disable Lint/RedundantRequireStatement
 require "thread"
 # rubocop:enable Lint/RedundantRequireStatement
-
-##
-# @internal
-#   - https://ruby-doc.org/stdlib-2.7.0/libdoc/set/rdoc/Set.html
-#   - https://github.com/ruby/set
-#
-# @!visibility private
-#
-require "set"

data/lib/convenient_service/service/configs/standard.rb

@@ -219,6 +219,7 @@ module ConvenientService
               use ConvenientService::Plugins::Result::CanHaveStep::Concern if options.enabled?(:essential)
               use ConvenientService::Plugins::Result::CanBeCalled::Concern if options.enabled?(:essential)
               use ConvenientService::Plugins::Result::CanBeStrict::Concern if options.enabled?(:essential)
+              use ConvenientService::Plugins::Result::CanHaveModifiedData::Concern if options.enabled?(:essential)
               use ConvenientService::Plugins::Result::HasNegatedResult::Concern if options.enabled?(:essential)
               use ConvenientService::Plugins::Result::HasPatternMatchingSupport::Concern if options.enabled?(:essential)
               use ConvenientService::Plugins::Result::CanBeFromFallback::Concern if options.enabled?(:fallbacks)

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

@@ -13,6 +13,14 @@ module ConvenientService
           include Support::Concern
 
           class_methods do
+            ##
+            # @api public
+            # @return [ConvenientService::Support::UniqueValue]
+            #
+            def block
+              Support::BLOCK
+            end
+
             ##
             # @api public
             #

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

@@ -177,14 +177,11 @@ module ConvenientService
                 ##
                 # @api public
                 #
-                # @return [Hash{Symbol => Object}]
+                # @return [ConvenientService::Support::Arguments]
                 # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
                 #
-                # @internal
-                #   TODO: Refactor to `input_arguments` to support args and block via `step`?
-                #
-                def input_values
-                  @input_values ||= calculate_input_values
+                def input_arguments
+                  @input_arguments ||= calculate_input_arguments
                 end
 
                 ##
@@ -329,14 +326,31 @@ module ConvenientService
                 private
 
                 ##
-                # @return [Hash{Symbol => Object}]
+                # @return [ConvenientService::Support::Arguments]
                 # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Exceptions::StepHasNoOrganizer]
                 #
                 # @internal
-                #   TODO: Commands instead of private methods.
-                #
-                def calculate_input_values
-                  inputs.reduce({}) { |values, input| values.merge(input.key.to_sym => input.value) }
+                #   TODO: Refactor `inputs` array to `inputs` collection.
+                #
+                def calculate_input_arguments
+                  arguments = Support::Arguments.new
+
+                  inputs.each do |input|
+                    key = input.key.value
+
+                    case key
+                    when ::Symbol
+                      arguments.kwargs[key] = input.value
+                    when ::Integer
+                      arguments.args[key] = input.value
+                    when Support::BLOCK
+                      arguments.block = input.value
+                    else
+                      ::ConvenientService.raise Exceptions::UnsupportedKeyType.new(key: key, step: self)
+                    end
+                  end
+
+                  arguments
                 end
 
                 ##

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

@@ -42,6 +42,23 @@ module ConvenientService
                   initialize(message)
                 end
               end
+
+              class UnsupportedKeyType < ::ConvenientService::Exception
+                ##
+                # @param key [Symbol]
+                # @param step [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step]
+                # @return [void]
+                #
+                def initialize_with_kwargs(key:, step:)
+                  message = <<~TEXT
+                    Input key `#{key.inspect}` of step `#{step.printable_action}` has unsupported type `#{key.class}`.
+
+                    Maybe there is a typo in `in` definition?
+                  TEXT
+
+                  initialize(message)
+                end
+              end
             end
           end
         end

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/plugins/can_be_method_step/commands/calculate_method_result.rb

@@ -46,14 +46,11 @@ module ConvenientService
                     # @param method [Method]
                     # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
                     #
+                    # @internal
+                    #   TODO: Extract loose arguments from own method, but call regular method. This way middlewares can be applied to method steps.
+                    #
                     def call_method(method)
-                      params = Support::MethodParameters.new(method.parameters)
-
-                      return method.call(**input_values) if params.has_rest_kwargs?
-
-                      return method.call(**input_values.slice(*params.named_kwargs_keys)) if params.named_kwargs_keys.any?
-
-                      method.call
+                      Utils::Method.loose_call(method, *input_arguments.args, **input_arguments.kwargs, &input_arguments.block)
                     end
 
                     ##
@@ -81,10 +78,10 @@ module ConvenientService
                     end
 
                     ##
-                    # @return [Hash{Symbol => Object}]
+                    # @return [ConvenientService::Support::Arguments]
                     #
-                    def input_values
-                      @input_values ||= step.input_values
+                    def input_arguments
+                      @input_arguments ||= step.input_arguments
                     end
                   end
                 end

data/lib/convenient_service/service/plugins/can_have_steps/entities/step/plugins/can_be_service_step/commands/calculate_service_result.rb

@@ -33,13 +33,10 @@ module ConvenientService
                     # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
                     # @raise [ConvenientService::Service::Plugins::CanHaveSteps::Entities::Step::Plugins::CanBeMethodStep::Exceptions::StepIsNotServiceStep]
                     #
-                    # @internal
-                    #   IMPORTANT: `service.result(**input_values)` is the reason, why services should have only kwargs as arguments.
-                    #
                     def call
                       ::ConvenientService.raise Exceptions::StepIsNotServiceStep.new(step: step) unless step.service_step?
 
-                      service.result(**input_values)
+                      service.result(*input_arguments.args, **input_arguments.kwargs, &input_arguments.block)
                     end
 
                     private
@@ -52,10 +49,10 @@ module ConvenientService
                     end
 
                     ##
-                    # @return [Hash{Symbol => Object}]
+                    # @return [ConvenientService::Support::Arguments]
                     #
-                    def input_values
-                      @input_values ||= step.input_values
+                    def input_arguments
+                      @input_arguments ||= step.input_arguments
                     end
                   end
                 end

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

@@ -0,0 +1,109 @@
+# 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 CanHaveModifiedData
+                module Concern
+                  include Support::Concern
+
+                  instance_methods do
+                    ##
+                    # @api public
+                    #
+                    # @param keys [Array<Symbol>]
+                    # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+                    #
+                    def with_only_keys(*keys)
+                      return self if status.unsafe_not_success?
+                      return self if keys.empty?
+
+                      data_with_only_keys =
+                        keys.each_with_object({}) do |key, data_with_only_keys|
+                          if unsafe_data.__has_attribute__?(key)
+                            data_with_only_keys[key] = unsafe_data[key]
+                          else
+                            ::ConvenientService.raise Exceptions::NotExistingAttributeForOnly.new(key: key)
+                          end
+                        end
+
+                      copy(overrides: {kwargs: {data: data_with_only_keys}})
+                    end
+
+                    ##
+                    # @api public
+                    #
+                    # @param keys [Array<Symbol>]
+                    # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+                    #
+                    def with_except_keys(*keys)
+                      return self if status.unsafe_not_success?
+                      return self if keys.empty?
+
+                      data_with_except_keys =
+                        keys.each_with_object(unsafe_data.to_h.dup) do |key, data_with_except_keys|
+                          if unsafe_data.__has_attribute__?(key)
+                            data_with_except_keys.delete(key)
+                          else
+                            ::ConvenientService.raise Exceptions::NotExistingAttributeForExcept.new(key: key)
+                          end
+                        end
+
+                      copy(overrides: {kwargs: {data: data_with_except_keys}})
+                    end
+
+                    ##
+                    # @api public
+                    #
+                    # @param renamings [Hash{Symbol => Symbol}]
+                    # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+                    #
+                    def with_renamed_keys(**renamings)
+                      return self if status.unsafe_not_success?
+                      return self if renamings.empty?
+
+                      data_with_renamed_keys =
+                        renamings.each_with_object(unsafe_data.to_h.dup) do |(key, renamed_key), data_with_renamed_keys|
+                          if unsafe_data.__has_attribute__?(key)
+                            data_with_renamed_keys[renamed_key] = data_with_renamed_keys.delete(key)
+                          else
+                            ::ConvenientService.raise Exceptions::NotExistingAttributeForRename.new(key: key, renamed_key: renamed_key)
+                          end
+                        end
+
+                      copy(overrides: {kwargs: {data: data_with_renamed_keys}})
+                    end
+
+                    ##
+                    # @api public
+                    #
+                    # @param values [Hash{Symbol => Object}]
+                    # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+                    #
+                    def with_extra_keys(**values)
+                      return self if status.unsafe_not_success?
+                      return self if values.empty?
+
+                      data_with_extra_keys = unsafe_data.to_h.merge(values)
+
+                      copy(overrides: {kwargs: {data: data_with_extra_keys}})
+                    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_have_modified_data/exceptions.rb

@@ -0,0 +1,66 @@
+# 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 CanHaveModifiedData
+                module Exceptions
+                  class NotExistingAttributeForOnly < ::ConvenientService::Exception
+                    ##
+                    # @param key [Symbol]
+                    # @return [void]
+                    #
+                    def initialize_with_kwargs(key:)
+                      message = <<~TEXT
+                        Data attribute by key `:#{key}` does NOT exist. That is why it can NOT be selected. Make sure the corresponding result has it.
+                      TEXT
+
+                      initialize(message)
+                    end
+                  end
+
+                  class NotExistingAttributeForExcept < ::ConvenientService::Exception
+                    ##
+                    # @param key [Symbol]
+                    # @return [void]
+                    #
+                    def initialize_with_kwargs(key:)
+                      message = <<~TEXT
+                        Data attribute by key `:#{key}` does NOT exist. That is why it can NOT be dropped. Make sure the corresponding result has it.
+                      TEXT
+
+                      initialize(message)
+                    end
+                  end
+
+                  class NotExistingAttributeForRename < ::ConvenientService::Exception
+                    ##
+                    # @param key [Symbol]
+                    # @return [void]
+                    #
+                    def initialize_with_kwargs(key:, renamed_key:)
+                      message = <<~TEXT
+                        Data attribute by key `:#{key}` does NOT exist. That is why it can NOT be renamed to `:#{renamed_key}`. Make sure the corresponding result has it.
+                      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_have_modified_data.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_have_modified_data/concern"
+require_relative "can_have_modified_data/exceptions"

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

@@ -13,6 +13,7 @@ require_relative "plugins/can_have_fallbacks"
 require_relative "plugins/can_be_from_exception"
 require_relative "plugins/can_be_own_result"
 require_relative "plugins/can_be_stubbed_result"
+require_relative "plugins/can_have_modified_data"
 require_relative "plugins/has_j_send_status_and_attributes"
 require_relative "plugins/has_inspect"
 require_relative "plugins/has_pattern_matching_support"

data/lib/convenient_service/support/arguments/null_arguments/exceptions.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Support
+    class Arguments
+      class NullArguments < Support::Arguments
+        module Exceptions
+          class BlockSetIsNotAllowed < ::ConvenientService::Exception
+            ##
+            # @return [void]
+            #
+            def initialize_without_arguments
+              message = <<~TEXT
+                Setting a block to null arguments is NOT allowed.
+
+                Consider to create a new arguments object and set block to it instead.
+              TEXT
+
+              initialize(message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/arguments/null_arguments.rb

@@ -5,6 +5,8 @@
 # @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
 ##
 
+require_relative "null_arguments/exceptions"
+
 module ConvenientService
   module Support
     class Arguments
@@ -16,17 +18,36 @@ module ConvenientService
         # @return [void]
         #
         def initialize
-          @args = []
-          @kwargs = {}
+          @args = [].freeze
+          @kwargs = {}.freeze
           @block = nil
         end
 
+        ##
+        # @param other_block [Proc, nil]
+        #
+        def block=(other_block)
+          ::ConvenientService.raise Exceptions::BlockSetIsNotAllowed.new
+        end
+
         ##
         # @return [Boolean]
         #
         def null_arguments?
           true
         end
+
+        ##
+        # @return [Boolean]
+        #
+        alias_method :nil_arguments?, :null_arguments?
+
+        ##
+        # @return [ConvenientService::Support::Arguments]
+        #
+        def to_arguments
+          ConvenientService::Support::Arguments.new
+        end
       end
     end
   end

data/lib/convenient_service/support/arguments.rb

@@ -13,22 +13,28 @@ module ConvenientService
     class Arguments
       ##
       # @!attribute [r] args
-      #   @return [Array]
+      #   @return [Array<Object>]
       #
       attr_reader :args
 
       ##
       # @!attribute [r] kwargs
-      #   @return [Hash]
+      #   @return [Hash{Symbol => Object}]
       #
       attr_reader :kwargs
 
       ##
       # @!attribute [r] block
-      #   @return [Proc]
+      #   @return [Proc, nil]
       #
       attr_reader :block
 
+      ##
+      # @!attribute [w] block
+      #   @return [Proc, nil]
+      #
+      attr_writer :block
+
       ##
       # @param args [Array<Object>]
       # @param kwargs [Hash{Symbol => Object}]
@@ -48,6 +54,11 @@ module ConvenientService
         def null_arguments
           @null_arguments ||= Support::Arguments::NullArguments.new
         end
+
+        ##
+        # @return [ConvenientService::Support::Arguments::NullArguments]
+        #
+        alias_method :nil_arguments, :null_arguments
       end
 
       ##
@@ -57,6 +68,11 @@ module ConvenientService
         false
       end
 
+      ##
+      # @return [Boolean]
+      #
+      alias_method :nil_arguments?, :null_arguments?
+
       ##
       # @return [Booleam]
       #
@@ -137,6 +153,13 @@ module ConvenientService
           end
         end
       end
+
+      ##
+      # @return [ConvenientService::Support::Arguments]
+      #
+      def to_arguments
+        self
+      end
     end
   end
 end

data/lib/convenient_service/support/block.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Support
+    class Block < Support::UniqueValue; end
+
+    ##
+    # @return [ConvenientService::Support::UniqueValue]
+    #
+    BLOCK = Support::Block.new("block")
+  end
+end

data/lib/convenient_service/support/cache/entities/caches/array.rb

@@ -142,7 +142,11 @@ module ConvenientService
             # @return [Object] Can be any type.
             #
             def default=(value)
-              save_self_as_scope_in_parent!
+              if value.nil?
+                delete_self_as_scope_in_parent! if store.empty?
+              else
+                save_self_as_scope_in_parent!
+              end
 
               @default = value
             end

data/lib/convenient_service/support/cache/entities/caches/hash.rb

@@ -147,7 +147,11 @@ module ConvenientService
             # @return [Object] Can be any type.
             #
             def default=(value)
-              save_self_as_scope_in_parent!
+              if value.nil?
+                delete_self_as_scope_in_parent! if store.empty?
+              else
+                save_self_as_scope_in_parent!
+              end
 
               store.default = value
 

data/lib/convenient_service/support/not_passed.rb

@@ -7,15 +7,7 @@
 
 module ConvenientService
   module Support
-    class NotPassed < Support::UniqueValue
-      ##
-      # @param value [Object] Can be any type.
-      # @return [Boolean]
-      #
-      def [](value)
-        equal?(value)
-      end
-    end
+    class NotPassed < Support::UniqueValue; end
 
     ##
     # @return [ConvenientService::Support::UniqueValue]

data/lib/convenient_service/support/undefined.rb

@@ -7,15 +7,7 @@
 
 module ConvenientService
   module Support
-    class Undefined < Support::UniqueValue
-      ##
-      # @param value [Object] Can be any type.
-      # @return [Boolean]
-      #
-      def [](value)
-        equal?(value)
-      end
-    end
+    class Undefined < Support::UniqueValue; end
 
     ##
     # @return [ConvenientService::Support::UniqueValue]

data/lib/convenient_service/support/unique_value.rb

@@ -22,6 +22,14 @@ module ConvenientService
         @label = label
       end
 
+      ##
+      # @param value [Object] Can be any type.
+      # @return [Boolean]
+      #
+      def [](value)
+        equal?(value)
+      end
+
       ##
       # @param other [Object] Can be any type.
       # @return [Boolean, nil]

data/lib/convenient_service/support.rb

@@ -11,6 +11,7 @@ require_relative "support/unique_value"
 require_relative "support/not_passed"
 require_relative "support/undefined"
 require_relative "support/never_reach_here"
+require_relative "support/block"
 
 require_relative "support/concern"
 
@@ -25,7 +26,6 @@ require_relative "support/counter"
 require_relative "support/delegate"
 require_relative "support/dependency_container"
 require_relative "support/finite_loop"
-require_relative "support/method_parameters"
 require_relative "support/middleware"
 require_relative "support/raw_value"
 require_relative "support/safe_method"

data/lib/convenient_service/utils/method/loose_call.rb

@@ -0,0 +1,340 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Utils
+    module Method
+      class LooseCall < Support::Command
+        ##
+        # @example All possible parameters values in Ruby 2.7.
+        #   class Example
+        #     def m1(); end
+        #     def m2(a); end
+        #     def m3(a = 0); end
+        #     def m4(a, b); end
+        #     def m5(a, b = 1); end
+        #     def m6(a = 0, b = 1); end
+        #     def m7(*args); end
+        #     def m8(a:); end
+        #     def m9(a: 0); end
+        #     def m10(a:, b:); end
+        #     def m11(a:, b: 1); end
+        #     def m12(a: 0, b: 1); end
+        #     def m13(**kwargs); end
+        #     def m14(&block); end
+        #   end
+        #
+        #   object = Example.new
+        #
+        #   # def m1(); end
+        #   p object.method(:m1).parameters
+        #   # => []
+        #
+        #   # def m2(a); end
+        #   p object.method(:m2).parameters
+        #   # => [[:req, :a]]
+        #
+        #   # def m3(a = 0); end
+        #   p object.method(:m3).parameters
+        #   # => [[:opt, :a]]
+        #
+        #   # def m4(a, b); end
+        #   p object.method(:m4).parameters
+        #   # => [[:req, :a], [:req, :b]]
+        #
+        #   # def m5(a, b = 1); end
+        #   p object.method(:m5).parameters
+        #   # => [[:req, :a], [:opt, :b]]
+        #
+        #   # def m6(a = 0, b = 1); end
+        #   p object.method(:m6).parameters
+        #   # => [[:opt, :a], [:opt, :b]]
+        #
+        #   # def m7(*args); end
+        #   p object.method(:m7).parameters
+        #   # => [[:rest, :args]]
+        #
+        #   # def m8(a:); end
+        #   p object.method(:m8).parameters
+        #   # => [[:keyreq, :a]]
+        #
+        #   # def m9(a: 0); end
+        #   p object.method(:m9).parameters
+        #   # => [[:key, :a]]
+        #
+        #   # def m10(a:, b:); end
+        #   p object.method(:m10).parameters
+        #   # => [[:keyreq, :a], [:keyreq, :b]]
+        #
+        #   # def m11(a:, b: 1); end
+        #   p object.method(:m11).parameters
+        #   # => [[:keyreq, :a], [:key, :b]]
+        #
+        #   # def m12(a: 0, b: 1); end
+        #   p object.method(:m12).parameters
+        #   # => [[:key, :a], [:key, :b]]
+        #
+        #   # def m13(**kwargs); end
+        #   p object.method(:m13).parameters
+        #   # => [[:keyrest, :kwargs]]
+        #
+        #   # def m14(&block); end
+        #   p object.method(:m14).parameters
+        #   # => [[:block, :block]]
+        #
+        # @example All possible parameters values in Ruby 4.0.
+        #   class Example
+        #     def m1(); end
+        #     def m2(a); end
+        #     def m3(a = 0); end
+        #     def m4(a, b); end
+        #     def m5(a, b = 1); end
+        #     def m6(a = 0, b = 1); end
+        #     def m7(*args); end
+        #     def m8(a:); end
+        #     def m9(a: 0); end
+        #     def m10(a:, b:); end
+        #     def m11(a:, b: 1); end
+        #     def m12(a: 0, b: 1); end
+        #     def m13(**kwargs); end
+        #     def m14(&block); end
+        #   end
+        #
+        #   object = Example.new
+        #
+        #   # def m1(); end
+        #   p object.method(:m1).parameters
+        #   # => []
+        #
+        #   # def m2(a); end
+        #   p object.method(:m2).parameters
+        #   # => [[:req, :a]]
+        #
+        #   # def m3(a = 0); end
+        #   p object.method(:m3).parameters
+        #   # => [[:opt, :a]]
+        #
+        #   # def m4(a, b); end
+        #   p object.method(:m4).parameters
+        #   # => [[:req, :a], [:req, :b]]
+        #
+        #   # def m5(a, b = 1); end
+        #   p object.method(:m5).parameters
+        #   # => [[:req, :a], [:opt, :b]]
+        #
+        #   # def m6(a = 0, b = 1); end
+        #   p object.method(:m6).parameters
+        #   # => [[:opt, :a], [:opt, :b]]
+        #
+        #   # def m7(*args); end
+        #   p object.method(:m7).parameters
+        #   # => [[:rest, :args]]
+        #
+        #   # def m8(a:); end
+        #   p object.method(:m8).parameters
+        #   # => [[:keyreq, :a]]
+        #
+        #   # def m9(a: 0); end
+        #   p object.method(:m9).parameters
+        #   # => [[:key, :a]]
+        #
+        #   # def m10(a:, b:); end
+        #   p object.method(:m10).parameters
+        #   # => [[:keyreq, :a], [:keyreq, :b]]
+        #
+        #   # def m11(a:, b: 1); end
+        #   p object.method(:m11).parameters
+        #   # => [[:keyreq, :a], [:key, :b]]
+        #
+        #   # def m12(a: 0, b: 1); end
+        #   p object.method(:m12).parameters
+        #   # => [[:key, :a], [:key, :b]]
+        #
+        #   # def m13(**kwargs); end
+        #   p object.method(:m13).parameters
+        #   # => [[:keyrest, :kwargs]]
+        #
+        #   # def m14(&block); end
+        #   p object.method(:m14).parameters
+        #   # => [[:block, :block]]
+        #
+        class Signature
+          ##
+          # @!attribute [r] parameters
+          #   @return [Array<Array<Symbol>>]
+          #
+          attr_reader :parameters
+
+          ##
+          # @param parameters [Array<Array<Symbol>>]
+          # @return [void]
+          #
+          def initialize(parameters)
+            @parameters = parameters
+          end
+
+          ##
+          # @return [Array<Symbol>]
+          #
+          def args
+            parsed_parameters[:args].to_a
+          end
+
+          ##
+          # @return [Hash{Symbol => Object}]
+          #
+          def kwargs
+            parsed_parameters[:kwargs].to_a
+          end
+
+          ##
+          # @return [Symbol]
+          #
+          def kwargs_names
+            @kwargs_names ||= kwargs.map { |_, name| name }
+          end
+
+          ##
+          # @return [Boolean]
+          #
+          def args_rest?
+            parsed_parameters.has_key?(:args_rest)
+          end
+
+          ##
+          # @return [Boolean]
+          #
+          def kwargs_rest?
+            parsed_parameters.has_key?(:kwargs_rest)
+          end
+
+          ##
+          # @return [Boolean]
+          #
+          def block?
+            parsed_parameters.has_key?(:block)
+          end
+
+          ##
+          # @param regular_args [Array<Object>]
+          # @return [Array<Object>]
+          #
+          def loose_args_from(regular_args)
+            args_rest? ? regular_args : regular_args.take(args.size)
+          end
+
+          ##
+          # @param regular_kwargs [Hash{Symbol => Object}]
+          # @return [Hash{Symbol => Object}]
+          #
+          def loose_kwargs_from(regular_kwargs)
+            kwargs_rest? ? regular_kwargs : regular_kwargs.slice(*kwargs_names)
+          end
+
+          ##
+          # @param regular_block [Proc, nil]
+          # @return [Proc, nil]
+          #
+          def loose_block_from(regular_block)
+            block? ? regular_block : nil
+          end
+
+          private
+
+          ##
+          # @return [Hash{Symbol => Object}]
+          #
+          def parsed_parameters
+            @parsed_parameters ||=
+              parameters.each_with_object({}) do |parameter, hash|
+                case parameter.first
+                when :req, :opt
+                  (hash[:args] ||= []) << parameter
+                when :keyreq, :key
+                  (hash[:kwargs] ||= []) << parameter
+                when :block
+                  hash[:block] = parameter
+                when :rest
+                  hash[:args_rest] = true
+                when :keyrest
+                  hash[:kwargs_rest] = true
+                end
+              end
+          end
+        end
+
+        ##
+        # @!attribute [r] method
+        #   @return [String, Symbol]
+        #
+        attr_reader :method
+
+        ##
+        # @!attribute [r] args
+        #   @return [Array<Object>]
+        #
+        attr_reader :args
+
+        ##
+        # @!attribute [r] kwargs
+        #   @return [Hash{Symbol => Object}]
+        #
+        attr_reader :kwargs
+
+        ##
+        # @!attribute [r] block
+        #   @return [Proc, nil]
+        #
+        attr_reader :block
+
+        ##
+        # @param method [Symbol, String]
+        # @param args [Array<Object>]
+        # @param kwargs [Hash{Symbol => Object}]
+        # @param block [Proc, nil]
+        # @return [void]
+        #
+        def initialize(method, *args, **kwargs, &block)
+          @method = method
+          @args = args
+          @kwargs = kwargs
+          @block = block
+        end
+
+        ##
+        # @return [Object] Can be any type.
+        #
+        # @internal
+        #   NOTE: Ruby 2.7 sometimes passes `kwargs` as `args`. Look for `ConvenientService::Dependencies.ruby.version > 3.0` in `spec/e2e/loose_method_steps_spec.rb` for examples.
+        #
+        def call
+          method.call(
+            *signature.loose_args_from(args),
+            **signature.loose_kwargs_from(kwargs),
+            &signature.loose_block_from(block)
+          )
+        end
+
+        private
+
+        ##
+        # @return [Signature]
+        #
+        def signature
+          @signature ||= Signature.new(parameters)
+        end
+
+        ##
+        # @return [Array<Array<Symbol>>]
+        #
+        def parameters
+          @parameters ||= method.parameters
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/utils/method.rb

@@ -6,6 +6,7 @@
 ##
 
 require_relative "method/defined"
+require_relative "method/loose_call"
 require_relative "method/name"
 require_relative "method/remove"
 
@@ -17,6 +18,10 @@ module ConvenientService
           Defined.call(...)
         end
 
+        def loose_call(...)
+          LooseCall.call(...)
+        end
+
         def remove(...)
           Remove.call(...)
         end

data/lib/convenient_service/version.rb

@@ -13,5 +13,5 @@ module ConvenientService
   # @since 1.0.0
   # @return [String]
   #
-  VERSION = "0.21.0"
+  VERSION = "0.22.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: convenient_service
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.22.0
 platform: ruby
 authors:
 - Marian Kostyk
@@ -23,20 +23,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: set
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: |
   Manage complex business logic in Ruby applications using Service Objects with Results and Steps.
 
@@ -618,6 +604,9 @@ files:
 - lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_have_fallbacks.rb
 - lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_have_fallbacks/concern.rb
 - lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_have_fallbacks/exceptions.rb
+- lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_have_modified_data.rb
+- lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_have_modified_data/concern.rb
+- lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_have_modified_data/exceptions.rb
 - lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_have_parent_result.rb
 - lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_have_parent_result/concern.rb
 - lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_have_parent_result/constants.rb
@@ -756,7 +745,9 @@ files:
 - lib/convenient_service/support/arguments.rb
 - lib/convenient_service/support/arguments/exceptions.rb
 - lib/convenient_service/support/arguments/null_arguments.rb
+- lib/convenient_service/support/arguments/null_arguments/exceptions.rb
 - lib/convenient_service/support/backtrace_cleaner.rb
+- lib/convenient_service/support/block.rb
 - lib/convenient_service/support/cache.rb
 - lib/convenient_service/support/cache/constants.rb
 - lib/convenient_service/support/cache/entities.rb
@@ -794,7 +785,6 @@ files:
 - lib/convenient_service/support/dependency_container/export.rb
 - lib/convenient_service/support/dependency_container/import.rb
 - lib/convenient_service/support/finite_loop.rb
-- lib/convenient_service/support/method_parameters.rb
 - lib/convenient_service/support/middleware.rb
 - lib/convenient_service/support/middleware/stack_builder.rb
 - lib/convenient_service/support/middleware/stack_builder/constants.rb
@@ -845,6 +835,7 @@ files:
 - lib/convenient_service/utils/kernel/silence_warnings.rb
 - lib/convenient_service/utils/method.rb
 - lib/convenient_service/utils/method/defined.rb
+- lib/convenient_service/utils/method/loose_call.rb
 - lib/convenient_service/utils/method/name.rb
 - lib/convenient_service/utils/method/name/append.rb
 - lib/convenient_service/utils/method/remove.rb
@@ -901,7 +892,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Ruby Service Objects with Steps and more.
 test_files: []

data/lib/convenient_service/support/method_parameters.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-##
-# @author Marian Kostyk <mariankostyk13895@gmail.com>
-# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
-##
-
-module ConvenientService
-  module Support
-    ##
-    # Wrapps `Method#parameters` return value to provide a higher level interface.
-    #
-    # @note `Method#parameters` return value may look like the following.
-    #
-    #   def foo(a, b = 1, *args, c:, d: 2, **kwargs, &block)
-    #   end
-    #
-    #   method(:foo).parameters
-    #   # => [[:req, :a], [:opt, :b], [:rest, :args], [:keyreq, :c], [:key, :d], [:keyrest, :kwargs], [:block, :block]]
-    #
-    # @see https://ruby-doc.org/core-2.7.1/Method.html#method-i-parameters
-    #
-    class MethodParameters
-      module Constants
-        module Types
-          REQUIRED_KEYWORD = :keyreq
-          OPTIONAL_KEYWORD = :key
-
-          REST_KEYWORDS = :keyrest
-        end
-      end
-
-      ##
-      # @!attribute [r] method_parameters
-      #   @return [Array]
-      #
-      attr_reader :method_parameters
-
-      ##
-      # @param method_parameters [Array]
-      # @return [void]
-      #
-      def initialize(method_parameters)
-        @method_parameters = method_parameters
-      end
-
-      ##
-      # Returns `true` when method definition has `**kwargs`.
-      # @return [Boolean]
-      #
-      # @example `rest_kwargs` means NOT named kwargs.
-      #
-      #   def foo(a, b = 1, *args, c:, d: 2, **kwargs, &block)
-      #   end
-      #
-      #   def bar(a, b = 1, *args, c:, d: 2, &block)
-      #   end
-      #
-      #   ConvenientService::Support::MethodParameters.new(method(:foo).parameters).has_rest_kwargs?
-      #   # => true
-      #
-      #   ConvenientService::Support::MethodParameters.new(method(:bar).parameters).has_rest_kwargs?
-      #   # => false
-      #
-      # @see https://ruby-doc.org/core-2.7.1/Method.html#method-i-parameters
-      #
-      def has_rest_kwargs?
-        return @has_rest_kwargs if defined? @has_rest_kwargs
-
-        @has_rest_kwargs = method_parameters.any? { |type, _name| type == Constants::Types::REST_KEYWORDS }
-      end
-
-      ##
-      # @return [Array<Symbol>]
-      #
-      # @example `named_kwargs_keys` are `kwargs` with or without `defaults`.
-      #
-      #   def foo(a, b = 1, *args, c:, d: 2, **kwargs, &block)
-      #   end
-      #
-      #   ConvenientService::Support::MethodParameters.new(method(:foo).parameters).named_kwargs_keys
-      #   # => [:c, :d]
-      #
-      # @note `named_kwargs_keys` is an optimized way to get `required_kwargs_keys + optional_kwargs_keys`.
-      # @see https://ruby-doc.org/core-2.7.1/Method.html#method-i-parameters
-      #
-      def named_kwargs_keys
-        @named_kwargs_keys ||= method_parameters.select { |type, _name| type == Constants::Types::REQUIRED_KEYWORD || type == Constants::Types::OPTIONAL_KEYWORD }.map { |_type, name| name }
-      end
-
-      ##
-      # @return [Array<Symbol>]
-      #
-      # @note `required_kwargs` are named `kwargs` without `defaults`.
-      #
-      #   def foo(a, b = 1, *args, c:, d: 2, **kwargs, &block)
-      #   end
-      #
-      #   ConvenientService::Support::MethodParameters.new(method(:foo).parameters).required_kwargs_keys
-      #   # => [:c]
-      #
-      # @see https://ruby-doc.org/core-2.7.1/Method.html#method-i-parameters
-      #
-      def required_kwargs_keys
-        @required_kwargs_keys ||= method_parameters.select { |type, _name| type == Constants::Types::REQUIRED_KEYWORD }.map { |_type, name| name }
-      end
-
-      ##
-      # @return [Array<Symbol>]
-      #
-      # @note `optional_kwargs` are named `kwargs` with `defaults`.
-      #
-      #   def foo(a, b = 1, *args, c:, d: 2, **kwargs, &block)
-      #   end
-      #
-      #   ConvenientService::Support::MethodParameters.new(method(:foo).parameters).optional_kwargs_keys
-      #   # => [:d]
-      #
-      # @see https://ruby-doc.org/core-2.7.1/Method.html#method-i-parameters
-      #
-      def optional_kwargs_keys
-        @optional_kwargs_keys ||= method_parameters.select { |type, _name| type == Constants::Types::OPTIONAL_KEYWORD }.map { |_type, name| name }
-      end
-    end
-  end
-end