convenient_service 0.5.0 → 0.6.0

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/entities/callers/reassignment/commands/define_method_in_container.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              module Callers
+                class Reassignment < Callers::Base
+                  module Commands
+                    class DefineMethodInContainer < Support::Command
+                      include Support::Delegate
+
+                      attr_reader :method, :container, :index
+
+                      delegate :key, :name, to: :method
+
+                      def initialize(method:, container:, index:)
+                        @method = method
+                        @container = container
+                        @index = index
+                      end
+
+                      ##
+                      # @return [Boolean]
+                      #
+                      def call
+                        ##
+                        # NOTE: `prepend` is thread-safe.
+                        #
+                        container.klass.prepend reassigned_methods
+
+                        return false if Utils::Module.instance_method_defined?(reassigned_methods, method, private: true)
+
+                        <<~RUBY.tap { |code| reassigned_methods.module_eval(code, __FILE__, __LINE__ + 1) }
+                          def #{name}
+                            step =
+                              steps
+                                .select { |step| step.has_reassignment?(__method__) }
+                                .select(&:completed?)
+                                .last
+
+                            return super unless step
+
+                            key = step.reassignment(__method__).key.to_sym
+
+                            step.result.data[key]
+                          end
+                        RUBY
+
+                        true
+                      end
+
+                      private
+
+                      ##
+                      # @return [Module]
+                      #
+                      def reassigned_methods
+                        @reassigned_methods ||= Utils::Module.fetch_own_const(container.klass, :ReassignedMethods) { ::Module.new }
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/entities/callers/reassignment/commands.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "commands/define_method_in_container"

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/entities/callers/reassignment.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "reassignment/commands"
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              module Callers
+                class Reassignment < Callers::Base
+                  def reassignment?(name)
+                    ##
+                    # TODO: A better name for `object`. Wrapped object, `target`?
+                    #
+                    object.to_sym == name.to_sym
+                  end
+
+                  ##
+                  # TODO: Separate `in` and `out` methods?
+                  #
+                  def calculate_value(method)
+                    raise Errors::CallerCanNotCalculateReassignment.new(method: method)
+                  end
+
+                  def validate_as_input_for_container!(container, method:)
+                    raise Errors::InputMethodReassignment.new(method: method, container: container)
+                  end
+
+                  def validate_as_output_for_container!(container, method:)
+                    ##
+                    # TODO: Raise when container has two reassignments with same name.
+                    #
+                    true
+                  end
+
+                  def define_output_in_container!(container, index:, method:)
+                    Commands::DefineMethodInContainer.call(method: method, container: container, index: index)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/entities/callers.rb

@@ -4,4 +4,5 @@ require_relative "callers/base"
 require_relative "callers/alias"
 require_relative "callers/proc"
 require_relative "callers/raw"
+require_relative "callers/reassignment"
 require_relative "callers/usual"

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/entities/values/reassignment.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              module Values
+                ##
+                # TODO: Specs.
+                #
+                class Reassignment
+                  include Support::Delegate
+
+                  attr_reader :value
+
+                  delegate :to_s, :to_sym, to: :value
+
+                  ##
+                  # @param value [String, Symbol] Method name to reassign.
+                  #
+                  def initialize(value)
+                    @value = value
+                  end
+
+                  def ==(other)
+                    return unless other.instance_of?(self.class)
+
+                    return false if value != other.value
+
+                    true
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/entities/values.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "values/reassignment"

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/entities.rb

@@ -4,3 +4,4 @@ require_relative "entities/directions"
 require_relative "entities/callers"
 require_relative "entities/key"
 require_relative "entities/name"
+require_relative "entities/values"

data/lib/convenient_service/service/plugins/has_result_steps/entities/method/errors.rb

@@ -87,6 +87,28 @@ module ConvenientService
                 end
               end
 
