convenient_service 0.4.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/create_methods_module.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Commands
+        class CreateMethodsModule < Support::Command
+          ##
+          # @return [Module]
+          #
+          def call
+            ::Module.new do
+              class << self
+                ##
+                # @return namespaces [ConvenientService::Support::DependencyContainer::Entities::NamespaceCollection]
+                #
+                def namespaces
+                  @namespaces ||= Entities::NamespaceCollection.new
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Commands
+        class ImportMethod < Support::Command
+          include Support::Delegate
+
+          ##
+          # @!attribute [r] importing_module
+          #   @return [Module]
+          #
+          attr_reader :importing_module
+
+          ##
+          # @!attribute [r] exported_method
+          #   @return [ConvenientService::Support::DependencyContainer::Method]
+          #
+          attr_reader :exported_method
+
+          ##
+          # @!attribute [r] prepend
+          #   @return [Boolean]
+          #
+          attr_reader :prepend
+
+          ##
+          # @!attribute [r] scope
+          #   @return [Symbol]
+          #
+          delegate :scope, to: :exported_method
+
+          ##
+          # @param importing_module [Module]
+          # @param exported_method [ConvenientService::Support::DependencyContainer::Method]
+          # @param prepend [Boolean]
+          #
+          def initialize(importing_module:, exported_method:, prepend:)
+            @importing_module = importing_module
+            @exported_method = exported_method
+            @prepend = prepend
+          end
+
+          ##
+          # @return [ConvenientService::Support::DependencyContainer::Method]
+          #
+          def call
+            import imported_scoped_methods
+
+            exported_method.define_in_module!(imported_scoped_methods)
+          end
+
+          private
+
+          ##
+          # @return [Module]
+          #
+          def imported_scoped_methods
+            @imported_scoped_methods ||= Utils::Module.fetch_own_const(importing_module, :"Imported#{imported_prefix}#{scoped_prefix}Methods") { Commands::CreateMethodsModule.call }
+          end
+
+          ##
+          # @return [String]
+          #
+          def imported_prefix
+            prepend ? "Prepended" : "Included"
+          end
+
+          ##
+          # @return [String]
+          #
+          def scoped_prefix
+            case scope
+            when Constants::INSTANCE_SCOPE then "Instance"
+            when Constants::CLASS_SCOPE then "Class"
+            end
+          end
+
+          ##
+          # @return [Module, Class]
+          #
+          def importer
+            case scope
+            when Constants::INSTANCE_SCOPE then importing_module
+            when Constants::CLASS_SCOPE then importing_module.singleton_class
+            end
+          end
+
+          ##
+          # @param mod [Module]
+          # @return [Module]
+          #
+          def import(mod)
+            prepend ? importer.prepend(mod) : importer.include(mod)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Constants
+        SCOPES = [
+          INSTANCE_SCOPE = :instance,
+          CLASS_SCOPE = :class
+        ]
+
+        DEFAULT_SCOPE = Constants::INSTANCE_SCOPE
+        DEFAULT_PREPEND = false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module DependencyContainer
+      module Entities
+        class Method
+          ##
+          # @!attribute [r] full_name
+          #   @return [String, Symbol]
+          #
+          attr_reader :full_name
+
+          ##
+          # @!attribute [r] scope
+          #   @return [:instance, :class]
+          #
+          attr_reader :scope
+
+          ##
+          # @!attribute [r] body
+          #   @return [Proc]
+          #
+          attr_reader :body
+
+          ##
+          # @param full_name [String, Symbol]
+          # @param scope [:instance, :class]
+          # @param body [Proc]
+          # @return [void]
+          #
+          def initialize(full_name:, scope:, body:)
+            @full_name = full_name
+            @scope = scope
+            @body = body
+          end
+
+          ##
+          # @return [String]
+          #
+          def name
+            @name ||= full_name_parts.last
+          end
+
+          ##
+          # @return [Array<ConvenientService::Support::DependencyContainer::Entities::Namespace>]
+          #
+          def namespaces
+            @namespaces ||= full_name_parts.slice(0..-2).map { |part| Entities::Namespace.new(name: part) }
+          end
+
+          ##
+          # @param mod [Module]
+          # @return [ConvenientService::Support::DependencyContainer::Entities::Method]
+          #
+          def define_in_module!(mod)
+            ##
+            # NOTE: `innermost_namespace` is just `mod`, when `namespaces` are empty.
+            #
+            innermost_namespace =
+              namespaces.reduce(mod) do |namespace, sub_namespace|
+                already_defined_sub_namespace = namespace.namespaces.find_by(name: sub_namespace.name)
+
+                ##
+                # NOTE:
+                #   - Reuses already defined namespace from previous "imports".
+                #   - In contrast, same methods are always redefined.
+                #
+                next already_defined_sub_namespace if already_defined_sub_namespace
+
+                namespace.namespaces << sub_namespace
+
+                namespace.define_method(sub_namespace.name) { sub_namespace.body.call }
+
+                sub_namespace
+              end
+
+            ##
+            # NOTE:
+            #   - Same methods are redefined.
+            #   - In contrast, same namespaces are always reused.
+            #
+            innermost_namespace.define_method(name, &body)
+
+            self
+          end
+
+          ##
+          # @param other [Object] Can be any type.
+          # @return [Boolean]
+          #
+          def ==(other)
+            return unless other.instance_of?(self.class)
+
+            return false if full_name != other.full_name
+            return false if scope != other.scope
+            return false if body != other.body
+
+            true
+          end
+
+          private
+
+          ##
+          # @return [Array<String>]
+          #
+          def full_name_parts
+            @full_name_parts ||= Utils::String.split(full_name, ".", "::").map(&:to_sym)
+          end
+        end
+      end
+    end
+  end
+end