convenient_service 0.1.0

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanRecalculateResult
+        module Concern
+          include Support::Concern
+
+          ##
+          # NOTE: `CanRecalculateResult` plugin expects that `CanBeCopied` plugin is already included.
+          # That is why `copy` method is available.
+          #
+          # NOTE: `CanRecalculateResult` plugin expects that `HasResult` plugin is already included.
+          # That is why `result` method is available.
+          #
+          instance_methods do
+            def recalculate_result
+              copy.result
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/can_recalculate_result.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "can_recalculate_result/concern"

data/lib/convenient_service/service/plugins/has_result/commands/create_result_class.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Commands
+          class CreateResultClass < Support::Command
+            attr_reader :service_class
+
+            def initialize(service_class:)
+              @service_class = service_class
+            end
+
+            def call
+              result_class.include Entities::Result::Concern
+
+              ##
+              # class Result < ConvenientService::Service::Plugins::HasResult::Entities::Result # or just `class Result` if service class defines its own.
+              #   include ConvenientService::Service::Plugins::HasResult::Entities::Result::Concern
+              #
+              #   class << self
+              #     def service_class
+              #       ##
+              #       # NOTE: Returns `service_class` passed to `CreateResultClass`.
+              #       #
+              #       service_class
+              #     end
+              #
+              #     def ==(other)
+              #       return unless other.instance_of?(self.class)
+              #
+              #       self.service_class == other.service_class
+              #     end
+              #   end
+              # end
+              #
+              result_class.class_exec(service_class) do |service_class|
+                define_singleton_method(:service_class) { service_class }
+                define_singleton_method(:==) { |other| self.service_class == other.service_class if other.instance_of?(self.class) }
+              end
+
+              result_class
+            end
+
+            private
+
+            def result_class
+              @result_class ||= Utils::Module.get_own_const(service_class, :Result) || ::Class.new(Entities::Result)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result/commands.rb

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