+              class CallerCanNotCalculateReassignment < ::ConvenientService::Error
+                def initialize(method:)
+                  message = <<~TEXT
+                    Method caller failed to calculate reassignment for `#{method.name}`.
+
+                    Method callers can calculate only `in` methods, while reassignments are always `out` methods.
+                  TEXT
+
+                  super(message)
+                end
+              end
+
+              class InputMethodReassignment < ConvenientService::Error
+                def initialize(method:, container:)
+                  message = <<~TEXT
+                    Reassignments are not allowed for `in` methods.
+                  TEXT
+
+                  super(message)
+                end
+              end
+
               class MethodIsNotInputMethod < ConvenientService::Error
                 def initialize(method:, container:)
                   message = <<~TEXT

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

@@ -50,10 +50,18 @@ module ConvenientService
                   Utils::Bool.to_bool(organizer)
                 end
 
+                def has_reassignment?(name)
+                  outputs.any? { |output| output.reassignment?(name) }
+                end
+
                 def completed?
                   Utils::Bool.to_bool(@completed)
                 end
 
+                def reassignment(name)
+                  outputs.find { |output| output.reassignment?(name) }
+                end
+
                 def params
                   @params ||= resolve_params
                 end
@@ -113,14 +121,17 @@ module ConvenientService
                 end
 
                 ##
-                # IMPORTANT: `service.result(**input_values)` is the reason, why services should have only kwargs as arguments.
+                # @internal
+                #   IMPORTANT: `service.result(**input_values)` is the reason, why services should have only kwargs as arguments.
                 #
                 def calculate_result
                   assert_has_organizer!
 
+                  result = service.result(**input_values)
+
                   mark_as_completed!
 
-                  service.result(**input_values)
+                  result
                 end
 
                 def resolve_params

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    class Arguments
+      ##
+      # @api private
+      #
+      class NullArguments < Support::Arguments
+        ##
+        # @return [void]
+        #
+        def initialize
+          @args = []
+          @kwargs = {}
+          @block = nil
+        end
+
+        ##
+        # @return [Boolean]
+        #
+        def null_arguments?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/arguments.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "arguments/null_arguments"
+
+module ConvenientService
+  module Support
+    class Arguments
+      ##
+      # @!attribute [r] args
+      #   @return [Array]
+      #
+      attr_reader :args
+
+      ##
+      # @!attribute [r] kwargs
+      #   @return [Hash]
+      #
+      attr_reader :kwargs
+
+      ##
+      # @!attribute [r] block
+      #   @return [Proc]
+      #
+      attr_reader :block
+
+      ##
+      # @param args [Array]
+      # @param kwargs [Hash]
+      # @param block [Proc]
+      # @return [void]
+      #
+      def initialize(*args, **kwargs, &block)
+        @args = args
+        @kwargs = kwargs
+        @block = block
+      end
+
+      class << self
+        ##
+        # @return [ConvenientService::Support::Arguments::NullArguments]
+        #
+        def null_arguments
+          @null_arguments ||= Support::Arguments::NullArguments.new
+        end
+      end
+
+      ##
+      # @return [Boolean]
+      #
+      def null_arguments?
+        false
+      end
+
+      ##
+      # @return [Booleam]
+      #
+      def any?
+        return true if args.any?
+        return true if kwargs.any?
+        return true if block
+
+        false
+      end
+
+      ##
+      # @return [Booleam]
+      #
+      def none?
+        !any?
+      end
+
+      ##
+      # @param other [Object]
+      # @return [Boolean]
+      #
+      def ==(other)
+        return unless other.instance_of?(self.class)
+
+        return false if args != other.args
+        return false if kwargs != other.kwargs
+        return false if block != other.block
+
+        true
+      end
+    end
+  end
+end

data/lib/convenient_service/support/dependency_container/commands/assert_valid_scope.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Commands
+        class AssertValidScope < Support::Command
+          ##
+          # @!attribute [r] scope
+          #   @return [Object]
+          #
+          attr_reader :scope
+
+          ##
+          # @param scope [Object]
+          # @return [void]
+          #
+          def initialize(scope:)
+            @scope = scope
+          end
+
+          ##
+          # @return [Module]
+          #
+          def call
+            raise Errors::InvalidScope.new(scope: scope) unless Constants::SCOPES.include?(scope)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/dependency_container/commands/import_method.rb

