convenient_service 0.1.0

data/lib/convenient_service/service/plugins/has_result_params_validations/using_active_model_validations.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "using_active_model_validations/concern"
+require_relative "using_active_model_validations/middleware"

data/lib/convenient_service/service/plugins/has_result_params_validations/using_dry_validation/concern.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultParamsValidations
+        module UsingDryValidation
+          module Concern
+            include Support::Concern
+
+            class_methods do
+              def contract(&block)
+                (@contract ||= ::Class.new(::Dry::Validation::Contract))
+                  .tap { |contract| contract.class_exec(&block) if block }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_params_validations/using_dry_validation/middleware.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultParamsValidations
+        module UsingDryValidation
+          class Middleware < Core::MethodChainMiddleware
+            def next(...)
+              return entity.failure(data: errors) if errors.any?
+
+              chain.next(...)
+            end
+
+            private
+
+            ##
+            # NOTE: An example of `Dry::Validation::Contract` usage.
+            # https://dry-rb.org/gems/dry-validation/1.8/#quick-start
+            #
+            # TODO: Return one or all errors?
+            #
+            def errors
+              @errors ||=
+                entity
+                  .class
+                  .contract
+                  .new
+                  .call(**entity.constructor_params.kwargs)
+                  .errors
+                  .to_h
+                  .transform_values(&:first)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_params_validations/using_dry_validation.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "using_dry_validation/concern"
+require_relative "using_dry_validation/middleware"

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultShortSyntax
+        module Concern
+          include Support::Concern
+
+          class_methods do
+            ##
+            # @internal
+            #   NOTE: Delegates to `result` instead of aliasing in order to have an ability
+            #   to use the same RSpec stubs for short and usual syntax.
+            #
+            #   For example:
+            #
+            #     allow(Service).to receive(:result).with(foo: :bar).and_call_original
+            #
+            #   works for both `Service.result(foo: :bar)` and `Service[foo: :bar]`.
+            #
+            def [](...)
+              result(...)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_short_syntax/error/commands/assert_args_count_lower_than_three.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultShortSyntax
+        module Error
+          module Commands
+            class AssertArgsCountLowerThanThree < Support::Command
+              attr_reader :args
+
+              def initialize(args:)
+                @args = args
+              end
+
+              def call
+                raise Errors::MoreThanTwoArgsArePassed.new if args.size > 2
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_short_syntax/error/commands/assert_either_args_or_kwargs_are_passed.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultShortSyntax
+        module Error
+          module Commands
+            class AssertEitherArgsOrKwargsArePassed < Support::Command
+              attr_reader :args, :kwargs
+
+              def initialize(args:, kwargs:)
+                @args = args
+                @kwargs = kwargs
+              end
+
+              def call
+                raise Errors::BothArgsAndKwargsArePassed.new if args.any? && kwargs.any?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_short_syntax/error/commands.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "commands/assert_args_count_lower_than_three"
+require_relative "commands/assert_either_args_or_kwargs_are_passed"

data/lib/convenient_service/service/plugins/has_result_short_syntax/error/errors.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultShortSyntax
+        module Error
+          module Errors
+            class BothArgsAndKwargsArePassed < ::ConvenientService::Error
+              def initialize
+                message = <<~TEXT
+                  Both `args` and `kwargs` are passed to the `error` method.
+
+                  Did you mean something like:
+
+                  error("Helpful text")
+                  error("Helpful text", :descriptive_code)
+
+                  error(message: "Helpful text")
+                  error(message: "Helpful text", code: :descriptive_code)
+                TEXT
+
+                super(message)
+              end
+            end
+
+            class MoreThanTwoArgsArePassed < ::ConvenientService::Error
+              def initialize
+                message = <<~TEXT
+                  More than two `args` are passed to the `error` method.
+
+                  Did you mean something like:
+
+                  error("Helpful text")
+                  error("Helpful text", :descriptive_code)
+                TEXT
+
+                super(message)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_short_syntax/error/middleware.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultShortSyntax
+        module Error
+          class Middleware < Core::MethodChainMiddleware
+            def next(*args, **kwargs)
+              Commands::AssertEitherArgsOrKwargsArePassed.call(args: args, kwargs: kwargs)
+
+              return chain.next(**kwargs) if kwargs.any?
+
+              Commands::AssertArgsCountLowerThanThree.call(args: args)
+
+              return chain.next if args.none?
+
+              return chain.next(message: args.first) if args.one?
+
+              chain.next(message: args.first, code: args.last) # NOTE: if args.count == 2
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_short_syntax/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "error/commands"
+require_relative "error/errors"
+require_relative "error/middleware"

