convenient_service 0.1.0

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "concern/instance_methods"
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Step
+            module Concern
+              include Support::Concern
+
+              included do |step_class|
+                step_class.include InstanceMethods
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Errors
+          class StepHasNoOrganizer < ConvenientService::Error
+            def initialize(step:)
+              message = <<~TEXT
+                Step `#{step.service}` has not assigned organizer.
+
+                Did you forget to set it?
+              TEXT
+
+              super(message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_steps/entities/step/structs/params.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Step
+            module Structs
+              Params = ::Struct.new(:service, :inputs, :outputs, :index, :container, :organizer, keyword_init: true)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "structs/params"

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

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

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class StepCollection
+            include ::Enumerable
+
+            attr_reader :steps
+
+            def initialize
+              @steps = []
+            end
+
+            ##
+            # TODO: Specs.
+            #
+            def commit!
+              return false if committed?
+
+              steps.each { |step| step.validate! && step.define! }.freeze
+
+              true
+            end
+
+            ##
+            # TODO: Specs.
+            #
+            def committed?
+              steps.frozen?
+            end
+
+            def each(&block)
+              steps.each(&block)
+            end
+
+            def <<(step)
+              steps << step.copy(overrides: {kwargs: {index: next_available_index}})
+            end
+
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              return false if steps != other.steps
+
+              true
+            end
+
+            private
+
+            def next_available_index
+              steps.size
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "entities/service"
+require_relative "entities/method"
+require_relative "entities/step_collection"
+require_relative "entities/step"

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        class Middleware < Core::MethodChainMiddleware
+          def next(...)
+            return chain.next(...) if entity.steps.none?
+
+            last_step.result
+          end
+
+          private
+
+          def last_step
+            ##
+            # TODO: Use `entity.steps.find { |step| step.result.tap { |result| entity.step(result) }.not_success? }` for callbacks.
+            #
+            @last_step ||= entity.steps.find(&:not_success?) || entity.steps.last
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "has_result_steps/commands"
+require_relative "has_result_steps/concern"
+require_relative "has_result_steps/middleware"
+require_relative "has_result_steps/entities"

data/lib/convenient_service/service/plugins/raises_on_double_result/errors.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module RaisesOnDoubleResult
+        module Errors
+          class DoubleResult < ConvenientService::Error
+            def initialize(service:)
+              message = <<~TEXT
+                `#{service.class}` service has a double result.
+
+                Make sure its #result calls only one from the following methods `success`, `failure`, or `error` and only once.
+
+                Maybe you missed `return`? The most common scenario is similar to this one:
+
+                def result
+                  # ...
+
+                  error unless valid?
+                  # instead of return error unless valid?
+
+                  success
+                end
+              TEXT
+
+              super(message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/raises_on_double_result/middleware.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module RaisesOnDoubleResult
+        class Middleware < Core::MethodChainMiddleware
+          def next(...)
+            refute_has_result! || mark_as_has_result!
+
+            chain.next(...)
+          end
+
+          private
+
+          ##
+          # NOTE: `refute` is `!assert`.
+          # https://docs.seattlerb.org/minitest
+          #
+          def refute_has_result!
+            return unless entity.internals.cache.exist?(:has_result)
+
+            raise Errors::DoubleResult.new(service: entity)
+          end
+
+          def mark_as_has_result!
+            entity.internals.cache.write(:has_result, true)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "raises_on_double_result/errors"
+require_relative "raises_on_double_result/middleware"

data/lib/convenient_service/service/plugins/wraps_result_in_db_transaction/middleware.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module WrapsResultInDbTransaction
+        class Middleware < Core::MethodChainMiddleware
+          def next(...)
+            ::ActiveRecord::Base.transaction { chain.next(...) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "wraps_result_in_db_transaction/middleware"

data/lib/convenient_service/service/plugins.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+##
+# NOTE: Order matters.
+#
+require_relative "plugins/can_recalculate_result"
+require_relative "plugins/has_result"
+require_relative "plugins/has_result_method_steps"
+require_relative "plugins/has_result_short_syntax"
+require_relative "plugins/has_result_steps"
+require_relative "plugins/raises_on_double_result"
+require_relative "plugins/wraps_result_in_db_transaction"
+
+require_relative "plugins/aliases"

data/lib/convenient_service/service.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "service/plugins"

data/lib/convenient_service/specification.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Specification
+    NAME = "convenient_service"
+
+    AUTHORS = ["Marian Kostyk"].freeze
+
+    EMAIL = ["mariankostyk13895@gmail.com"].freeze
+
+    HOMEPAGE = "https://github.com/marian13/convenient_service"
+
+    SUMMARY = <<~TEXT
+      Service object pattern implementation in Ruby.
+    TEXT
+
+    DESCRIPTION = <<~TEXT
+      Yet another approach to revisit the service object pattern in Ruby, but this time focusing on the unique, opinionated, moderately obtrusive, but not mandatory features.
+    TEXT
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module AbstractMethod
+      module Errors
+        class AbstractMethodNotOverridden < ::StandardError
+          def initialize(instance:, method:)
+            klass = instance.is_a?(::Class) ? instance : instance.class
+            method_type = Utils::Object.resolve_type(instance)
+
+            message = <<~TEXT
+              `#{klass}` should implement abstract #{method_type} method `#{method}`.
+            TEXT
+
+            super(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/abstract_method.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "abstract_method/errors"
+
+module ConvenientService
+  module Support
+    module AbstractMethod
+      include Support::Concern
+
+      class_methods do
+        def abstract_method(*names)
+          names.each do |name|
+            define_method(name) do |*args, **kwargs, &block|
+              raise Errors::AbstractMethodNotOverridden.new(instance: self, method: name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module Castable
+      module Errors
+        class CastIsNotOverridden < ::StandardError
+          def initialize(klass:)
+            message = <<~TEXT
+              Cast method (.cast) of `#{klass}` is NOT overridden.
+            TEXT
+
+            super(message)
+          end
+        end
+
+        class FailedToCast < ::StandardError
+          def initialize(other:, klass:)
+            message = <<~TEXT
+              Failed to cast `#{other.inspect}` into `#{klass}`.
+            TEXT
+
+            super(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/castable.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "castable/errors"
+
+module ConvenientService
+  module Support
+    ##
+    # TODO: Specs for options.
+    #
+    module Castable
+      include Support::Concern
+
+      instance_methods do
+        private
+
+        def cast(...)
+          self.class.cast(...)
+        end
+
+        def cast!(...)
+          self.class.cast!(...)
+        end
+      end
+
+      class_methods do
+        ##
+        # @internal
+        #   TODO: `include Support::Castable` also extends `Support::AbstractMethod`. Is there a way to avoid such behavior?
+        #
+        include Support::AbstractMethod
+
+        abstract_method :cast
+
+        def cast!(other, **options)
+          casted = cast(other, **options)
+
+          raise Errors::FailedToCast.new(other: other, klass: self) unless casted
+
+          casted
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/command.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    ##
+    # @abstract Subclass and override {#initialize} and {#call} to implement a Command.
+    #
+    class Command
+      class << self
+        ##
+        # TODO: Specs.
+        #
+        def call(...)
+          new(...).call
+        end
+      end
+
+      ##
+      # TODO: Specs. Raise error if not overridden.
+      #
+      def call
+      end
+    end
+  end
+end

data/lib/convenient_service/support/concern.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module Concern
+      def self.included(klass)
+        klass.extend Dependencies::Extractions::ActiveSupportConcern::Concern
+      end
+    end
+  end
+end

data/lib/convenient_service/support/copyable.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module Copyable
+      ##
+      # @example
+      #   person = Person.new('John', 'Doe', age: 42, gender: :male) do |p|
+      #     puts p
+      #   end
+      #
+      #   copy = person.copy
+      #   copy = person.copy(overrides: {args: ['Jane']})
+      #   copy = person.copy(overrides: {args: {0 => 'Jane'}})
+      #   copy = person.copy(overrides: {kwargs: {age: 18}})
+      #   copy = person.copy(overrides: {block: proc { |p| print p }})
+      #
+      # NOTE: Inline logic instead of private methods is used intentionally in order to NOT pollute the public interface.
+      # NOTE: This method is NOT likely to be ever changed, that is why inline logic is preferred over command classes in this particular case.
+      #
+      def copy(overrides: {})
+        overrides[:args] ||= {}
+        overrides[:kwargs] ||= {}
+
+        ##
+        # TODO: Refactor runtime `respond_to?`. Investigate before refactoring.
+        #
+        args =
+          if respond_to?(:to_args)
+            case overrides[:args]
+            when ::Array
+              overrides[:args]
+            when ::Hash
+              Utils::Array.merge(to_args, overrides[:args])
+            end
+          else
+            []
+          end
+
+        kwargs =
+          if respond_to?(:to_kwargs)
+            to_kwargs.merge(overrides[:kwargs])
+          else
+            {}
+          end
+
+        block =
+          if respond_to?(:to_block)
+            overrides[:block] || to_block
+          end
+
+        self.class.new(*args, **kwargs, &block)
+      end
+    end
+  end
+end

data/lib/convenient_service/support/delegate.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    ##
+    # A wrapper for Ruby's stdlib `::Forwardable` module.
+    # https://ruby-doc.org/stdlib-2.5.1/libdoc/forwardable/rdoc/Forwardable.html
+    #
+    # Tries to follow Rails `delegate` interface.
+    # https://api.rubyonrails.org/classes/Module.html#method-i-delegate
+    #
+    module Delegate
+      include Support::Concern
+
+      included do
+        extend ::Forwardable
+
+        extend ClassMethodsForForwardable
+      end
+
+      ##
+      # `ClassMethods` is loaded faster than `included` by `Concern`.
+      # Since `Forwardable` has it own `delegate` - a different name is used.
+      #
+      module ClassMethodsForForwardable
+        def delegate(*methods, to:)
+          ##
+          # NOTE: The following condition will NOT ever change. That is why it is inlined.
+          #
+          receiver =
+            if to == :class
+              :"self.class"
+            else
+              to
+            end
+
+          def_delegators receiver, *methods
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/support/finite_loop.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Support
+    module FiniteLoop
+      MAX_ITERATION_COUNT = 1_000
+
+      module Errors
+        class MaxIterationCountExceeded < ::StandardError
+          def initialize(limit:)
+            message = <<~TEXT
+              Max iteration count is exceeded. Current limit is #{limit}.
+
+              Consider using `max_iteration_count` or `raise_on_exceedance` options if that is not the expected behavior.
+            TEXT
+
+            super(message)
+          end
+        end
+
+        class NoBlockGiven < ::StandardError
+          def initialize
+            message = <<~TEXT
+              `finite_loop` always expects a block to be given.
+            TEXT
+
+            super(message)
+          end
+        end
+      end
+
+      private
+
+      def finite_loop(max_iteration_count: MAX_ITERATION_COUNT, raise_on_exceedance: true, &block)
+        raise Errors::NoBlockGiven.new unless block
+
+        loop.with_index do |_, index|
+          if index >= max_iteration_count
+            break unless raise_on_exceedance
+
+            raise Errors::MaxIterationCountExceeded.new(limit: max_iteration_count)
+          end
+
+          block.call(index)
+        end
+      end
+    end
+  end
+end