convenient_service 0.1.0

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Commands
+              class CastMethodDirection < Support::Command
+                attr_reader :other, :options
+
+                def initialize(other:, options:)
+                  @other = other
+                  @options = options
+                end
+
+                def call
+                  casted =
+                    case options[:direction]
+                    when ::Symbol then cast_symbol
+                    when ::String then cast_string
+                    end
+
+                  ##
+                  # TODO: Specs. Priority.
+                  #
+                  return casted if casted
+
+                  case other
+                  when Method then cast_method
+                  end
+                end
+
+                private
+
+                def cast_symbol
+                  case options[:direction]
+                  when :input
+                    Entities::Directions::Input.new
+                  when :output
+                    Entities::Directions::Output.new
+                  end
+                end
+
+                def cast_string
+                  case options[:direction]
+                  when "input"
+                    Entities::Directions::Input.new
+                  when "output"
+                    Entities::Directions::Output.new
+                  end
+                end
+
+                def cast_method
+                  other.direction.copy
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Commands
+              ##
+              # TODO: Replace `CastMethodKey`, `CastMethodName`, `CastMethodCaller` by declarative caster?
+              #
+              class CastMethodKey < Support::Command
+                attr_reader :other, :options
+
+                def initialize(other:, options:)
+                  @other = other
+                  @options = options
+                end
+
+                def call
+                  ##
+                  # TODO: Use pattern matcher when Ruby 2.7.
+                  #
+                  case other
+                  when ::Symbol then cast_symbol
+                  when ::String then cast_string
+                  when ::Hash then cast_hash
+                  when Method then cast_method
+                  end
+                end
+
+                private
+
+                def cast_symbol
+                  Entities::Key.new(other)
+                end
+
+                def cast_string
+                  Entities::Key.new(other)
+                end
+
+                def cast_hash
+                  return unless other.keys.one?
+
+                  key = other.keys.first
+                  value = other.values.first
+
+                  case value
+                  when ::Symbol
+                    Entities::Key.new(key)
+                  when ::String
+                    Entities::Key.new(key)
+                  when ::Proc
+                    Entities::Key.new(key)
+                  when Entities::Values::Raw
+                    Entities::Key.new(key)
+                  end
+                end
+
+                def cast_method
+                  other.key.copy
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Commands
+              ##
+              # TODO: Replace `CastMethodKey`, `CastMethodName`, `CastMethodCaller` by declarative caster?
+              #
+              class CastMethodName < Support::Command
+                attr_reader :other, :options
+
+                def initialize(other:, options:)
+                  @other = other
+                  @options = options
+                end
+
+                def call
+                  ##
+                  # TODO: Use pattern matcher when Ruby 2.7.
+                  #
+                  case other
+                  when ::Symbol then cast_symbol
+                  when ::String then cast_string
+                  when ::Hash then cast_hash
+                  when Method then cast_method
+                  end
+                end
+
+                private
+
+                def cast_symbol
+                  Entities::Name.new(other)
+                end
+
+                def cast_string
+                  Entities::Name.new(other)
+                end
+
+                def cast_hash
+                  return unless other.keys.one?
+
+                  key = other.keys.first
+                  value = other.values.first
+
+                  case value
+                  when ::Symbol
+                    Entities::Name.new(value)
+                  when ::String
+                    Entities::Name.new(value)
+                  when ::Proc
+                    Entities::Name.new(key)
+                  when Entities::Values::Raw
+                    Entities::Name.new(key)
+                  end
+                end
+
+                ##
+                # TODO: Specs.
+                #
+                def cast_method
+                  other.name.copy
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            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
+
+                def call
+                  ##
+                  # NOTE: Assignement in the beginning for easier debugging.
+                  #
+                  <<~RUBY.tap { |code| container.klass.class_eval(code, __FILE__, __LINE__ + 1) }
+                    def #{name}
+                      step, key, name, error = steps[#{index}], :#{key}, :#{name}, #{error}
+
+                      return step.result.data[key] if step.completed?
+
+                      raise ::#{error}.new(step: step, method_name: name)
+                    end
+                  RUBY
+
+                  true
+                end
+
+                private
+
+                def error
+                  @error ||=
+                    <<~RUBY.chomp
+                      ConvenientService::Service::Plugins::HasResultSteps::Entities::Method::Errors::NotCompletedStep
+                    RUBY
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "commands/cast_method_caller"
+require_relative "commands/cast_method_direction"
+require_relative "commands/cast_method_key"
+require_relative "commands/cast_method_name"
+require_relative "commands/cast_method"
+require_relative "commands/define_method_in_container"

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Concern
+              module ClassMethods
+                def cast(other, **options)
+                  Commands::CastMethod.call(other: other, options: options)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Concern
+              module InstanceMethods
+                include Support::Delegate
+
+                attr_reader :key, :name, :caller, :direction, :organizer
+
+                delegate :to_s, to: :name
+
+                def initialize(key:, name:, caller:, direction:, organizer: nil)
+                  @key = key
+                  @name = name
+                  @caller = caller
+                  @direction = direction
+                  @organizer = organizer
+                end
+
+                def ==(other)
+                  return unless other.instance_of?(self.class)
+
+                  return false if key != other.key
+                  return false if name != other.name
+                  return false if caller != other.caller
+                  return false if direction != other.direction
+                  return false if organizer != other.organizer
+
+                  true
+                end
+
+                def has_organizer?
+                  Utils::Bool.to_bool(organizer)
+                end
+
+                def validate_as_input_for_container!(container)
+                  direction.validate_as_input_for_container!(container, method: self)
+
+                  caller.validate_as_input_for_container!(container, method: self)
+
+                  true
+                end
+
+                def validate_as_output_for_container!(container)
+                  direction.validate_as_output_for_container!(container, method: self)
+
+                  caller.validate_as_output_for_container!(container, method: self)
+
+                  true
+                end
+
+                def define_output_in_container!(container, index:)
+                  direction.define_output_in_container!(container, index: index, method: self)
+
+                  caller.define_output_in_container!(container, index: index, method: self)
+
+                  true
+                end
+
+                def value
+                  @value ||= calculate_value
+                end
+
+                def to_kwargs
+                  {key: key, name: name, caller: caller, direction: direction, organizer: organizer}
+                end
+
+                private
+
+                def calculate_value
+                  assert_has_organizer!
+
+                  caller.calculate_value(self)
+                end
+
+                ##
+                # TODO: Return `true` for valid assertions.
+                #
+                def assert_has_organizer!
+                  return if has_organizer?
+
+                  raise Errors::MethodHasNoOrganizer.new(method: self)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "concern/instance_methods"
+require_relative "concern/class_methods"
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Concern
+              include Support::Concern
+
+              included do |method_klass|
+                method_klass.include Support::Castable
+                method_klass.include Support::Copyable
+
+                method_klass.include InstanceMethods
+
+                method_klass.extend ClassMethods
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              module Callers
+                class Alias < Callers::Base
+                  def calculate_value(method)
+                    method.organizer.__send__(method.name.to_s)
+                  end
+
+                  def validate_as_input_for_container!(container, method:)
+                    return true if container.has_defined_method?(method)
+
+                    raise Errors::AliasInputMethodIsNotDefinedInContainer.new(method: method, container: container)
+                  end
+
+                  def validate_as_output_for_container!(container, method:)
+                    return true unless container.has_defined_method?(method)
+
+                    raise Errors::AliasOutputMethodIsDefinedInContainer.new(method: method, container: container)
+                  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/base.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              module Callers
+                class Base
+                  include Support::AbstractMethod
+                  include Support::Copyable
+
+                  ##
+                  # TODO: A better name for `object`. Wrapped object, `target`?
+                  #
+                  attr_reader :object
+
+                  abstract_method \
+                    :calculate_value,
+                    :validate_as_input_for_container!,
+                    :validate_as_output_for_container!,
+                    :define_output_in_container!
+
+                  def initialize(object)
+                    @object = object
+                  end
+
+                  def ==(other)
+                    return unless other.instance_of?(self.class)
+
+                    return false if object != other.object
+
+                    true
+                  end
+
+                  def to_args
+                    [object]
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              module Callers
+                class Proc < Callers::Base
+                  def calculate_value(method)
+                    method.organizer.instance_exec(&proc)
+                  end
+
+                  def validate_as_input_for_container!(container, method:)
+                    true
+                  end
+
+                  def validate_as_output_for_container!(container, method:)
+                    ##
+                    # TODO: Better error message.
+                    #
+                    raise Errors::OutputMethodProc.new(method: method, container: container)
+                  end
+
+                  def define_output_in_container!(container, index:, method:)
+                    true
+                  end
+
+                  private
+
+                  alias_method :proc, :object
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              module Callers
+                class Raw < Callers::Base
+                  def calculate_value(method)
+                    raw_value.unwrap
+                  end
+
+                  def validate_as_input_for_container!(container, method:)
+                    true
+                  end
+
+                  def validate_as_output_for_container!(container, method:)
+                    ##
+                    # TODO: Better error message.
+                    #
+                    raise Errors::OutputMethodRawValue.new(container: container, method: method)
+                  end
+
+                  def define_output_in_container!(container, index:, method:)
+                    true
+                  end
+
+                  private
+
+                  alias_method :raw_value, :object
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              module Callers
+                class Usual < Callers::Base
+                  def calculate_value(method)
+                    method.organizer.__send__(method.name.to_s)
+                  end
+
+                  def validate_as_input_for_container!(container, method:)
+                    return true if container.has_defined_method?(method)
+
+                    raise Errors::InputMethodIsNotDefinedInContainer.new(method: method, container: container)
+                  end
+
+                  def validate_as_output_for_container!(container, method:)
+                    return true unless container.has_defined_method?(method)
+
+                    raise Errors::OutputMethodIsDefinedInContainer.new(method: method, container: container)
+                  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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "callers/base"
+require_relative "callers/alias"
+require_relative "callers/proc"
+require_relative "callers/raw"
+require_relative "callers/usual"

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              module Directions
+                class Base
+                  include Support::AbstractMethod
+                  include Support::Copyable
+
+                  abstract_method \
+                    :validate_as_input_for_container!,
+                    :validate_as_output_for_container!,
+                    :define_output_in_container!
+
+                  def ==(other)
+                    return unless other.instance_of?(self.class)
+
+                    true
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end