data/lib/convenient_service/service/plugins/has_result_short_syntax/failure/commands/refute_kwargs_contain_data_and_extra_keys.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultShortSyntax
+        module Failure
+          module Commands
+            class RefuteKwargsContainDataAndExtraKeys < Support::Command
+              attr_reader :kwargs
+
+              def initialize(kwargs:)
+                @kwargs = kwargs
+              end
+
+              def call
+                return unless kwargs.has_key?(:data)
+
+                return if kwargs.keys.one?
+
+                raise Errors::KwargsContainDataAndExtraKeys.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_short_syntax/failure/commands.rb

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

data/lib/convenient_service/service/plugins/has_result_short_syntax/failure/errors.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultShortSyntax
+        module Failure
+          module Errors
+            class KwargsContainDataAndExtraKeys < ::ConvenientService::Error
+              def initialize
+                message = <<~TEXT
+                  `kwargs` passed to `failure` method contain `data` and extra keys. That's NOT allowed.
+
+                  Please, consider something like:
+
+                  failure(foo: :bar)
+                  failure(data: {foo: :bar})
+                TEXT
+
+                super(message)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_short_syntax/failure/middleware.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultShortSyntax
+        module Failure
+          class Middleware < Core::MethodChainMiddleware
+            def next(**kwargs)
+              Commands::RefuteKwargsContainDataAndExtraKeys.call(kwargs: kwargs)
+
+              kwargs.has_key?(:data) ? chain.next(**kwargs) : chain.next(data: kwargs)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_short_syntax/failure.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "failure/commands"
+require_relative "failure/errors"
+require_relative "failure/middleware"

data/lib/convenient_service/service/plugins/has_result_short_syntax/success/commands/refute_kwargs_contain_data_and_extra_keys.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultShortSyntax
+        module Success
+          module Commands
+            class RefuteKwargsContainDataAndExtraKeys < Support::Command
+              attr_reader :kwargs
+
+              def initialize(kwargs:)
+                @kwargs = kwargs
+              end
+
+              def call
+                return unless kwargs.has_key?(:data)
+
+                return if kwargs.keys.one?
+
+                raise Errors::KwargsContainDataAndExtraKeys.new
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_short_syntax/success/commands.rb

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