@@ -5,6 +5,8 @@ module ConvenientService
     module DependencyContainer
       module Commands
         class ImportMethod < Support::Command
+          include Support::Delegate
+
           ##
           # @!attribute [r] importing_module
           #   @return [Module]
@@ -12,41 +14,31 @@ module ConvenientService
           attr_reader :importing_module
 
           ##
-          # @!attribute [r] exporting_module
-          #   @return [Module]
+          # @!attribute [r] exported_method
+          #   @return [ConvenientService::Support::DependencyContainer::Method]
           #
-          attr_reader :exporting_module
+          attr_reader :exported_method
 
           ##
-          # @!attribute [r] method
-          #   @return [ConvenientService::Support::DependencyContainer::Method]
+          # @!attribute [r] prepend
+          #   @return [Boolean]
           #
-          attr_reader :method
+          attr_reader :prepend
 
           ##
           # @!attribute [r] scope
           #   @return [Symbol]
           #
-          attr_reader :scope
-
-          ##
-          # @!attribute [r] prepend
-          #   @return [Boolean]
-          #
-          attr_reader :prepend
+          delegate :scope, to: :exported_method
 
           ##
           # @param importing_module [Module]
-          # @param exporting_module [Module]
-          # @param method [ConvenientService::Support::DependencyContainer::Method]
-          # @param scope [:instance, :class]
+          # @param exported_method [ConvenientService::Support::DependencyContainer::Method]
           # @param prepend [Boolean]
           #
-          def initialize(importing_module:, exporting_module:, method:, scope:, prepend:)
+          def initialize(importing_module:, exported_method:, prepend:)
             @importing_module = importing_module
-            @exporting_module = exporting_module
-            @method = method
-            @scope = scope
+            @exported_method = exported_method
             @prepend = prepend
           end
 
@@ -56,9 +48,7 @@ module ConvenientService
           def call
             import imported_scoped_methods
 
-            method.define_in_module!(imported_scoped_methods)
-
-            method
+            exported_method.define_in_module!(imported_scoped_methods)
           end
 
           private

data/lib/convenient_service/support/dependency_container/commands.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
 
+require_relative "commands/assert_valid_scope"
 require_relative "commands/create_methods_module"
 require_relative "commands/import_method"

data/lib/convenient_service/support/dependency_container/constants.rb

@@ -4,8 +4,10 @@ module ConvenientService
   module Support
     module DependencyContainer
       module Constants
-        INSTANCE_SCOPE = :instance
-        CLASS_SCOPE = :class
+        SCOPES = [
+          INSTANCE_SCOPE = :instance,
+          CLASS_SCOPE = :class
+        ]
 
         DEFAULT_SCOPE = Constants::INSTANCE_SCOPE
         DEFAULT_PREPEND = false

data/lib/convenient_service/support/dependency_container/entities/method.rb

@@ -80,9 +80,9 @@ module ConvenientService
             #   - Same methods are redefined.
             #   - In contrast, same namespaces are always reused.
             #
-            innermost_namespace.define_method(method.name, &method.body)
+            innermost_namespace.define_method(name, &body)
 
-            method
+            self
           end
 
           ##
@@ -101,13 +101,6 @@ module ConvenientService
 
           private
 
-          ##
-          # @return [ConvenientService::Support::DependencyContainer::Entities::Method]
-          #
-          def method
-            self
-          end
-
           ##
           # @return [Array<String>]
           #

data/lib/convenient_service/support/dependency_container/entities/namespace_collection.rb

@@ -13,15 +13,6 @@ module ConvenientService
             @namespaces = namespaces
           end
 
-          ##
-          #
-          #
-          def define_namespace(namespace)
-            namespaces << namespace
-
-            define_singleton_method(namespace.name) { namespace.body.call }
-          end
-
           ##
           # @param name [String, Symbol]
           # @return [ConvenientService::Support::DependencyContainer::Entities::Namespace, nil]