data/lib/convenient_service/service/plugins/has_result/concern/class_methods.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Concern
+          module ClassMethods
+            ##
+            #
+            #
+            def result(...)
+              new(...).result
+            end
+
+            ##
+            # https://ruby-doc.org/core-2.5.0/Class.html#method-i-allocate
+            # https://frontdeveloper.pl/2018/11/ruby-allocate-method/
+            #
+            def new_without_initialize
+              allocate
+            end
+
+            ##
+            # NOTE: This method is internally used by custom RSpec helper `stub_service`. It should NOT be used in the client code.
+            #
+            def success(
+              service: Constants::DEFAULT_SERVICE_INSTANCE,
+              data: Constants::DEFAULT_SUCCESS_DATA
+            )
+              result_class.new(
+                service: service,
+                status: Constants::SUCCESS_STATUS,
+                data: data,
+                message: Constants::SUCCESS_MESSAGE,
+                code: Constants::SUCCESS_CODE
+              )
+            end
+
+            ##
+            # NOTE: This method is internally used by custom RSpec helper `stub_service`. It should NOT be used in the client code.
+            #
+            def failure(
+              service: Constants::DEFAULT_SERVICE_INSTANCE,
+              data: Constants::DEFAULT_FAILURE_DATA,
+              message: data.any? ? data.first.join(" ") : Constants::DEFAULT_FAILURE_MESSAGE
+            )
+              result_class.new(
+                service: service,
+                status: Constants::FAILURE_STATUS,
+                data: data,
+                message: message,
+                code: Constants::FAILURE_CODE
+              )
+            end
+
+            ##
+            # NOTE: This method is internally used by custom RSpec helper `stub_service`. It should NOT be used in the client code.
+            #
+            def error(
+              service: Constants::DEFAULT_SERVICE_INSTANCE,
+              message: Constants::DEFAULT_ERROR_MESSAGE,
+              code: Constants::DEFAULT_ERROR_CODE
+            )
+              result_class.new(
+                service: service,
+                status: Constants::ERROR_STATUS,
+                data: Constants::ERROR_DATA,
+                message: message,
+                code: code
+              )
+            end
+
+            def result_class
+              @result_class ||= Commands::CreateResultClass.call(service_class: self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result/concern/instance_methods.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Concern
+          module InstanceMethods
+            def result
+              raise Errors::ResultIsNotOverridden.new(service: self)
+            end
+
+            ##
+            # TODO: Specs.
+            #
+            def success(**kwargs)
+              self.class.success(**kwargs.merge(service: self))
+            end
+
+            def failure(**kwargs)
+              self.class.failure(**kwargs.merge(service: self))
+            end
+
+            def error(**kwargs)
+              self.class.error(**kwargs.merge(service: self))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "concern/instance_methods"
+require_relative "concern/class_methods"
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Concern
+          include Support::Concern
+
+          included do |service_class|
+            service_class.include InstanceMethods
+
+            service_class.extend ClassMethods
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result/constants.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Constants
+          ##
+          # TODO: Consider to include `::ConvenientService::Configs::Minimal`
+          #
+          DEFAULT_SERVICE_CLASS = ::Class.new { include ::ConvenientService::Core }
+          DEFAULT_SERVICE_INSTANCE = DEFAULT_SERVICE_CLASS.new
+
+          SUCCESS_STATUS = :success
+          FAILURE_STATUS = :failure
+          ERROR_STATUS = :error
+
+          DEFAULT_SUCCESS_DATA = {}
+          DEFAULT_FAILURE_DATA = {}
+          ERROR_DATA = {}
+
+          SUCCESS_MESSAGE = ""
+          DEFAULT_FAILURE_MESSAGE = ""
+          DEFAULT_ERROR_MESSAGE = ""
+
+          SUCCESS_CODE = :success
+          FAILURE_CODE = :failure
+          DEFAULT_ERROR_CODE = :default_error
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result/entities/result/commands/cast_result_params.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Entities
+          class Result
+            module Commands
+              class CastResultParams < Support::Command
+                attr_reader :params
+
+                def initialize(params:)
+                  @params = params
+                end
+
+                def call
+                  Structs::ResultParams.new(
+                    service: params[:service],
+                    status: Entities::Status.cast!(params[:status]),
+                    data: Entities::Data.cast!(params[:data]),
+                    message: Entities::Message.cast!(params[:message]),
+                    code: Entities::Code.cast!(params[:code])
+                  )
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result/entities/result/commands.rb

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

data/lib/convenient_service/service/plugins/has_result/entities/result/concern/instance_methods.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Entities
+          class Result
+            module Concern
+              ##
+              # TODO: How to use concern outside?
+              #
+              module InstanceMethods
+                include Support::Delegate
+                include Support::Copyable
+
+                delegate \
+                  :service,
+                  :status,
+                  :data,
+                  :message,
+                  :code,
+                  to: :params
+
+                delegate \
+                  :success?,
+                  :failure?,
+                  :error?,
+                  :not_success?,
+                  :not_failure?,
+                  :not_error?,
+                  to: :status
+
+                def initialize(**params)
+                  @params = Commands::CastResultParams.call(params: params)
+                end
+
+                def ==(other)
+                  return unless other.instance_of?(self.class)
+
+                  return false if service.class != other.service.class
+                  return false if status != other.status
+                  return false if data != other.data
+                  return false if message != other.message
+                  return false if code != other.code
+
+                  true
+                end
+
+                def to_kwargs
+                  {service: service, status: status, data: data, message: message, code: code}
+                end
+
+                private
+
+                attr_reader :params
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result/entities/result/concern.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "concern/instance_methods"
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Entities
+          class Result
+            module Concern
+              include Support::Concern
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result/entities/result/entities/code/class_methods.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Entities
+          class Result
+            module Entities
+              class Code
+                module ClassMethods
+                  def cast(other)
+                    case other
+                    when ::String
+                      new(value: other.to_sym)
+                    when ::Symbol
+                      new(value: other)
+                    when Code
+                      new(value: other.value)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result/entities/result/entities/code.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "code/class_methods"
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Entities
+          class Result
+            module Entities
+              class Code
+                include Support::Castable
+
+                extend ClassMethods
+
+                attr_reader :value
+
+                def initialize(value:)
+                  @value = value
+                end
+
+                def ==(other)
+                  casted = cast(other)
+
+                  return unless casted
+
+                  value == casted.value
+                end
+
+                def to_s
+                  @to_s ||= value.to_s
+                end
+
+                def to_sym
+                  @to_sym ||= value.to_sym
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result/entities/result/entities/data/class_methods.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Entities
+          class Result
+            module Entities
+              class Data
+                module ClassMethods
+                  def cast(other)
+                    case other
+                    when ::Hash
+                      new(value: other.transform_keys(&:to_sym))
+                    when Data
+                      new(value: other.value)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "data/class_methods"
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Entities
+          class Result
+            module Entities
+              class Data
+                include Support::Castable
+
+                extend ClassMethods
+
+                attr_reader :value
+
+                def initialize(value:)
+                  @value = value
+                end
+
+                def ==(other)
+                  casted = cast(other)
+
+                  return unless casted
+
+                  value == casted.value
+                end
+
+                def [](key)
+                  value.fetch(key.to_sym) { raise Errors::NotExistingAttribute.new(attribute: key) }
+                end
+
+                def to_h
+                  @to_h ||= value.to_h
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result/entities/result/entities/message/class_methods.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Entities
+          class Result
+            module Entities
+              class Message
+                module ClassMethods
+                  def cast(other)
+                    case other
+                    when ::String
+                      new(value: other)
+                    when ::Symbol
+                      new(value: other.to_s)
+                    when Message
+                      new(value: other.value)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result/entities/result/entities/message.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "message/class_methods"
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Entities
+          class Result
+            module Entities
+              class Message
+                include Support::Castable
+
+                extend ClassMethods
+
+                attr_reader :value
+
+                def initialize(value:)
+                  @value = value
+                end
+
+                def ==(other)
+                  casted = cast(other)
+
+                  return unless casted
+
+                  value == casted.value
+                end
+
+                def to_s
+                  @to_s ||= value.to_s
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result/entities/result/entities/status/class_methods.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResult
+        module Entities
+          class Result
+            module Entities
+              class Status
+                module ClassMethods
+                  def cast(other)
+                    case other
+                    when ::String
+                      new(value: other.to_sym)
+                    when ::Symbol
+                      new(value: other)
+                    when Status
+                      new(value: other.value)
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end