data/lib/convenient_service/service/plugins/has_result_short_syntax/success/errors.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultShortSyntax
+        module Success
+          module Errors
+            class KwargsContainDataAndExtraKeys < ::ConvenientService::Error
+              def initialize
+                message = <<~TEXT
+                  `kwargs` passed to `success` method contain `data` and extra keys. That's NOT allowed.
+
+                  Please, consider something like:
+
+                  success(foo: :bar)
+                  success(data: {foo: :bar})
+                TEXT
+
+                super(message)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_short_syntax/success/middleware.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultShortSyntax
+        module Success
+          class Middleware < Core::MethodChainMiddleware
+            def next(**kwargs)
+              Commands::RefuteKwargsContainDataAndExtraKeys.call(kwargs: kwargs)
+
+              kwargs.has_key?(:data) ? chain.next(**kwargs) : chain.next(data: kwargs)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/has_result_short_syntax/success.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "success/commands"
+require_relative "success/errors"
+require_relative "success/middleware"

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "has_result_short_syntax/concern"
+require_relative "has_result_short_syntax/success"
+require_relative "has_result_short_syntax/failure"
+require_relative "has_result_short_syntax/error"

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Commands
+          class CreateStepClass < Support::Command
+            attr_reader :service_class
+
+            def initialize(service_class:)
+              @service_class = service_class
+            end
+
+            def call
+              step_class.include Entities::Step::Concern
+
+              ##
+              # class Step < ConvenientService::Service::Plugins::HasResultSteps::Entities::Step # or just `class Step` if service class defines its own.
+              #   include ConvenientService::Service::Plugins::HasResultSteps::Entities::Step::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
+              #
+              step_class.class_exec(service_class) do |service_class|
+                define_singleton_method(:service_class) { service_class }
+
+                ##
+                # TODO: Fix a bug with `ap`.
+                #
+                define_singleton_method(:==) { |other| self.service_class == other.service_class if other.instance_of?(self.class) }
+              end
+
+              step_class
+            end
+
+            private
+
+            def step_class
+              @step_class ||= Utils::Module.get_own_const(service_class, :Step) || ::Class.new(Entities::Step)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Concern
+          include Support::Concern
+
+          instance_methods do
+            def steps
+              @steps ||=
+                self.class
+                  .steps
+                  .tap(&:commit!)
+                  .map { |step| step.copy(overrides: {kwargs: {organizer: self}}) }
+            end
+
+            ##
+            # TODO: Create for callbacks.
+            #
+            #   def step(step_result)
+            #     step_result
+            #   end
+            #
+          end
+
+          class_methods do
+            def step(*args, **kwargs)
+              step_class.new(*args, **kwargs.merge(container: self))
+                .tap { |step_instance| steps << step_instance }
+            end
+
+            ##
+            # NOTE: Allows to pass a value to `in` method without processing it.
+            #
+            def raw(value)
+              Entities::Method::Entities::Values::Raw.wrap(value)
+            end
+
+            def steps
+              @steps ||= Entities::StepCollection.new
+            end
+
+            def step_class
+              @step_class ||= Commands::CreateStepClass.call(service_class: self)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Service
+    module Plugins
+      module HasResultSteps
+        module Entities
+          class Method
+            module Commands
+              class CastMethod < Support::Command
+                attr_reader :other, :options
+
+                def initialize(other:, options:)
+                  @other = other
+                  @options = options
+                end
+
+                def call
+                  return unless key
+                  return unless name
+                  return unless caller
+                  return unless direction
+
+                  ##
+                  # https://en.wikipedia.org/wiki/Composition_over_inheritance
+                  #
+                  Method.new(key: key, name: name, caller: caller, direction: direction)
+                end
+
+                private
+
+                def key
+                  @key ||= Commands::CastMethodKey.call(other: other, options: options)
+                end
+
+                def name
+                  @name ||= Commands::CastMethodName.call(other: other, options: options)
+                end
+
+                def caller
+                  @caller ||= Commands::CastMethodCaller.call(other: other, options: options)
+                end
+
+                def direction
+                  @direction ||= Commands::CastMethodDirection.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/commands/cast_method_caller.rb

@@ -0,0 +1,67 @@
+# 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 CastMethodCaller < Support::Command
+                attr_reader :other, :options
+
+                def initialize(other:, options:)
+                  @other = other
+                  @options = options
+                end
+
+                def call
+                  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::Callers::Usual.new(other)
+                end
+
+                def cast_string
+                  Entities::Callers::Usual.new(other)
+                end
+
+                def cast_hash
+                  return unless other.keys.one?
+
+                  value = other.values.first
+
+                  case value
+                  when ::Symbol
+                    Entities::Callers::Alias.new(value)
+                  when ::String
+                    Entities::Callers::Alias.new(value)
+                  when ::Proc
+                    Entities::Callers::Proc.new(value)
+                  when Entities::Values::Raw
+                    Entities::Callers::Raw.new(value)
+                  end
+                end
+
+                def cast_method
+                  other.caller.copy
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end