data/lib/convenient_service/support/dependency_container/errors.rb

@@ -4,6 +4,31 @@ module ConvenientService
   module Support
     module DependencyContainer
       module Errors
+        class InvalidScope < ConvenientService::Error
+          ##
+          # @param scope [Object]
+          # @return [void]
+          #
+          def initialize(scope:)
+            message = <<~TEXT
+              Scope `#{scope.inspect}` is NOT valid.
+
+              Valid options are #{printable_valid_scopes}.
+            TEXT
+
+            super(message)
+          end
+
+          private
+
+          ##
+          # @return [String]
+          #
+          def printable_valid_scopes
+            Constants::SCOPES.map { |scope| "`:#{scope}`" }.join(", ")
+          end
+        end
+
         class NotExportableModule < ConvenientService::Error
           ##
           # @param mod [Module]

data/lib/convenient_service/support/dependency_container/export.rb

@@ -13,7 +13,15 @@ module ConvenientService
           # @param body [Proc]
           # @return [ConvenientService::Support::DependencyContainer::Entities::Method]
           #
+          # @internal
+          #   NOTE: `export` does NOT accept `prepend` kwarg intentionally.
+          #   It is done to follow "the Ruby way".
+          #   You won't ever see a module in Ruby that contains methods for `include` and `prepend` at the same time.
+          #   So why `export` should allow to do it?
+          #
           def export(full_name, scope: Constants::DEFAULT_SCOPE, &body)
+            Commands::AssertValidScope.call(scope: scope)
+
             Entities::Method.new(full_name: full_name, scope: scope, body: body).tap { |method| exported_methods << method }
           end
 

data/lib/convenient_service/support/dependency_container/import.rb

@@ -15,13 +15,15 @@ module ConvenientService
           # @return [ConvenientService::Support::DependencyContainer::Entities::Method]
           #
           def import(full_name, from:, scope: Constants::DEFAULT_SCOPE, prepend: Constants::DEFAULT_PREPEND)
+            Commands::AssertValidScope.call(scope: scope)
+
             raise Errors::NotExportableModule.new(mod: from) unless Utils::Module.include_module?(from, DependencyContainer::Export)
 
             method = from.exported_methods.find_by(full_name: full_name, scope: scope)
 
             raise Errors::NotExportedMethod.new(method_name: full_name, method_scope: scope, mod: from) unless method
 
-            Commands::ImportMethod.call(importing_module: self, exporting_module: from, method: method, scope: scope, prepend: prepend)
+            Commands::ImportMethod.call(importing_module: self, exported_method: method, prepend: prepend)
           end
         end
       end

data/lib/convenient_service/support/version/null_version.rb

@@ -11,6 +11,13 @@ module ConvenientService
       #   - https://avdi.codes/null-objects-and-falsiness/
       #
       class NullVersion
+        ##
+        # @return [Boolean]
+        #
+        def null_version?
+          true
+        end
+
         ##
         # @return [nil]
         #

data/lib/convenient_service/support/version.rb

@@ -24,10 +24,17 @@ module ConvenientService
         # @return [ConvenientService::Support::Version::NullVersion]
         #
         def null_version
-          @null_version ||= NullVersion.new
+          @null_version ||= Support::Version::NullVersion.new
         end
       end
 
+      ##
+      # @return [Boolean]
+      #
+      def null_version?
+        false
+      end
+
       ##
       # @return [Gem::Version, nil]
       #
@@ -52,6 +59,9 @@ module ConvenientService
 
       private
 
+      ##
+      # @return [String]
+      #
       attr_reader :value
 
       ##

data/lib/convenient_service/support.rb

@@ -4,6 +4,7 @@ require_relative "support/not_passed"
 require_relative "support/concern"
 
 require_relative "support/abstract_method"
+require_relative "support/arguments"
 require_relative "support/cache"
 require_relative "support/castable"
 require_relative "support/command"