convenient_service 0.1.0

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              module Directions
+                class Input < Base
+                  def validate_as_input_for_container!(container, method:)
+                    true
+                  end
+
+                  def validate_as_output_for_container!(container, method:)
+                    raise Errors::MethodIsNotOutputMethod.new(method: method, container: container)
+                  end
+
+                  def define_output_in_container!(container, index:, method:)
+                    raise Errors::MethodIsNotOutputMethod.new(method: method, container: container)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              module Directions
+                class Output < Base
+                  def validate_as_input_for_container!(container, method:)
+                    raise Errors::MethodIsNotInputMethod.new(method: method, container: container)
+                  end
+
+                  def validate_as_output_for_container!(container, method:)
+                    true
+                  end
+
+                  def define_output_in_container!(container, index:, method:)
+                    true
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "directions/base"
+require_relative "directions/input"
+require_relative "directions/output"

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              class Key
+                include Support::Copyable
+                include Support::Delegate
+
+                attr_reader :value
+
+                delegate :to_s, :to_sym, to: :value
+
+                def initialize(value)
+                  @value = value
+                end
+
+                def ==(other)
+                  return unless other.instance_of?(self.class)
+
+                  return false if value != other.value
+
+                  true
+                end
+
+                def to_args
+                  [value]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              class Name
+                include Support::Copyable
+                include Support::Delegate
+
+                attr_reader :value
+
+                delegate :to_s, :to_sym, to: :value
+
+                def initialize(value)
+                  @value = value
+                end
+
+                def ==(other)
+                  return unless other.instance_of?(self.class)
+
+                  return false if value != other.value
+
+                  true
+                end
+
+                def to_args
+                  [value]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Entities
+              module Values
+                ##
+                # TODO: Specs.
+                #
+                class Raw
+                  def initialize(object)
+                    @object = object
+                  end
+
+                  class << self
+                    def wrap(object)
+                      new(object)
+                    end
+
+                    private :new
+                  end
+
+                  def unwrap
+                    object
+                  end
+
+                  def ==(other)
+                    return unless other.instance_of?(self.class)
+
+                    object == other.object
+                  end
+
+                  protected
+
+                  attr_reader :object
+                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/raw"

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Errors
+              class MethodHasNoOrganizer < ::ConvenientService::Error
+                def initialize(method:)
+                  message = <<~TEXT
+                    Organizer for method `#{method.name}` is NOT assigned yet.
+
+                    Did you forget to set it?
+                  TEXT
+
+                  super(message)
+                end
+              end
+
+              class InputMethodIsNotDefinedInContainer < ::ConvenientService::Error
+                def initialize(method:, container:)
+                  message = <<~TEXT
+                    `in` method `#{method.name}` is NOT defined in `#{container.klass}`.
+
+                    Did you forget to define it?
+                  TEXT
+
+                  super(message)
+                end
+              end
+
+              class OutputMethodIsDefinedInContainer < ::ConvenientService::Error
+                def initialize(method:, container:)
+                  message = <<~TEXT
+                    `out` method `#{method.name}` is already defined in `#{container.klass}`.
+
+                    Did you forget to remove it?
+                  TEXT
+
+                  super(message)
+                end
+              end
+
+              class AliasInputMethodIsNotDefinedInContainer < ::ConvenientService::Error
+                def initialize(method:, container:)
+                  message = <<~TEXT
+                    Alias `in` method `#{method.name}` is NOT defined in `#{container.klass}`.
+
+                    Did you forget to define it?
+                  TEXT
+
+                  super(message)
+                end
+              end
+
+              class AliasOutputMethodIsDefinedInContainer < ::ConvenientService::Error
+                def initialize(method:, container:)
+                  message = <<~TEXT
+                    Alias `out` method `#{method.name}` is already defined in `#{container.klass}`.
+
+                    Did you forget to remove it?
+                  TEXT
+
+                  super(message)
+                end
+              end
+
+              class OutputMethodProc < ConvenientService::Error
+                def initialize(method:, container:)
+                  message = <<~TEXT
+                    Procs are not allowed for `out` methods.
+                  TEXT
+
+                  super(message)
+                end
+              end
+
+              class OutputMethodRawValue < ConvenientService::Error
+                def initialize(method:, container:)
+                  message = <<~TEXT
+                    Raw values are not allowed for `out` methods.
+                  TEXT
+
+                  super(message)
+                end
+              end
+
+              class MethodIsNotInputMethod < ConvenientService::Error
+                def initialize(method:, container:)
+                  message = <<~TEXT
+                    Method `#{method.name}` is NOT an `in` method.
+                  TEXT
+
+                  super(message)
+                end
+              end
+
+              class MethodIsNotOutputMethod < ConvenientService::Error
+                def initialize(method:, container:)
+                  message = <<~TEXT
+                    Method `#{method.name}` is NOT an `out` method.
+                  TEXT
+
+                  super(message)
+                end
+              end
+
+              class NotCompletedStep < ConvenientService::Error
+                def initialize(method_name:, step:)
+                  message = <<~TEXT
+                    `out` method `#{method_name}` is called before its corresponding step `#{step.service}` is completed.
+
+                    Maybe it makes sense to change the steps order?
+                  TEXT
+
+                  super(message)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "method/commands"
+require_relative "method/concern"
+require_relative "method/entities"
+require_relative "method/errors"
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            include Concern
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Service
+            module ClassMethods
+              def cast(other)
+                case other
+                when ::Class then cast_klass(other)
+                when Service then cast_service(other)
+                end
+              end
+
+              private
+
+              def cast_klass(klass)
+                new(klass)
+              end
+
+              def cast_service(service)
+                new(service.klass)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "service/class_methods"
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          ##
+          # NOTE: Service is a wrapper for a service class (klass). For example:
+          #
+          #   step SomeService, in: :foo, out: :bar
+          #   # klass is `SomeService` in this particular case.
+          #
+          class Service
+            include Support::Castable
+            include Support::Delegate
+
+            extend ClassMethods
+
+            delegate :result, :step_class, to: :klass
+
+            attr_reader :klass
+
+            def initialize(klass)
+              @klass = klass
+            end
+
+            def has_defined_method?(method)
+              Utils::Method.defined?(method, klass, private: true)
+            end
+
+            def ==(other)
+              casted = cast(other)
+
+              return unless casted
+
+              return false if klass != casted.klass
+
+              true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_steps/entities/step/commands/cast_params.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Step
+            module Commands
+              class CastParams < Support::Command
+                attr_reader :original_params
+
+                def initialize(original_params:)
+                  @original_params = original_params
+                end
+
+                def call
+                  Structs::Params.new(
+                    service: service,
+                    inputs: inputs,
+                    outputs: outputs,
+                    index: index,
+                    container: container,
+                    organizer: organizer
+                  )
+                end
+
+                def service
+                  @service ||= Entities::Service.cast!(original_params.service)
+                end
+
+                ##
+                # TODO: `cast_many`, `cast_many!`.
+                #
+                def inputs
+                  @inputs ||= original_params.inputs.map { |input| Entities::Method.cast!(input, direction: :input) }
+                end
+
+                def outputs
+                  @outputs ||= original_params.outputs.map { |output| Entities::Method.cast!(output, direction: :output) }
+                end
+
+                def index
+                  @index ||= original_params.index
+                end
+
+                def container
+                  @container ||= Entities::Service.cast!(original_params.container)
+                end
+
+                def organizer
+                  @organizer ||= original_params.organizer
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_steps/entities/step/commands/extract_params.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Step
+            module Commands
+              class ExtractParams < Support::Command
+                attr_reader :args, :kwargs
+
+                def initialize(args:, kwargs:)
+                  @args = args
+                  @kwargs = kwargs
+                end
+
+                def call
+                  Structs::Params.new(
+                    service: args.first,
+                    inputs: Utils::Array.wrap(kwargs[:in]),
+                    outputs: Utils::Array.wrap(kwargs[:out]),
+                    index: kwargs[:index],
+                    ##
+                    # TODO: Specs.
+                    #
+                    container: kwargs[:container],
+                    organizer: kwargs[:organizer]
+                  )
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "commands/extract_params"
+require_relative "commands/cast_params"

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Step
+            module Concern
+              module InstanceMethods
+                include Support::Copyable
+                include Support::Delegate
+
+                delegate \
+                  :success?,
+                  :failure?,
+                  :error?,
+                  :not_success?,
+                  :not_failure?,
+                  :not_error?,
+                  to: :result
+
+                delegate \
+                  :service,
+                  :outputs,
+                  :index,
+                  :container,
+                  :organizer,
+                  to: :params
+
+                def initialize(*args, **kwargs)
+                  @args = args
+                  @kwargs = kwargs
+                end
+
+                def ==(other)
+                  return unless other.instance_of?(self.class)
+
+                  return false if service != other.service
+                  return false if inputs != other.inputs
+                  return false if outputs != other.outputs
+                  return false if index != other.index
+                  return false if container != other.container
+                  return false if organizer != other.organizer
+
+                  true
+                end
+
+                def has_organizer?
+                  Utils::Bool.to_bool(organizer)
+                end
+
+                def completed?
+                  Utils::Bool.to_bool(@completed)
+                end
+
+                def params
+                  @params ||= resolve_params
+                end
+
+                def inputs
+                  @inputs ||= params.inputs.map { |input| input.copy(overrides: {kwargs: {organizer: organizer}}) }
+                end
+
+                def input_values
+                  @input_values ||= calculate_input_values
+                end
+
+                def result
+                  @result ||= calculate_result
+                end
+
+                def validate!
+                  inputs.each { |input| input.validate_as_input_for_container!(container) }
+
+                  outputs.each { |output| output.validate_as_output_for_container!(container) }
+
+                  true
+                end
+
+                def define!
+                  outputs.each { |output| output.define_output_in_container!(container, index: index) }
+
+                  true
+                end
+
+                def to_args
+                  [service]
+                end
+
+                def to_kwargs
+                  {in: inputs, out: outputs, index: index, container: container, organizer: organizer}
+                end
+
+                private
+
+                attr_reader :args, :kwargs
+
+                def calculate_input_values
+                  assert_has_organizer!
+
+                  inputs.reduce({}) { |values, input| values.merge(input.key.to_sym => input.value) }
+                end
+
+                ##
+                # IMPORTANT: `service.result(**input_values)` is the reason, why services should have only kwargs as arguments.
+                #
+                def calculate_result
+                  assert_has_organizer!
+
+                  mark_as_completed!
+
+                  service.result(**input_values)
+                end
+
+                def resolve_params
+                  original_params = Commands::ExtractParams.call(args: args, kwargs: kwargs)
+
+                  Commands::CastParams.call(original_params: original_params)
+                end
+
+                def assert_has_organizer!
+                  return if has_organizer?
+
+                  raise Errors::StepHasNoOrganizer.new(step: self)
+                end
+
+                def mark_as_completed!
+                  @completed = true
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end