use_cases 0.3.8 → 1.0.12

data/lib/use_cases/module_optins/transactional.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module UseCases
+  module ModuleOptins
+    module Transactional
+      class TransactionHandlerUndefined < StandardError; end
+
+      class TransactionHandlerInvalid < StandardError; end
+
+      def self.included(base)
+        super
+        base.prepend DoCallPatch
+      end
+
+      module DoCallPatch
+        def do_call(*args)
+          unless respond_to?(:transaction_handler)
+            raise TransactionHandlerUndefined, "when using *transactional*, make sure to include a transaction handler in your dependencies."
+          end
+
+          raise TransactionHandlerInvalid, "Make sure your transaction_handler implements #transaction." unless transaction_handler.respond_to?(:transaction)
+
+          transaction_handler.transaction { super }
+        end
+      end
+    end
+  end
+end

data/lib/use_cases/module_optins/validated.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "dry/validation/contract"
+
+module UseCases
+  module ModuleOptins
+    module Validated
+      class NoValidationError < StandardError; end
+
+      def self.included(base)
+        super
+        base.class_eval do
+          extend DSL
+          extend ClassMethods
+          prepend CallPatch
+        end
+      end
+
+      module CallPatch
+        def call(*args)
+          unless stack.include_step?(:validate)
+            raise NoValidationError,
+                  "Make sure to define params validations by using *params*" \
+                  "*schema*, *json*, *rule* or *option* macros in your use case."
+          end
+
+          super
+        end
+      end
+
+      module DSL
+        def params(*args, &blk)
+          _setup_validation
+
+          _contract_class.params(*args, &blk)
+        end
+
+        def schema(*args, &blk)
+          _setup_validation
+
+          _contract_class.schema(*args, &blk)
+        end
+
+        def rule(*args, &blk)
+          _setup_validation
+
+          _contract_class.rule(*args, &blk)
+        end
+
+        def json(*args, &blk)
+          _setup_validation
+
+          _contract_class.json(*args, &blk)
+        end
+
+        def option(*args, &blk)
+          _contract_class.option(*args, &blk)
+        end
+      end
+
+      private
+
+      def validate(params, *_args)
+        return Failure([:validation_error, "*params* must be a hash."]) unless params.respond_to?(:merge)
+
+        validation = contract.call(params)
+
+        if validation.success?
+          params.merge!(validation.to_h)
+          Success(validation.to_h)
+        else
+          Failure([:validation_error, validation.errors.to_h])
+        end
+      end
+
+      def contract
+        return self.class._contract_class.new if self.class._contract_class_defined?
+      end
+
+      module ClassMethods
+        def _setup_validation
+          _define_contract_class unless _contract_class_defined?
+          _define_validation_step unless _validation_step_defined?
+        end
+
+        def _define_validation_step
+          step :validate
+        end
+
+        def _contract_class
+          self::Contract
+        end
+
+        def _define_contract_class
+          const_set(:Contract, Class.new(Dry::Validation::Contract))
+        end
+
+        def _contract_class_name
+          "#{name}::Contract"
+        end
+
+        def _contract_class_defined?
+          Object.const_defined? _contract_class_name
+        end
+
+        def _validation_step_defined?
+          __steps__.map(&:name).include?(:validate)
+        end
+      end
+    end
+  end
+end

data/lib/use_cases/module_optins.rb

@@ -1,39 +1,37 @@
 # frozen_string_literal: true
 
-require "use_cases/authorize"
-require "use_cases/prepare"
-require "use_cases/transaction"
-require "use_cases/validate"
+require "use_cases/module_optins/prepared"
+require "use_cases/module_optins/transactional"
+require "use_cases/module_optins/validated"
+require "use_cases/module_optins/publishing"
+require "use_cases/module_optins/authorized"
 
 module UseCases
   module ModuleOptins
     attr_accessor :options
 
+    OPTINS = {
+      authorized: Authorized,
+      transactional: Transactional,
+      validated: Validated,
+      prepared: Prepared,
+      publishing: Publishing
+    }
+
     def [](*options)
-      @modules = []
-      @modules << UseCases::Authorize if options.include?(:authorized)
-      @modules << UseCases::Transaction if options.include?(:transactional)
-      @modules << UseCases::Validate if options.include?(:validated)
-      @modules << UseCases::Prepare if options.include?(:prepared)
-      self
-    end
+      modules = [self]
 
-    def included(base)
-      super
-      @modules ||= []
-      return if @modules.empty?
+      OPTINS.each do |key, module_constant|
+        modules << module_constant if options.include?(key)
+      end
 
-      base.include(*@modules)
-      @modules = nil
-    end
+      supermodule = Module.new
 
-    def inherited(base)
-      super
-      @modules ||= []
-      return if @modules.empty?
+      supermodule.define_singleton_method(:included) do |base|
+        base.include(*modules)
+      end
 
-      base.include(*@modules)
-      @modules = nil
+      supermodule
     end
 
     def descendants

data/lib/use_cases/{step_result.rb → result.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module UseCases
-  class StepResult < Dry::Monads::Result
+  class Result < Dry::Monads::Result
     attr_reader :step, :result
 
     def initialize(step, result)
@@ -14,7 +14,7 @@ module UseCases
       return result if result_not_monad?
       return nil if result_empty?
 
-      result.success? ? result.value! : result
+      result.success? ? result.value! : result.failure
     end
     alias value! value
 
@@ -23,25 +23,23 @@ module UseCases
     end
 
     def failure?
-      value.is_a?(Dry::Monads::Result::Failure)
-    end
-
-    def failure
-      failure? && value.failure
+      result.is_a?(Dry::Monads::Result::Failure)
     end
 
     def success
       success? && value
     end
 
+    def failure
+      failure? && value
+    end
+
     def nil?
       value.nil?
     end
 
     def to_result
-      value.to_result if failure?
-
-      result
+      self
     end
 
     def result_empty?
@@ -51,5 +49,13 @@ module UseCases
     def result_not_monad?
       !result.is_a?(Dry::Monads::Result)
     end
+
+    def inspect
+      if failure?
+        "UseCases::Result.Failure(#{value.inspect})"
+      else
+        "UseCases::Result.Success(#{value.inspect})"
+      end
+    end
   end
 end

data/lib/use_cases/rspec/matchers.rb

@@ -38,13 +38,15 @@ RSpec::Matchers.define(:be_failure_with) do |*expected_failure|
     expect(test_subject.failure).to eql expected_failure
   end
 
+  expected_result, expected_code = expected_failure
+
   failure_message do |test_subject|
     if test_subject.failure?
-      "the use case was expected to fail with #{expected_result.inspect} but it returned #{test_subject.failure.inspect}"
+      "the use case was expected to fail with #{expected_code} and #{expected_result.inspect} but it returned #{test_subject.failure.inspect}"
     else
       "the use case was expected to fail but it succeeded with #{test_subject.success.inspect}"
     end
-  end    
+  end
 end
 
 RSpec::Matchers.define(:be_successful_with) do |expected_result|
@@ -59,5 +61,5 @@ RSpec::Matchers.define(:be_successful_with) do |expected_result|
     else
       "the use case was expected to succeed but it failed with #{test_subject.failure.inspect}"
     end
-  end    
+  end
 end

data/lib/use_cases/stack_runner.rb

@@ -8,9 +8,7 @@ module UseCases
       @stack = stack
     end
 
-    def call(*args, &around_block)
-      return around_block.call { do_call(*args) } if around_block
-
+    def call(*args)
       do_call(*args)
     end
 
@@ -19,7 +17,6 @@ module UseCases
     def do_call(*args)
       stack.call do
         result = _run_step(stack, args)
-
         return result if result.failure?
 
         result
@@ -28,29 +25,21 @@ module UseCases
 
     def _run_step(stack, args)
       step = stack.current_step
-      expected_args_count = step.args_count
-      step_args = _assert_step_arguments_with_count(stack, args)
+      step_args = _assert_step_arguments(stack, args)
 
       raise MissingStepError, "Missing ##{step.name} implementation." if step.missing?
 
-      if expected_args_count != step_args.count
-        raise StepArgumentError,
-              "##{step.name} expects #{expected_args_count} arguments it only received #{step_args.count}, make sure your previous step Success() statement has a payload."
-      end
-
       step.call(*step_args)
     end
 
-    def _assert_step_arguments_with_count(stack, args)
-      step_args_count = stack.current_step.args_count
-
+    def _assert_step_arguments(stack, args)
       if _should_prepend_previous_step_result_to_args?(stack)
         prev_step_result_value = stack.previous_step_value
 
         args = [prev_step_result_value] + args
       end
 
-      args.first(step_args_count)
+      args
     end
 
     def _should_prepend_previous_step_result_to_args?(stack)

data/lib/use_cases/step_active_job_adapter.rb

@@ -16,7 +16,7 @@ module UseCases
     def deserialize_step_arguments(args)
       args.map do |arg|
         if arg.is_a?(Hash) && arg.delete("_serialized_by_use_case")
-          arg.delete('_class').constantize.new(arg)
+          arg.delete("_class").constantize.new(arg)
         else
           arg
         end

data/lib/use_cases/step_adapters/abstract.rb

@@ -6,16 +6,6 @@ module UseCases
   module StepAdapters
     class Abstract
       include Dry::Monads
-
-      # include Dry::Events::Publisher[name || object_id]
-
-      # def self.inherited(subclass)
-      #   super
-      #   subclass.register_event(:step)
-      #   subclass.register_event(:step_succeeded)
-      #   subclass.register_event(:step_failed)
-      # end
-
       include Dry::Monads[:result]
 
       attr_reader :name, :object, :failure, :options
@@ -31,22 +21,11 @@ module UseCases
       end
 
       def call(*args)
-        around_call(name, args: args) do
-          before_call(name, args: args)
-
-          result = StepResult.new(self, do_call(*args))
-
-          if result.success?
-            after_call_success(name, args: args, value: result.value)
-          else
-            after_call_failure(name, args: args, value: result.value)
-          end
-
-          result
-        end
+        UseCases::Result.new(self, do_call(*args))
       end
 
-      def do_call(*args)
+      def do_call(*initial_args)
+        args = callable_args(initial_args)
         callable_proc.call(*args)
       end
 
@@ -54,45 +33,71 @@ module UseCases
         self.class.new(name, object, options)
       end
 
+      def callable_args(args)
+        if callable_args_count > args.count
+          raise StepArgumentError,
+                "##{step.name} expects #{expected_args_count} arguments it only received #{step_args.count}, make sure your previous step Success() statement has a payload."
+        end
+
+        return args.first(callable_args_count) unless external? && selects_external_args?
+
+        hashed_args(args).values
+      end
+
+      def hashed_args(args)
+        {
+          params: args.first,
+          current_user: args.last,
+          previous_step_result: args.last
+        }.slice(pass_option)
+      end
+
       def callable_proc
         callable_object.method(callable_method).to_proc
       end
 
       def callable_object
-        case options[:with]
+        case with_option
         when NilClass, FalseClass then object
-        when String, Symbol       then object.send(options[:with])
-        else                           options[:with]
+        when Symbol               then object.send(with_option)
+        when String               then UseCases.config.container[with_option]
+        else                           with_option
         end
       end
 
       def callable_method
-        case options[:with]
+        case with_option
         when NilClass, FalseClass then name
         else                           :call
         end
       end
 
-      def external?
-        options[:with].present?
+      def with_option
+        options[:with]
       end
 
-      def args_count
-        callable_proc.parameters.count
+      def pass_option
+        options[:pass]
       end
 
-      def missing?
-        !callable_object.respond_to?(callable_method, true)
+      def previous_input_param_name
+        options[:merge_input_as] || :input
       end
 
-      def before_call(*args); end
+      def external?
+        with_option.present?
+      end
 
-      def after_call_success(*args); end
+      def selects_external_args?
+        pass_option.present?
+      end
 
-      def after_call_failure(*args); end
+      def callable_args_count
+        callable_proc.parameters.count
+      end
 
-      def around_call(*_args, &blk)
-        blk.call
+      def missing?
+        !callable_object.respond_to?(callable_method, true)
       end
     end
   end

data/lib/use_cases/step_adapters.rb

@@ -11,6 +11,7 @@ require "use_cases/step_active_job_adapter"
 module UseCases
   module StepAdapters
     def self.included(base)
+      super
       base.class_eval do
         register_adapter StepAdapters::Step
         register_adapter StepAdapters::Tee

data/lib/use_cases/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module UseCases
-  VERSION = "0.3.8"
+  VERSION = "1.0.12"
 end

data/lib/use_cases.rb

@@ -1,11 +1,20 @@
 # frozen_string_literal: true
 
+require "dry/configurable"
+
 require_relative "use_case"
 require_relative "use_cases/version"
-require_relative "use_cases/base"
 
 module UseCases
-  def self.register_type(type_name, klass)
+  class StepArgumentError < ArgumentError; end
+
+  class MissingStepError < NoMethodError; end
+
+  class PreviousStepInvalidReturn < StandardError; end
+
+  extend Dry::Configurable
 
-  end
+  setting :container, reader: true
+  setting :publisher, default: ::UseCases::Events::Publisher, reader: true
+  setting :subscribers, default: [], reader: true
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: use_cases
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 1.0.12
 platform: ruby
 authors:
 - Ring Twice
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-06 00:00:00.000000000 Z
+date: 2022-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -145,30 +145,30 @@ files:
 - bin/setup
 - lib/use_case.rb
 - lib/use_cases.rb
-- lib/use_cases/authorize.rb
-- lib/use_cases/base.rb
 - lib/use_cases/dsl.rb
-- lib/use_cases/errors.rb
+- lib/use_cases/events/publish_job.rb
+- lib/use_cases/events/publisher.rb
+- lib/use_cases/events/subscriber.rb
 - lib/use_cases/module_optins.rb
-- lib/use_cases/notifications.rb
+- lib/use_cases/module_optins/authorized.rb
+- lib/use_cases/module_optins/prepared.rb
+- lib/use_cases/module_optins/publishing.rb
+- lib/use_cases/module_optins/transactional.rb
+- lib/use_cases/module_optins/validated.rb
 - lib/use_cases/params.rb
-- lib/use_cases/prepare.rb
+- lib/use_cases/result.rb
 - lib/use_cases/rspec/matchers.rb
 - lib/use_cases/stack.rb
 - lib/use_cases/stack_runner.rb
 - lib/use_cases/step_active_job_adapter.rb
 - lib/use_cases/step_adapters.rb
 - lib/use_cases/step_adapters/abstract.rb
-- lib/use_cases/step_adapters/authorize.rb
 - lib/use_cases/step_adapters/check.rb
 - lib/use_cases/step_adapters/enqueue.rb
 - lib/use_cases/step_adapters/map.rb
 - lib/use_cases/step_adapters/step.rb
 - lib/use_cases/step_adapters/tee.rb
 - lib/use_cases/step_adapters/try.rb
-- lib/use_cases/step_result.rb
-- lib/use_cases/transaction.rb
-- lib/use_cases/validate.rb
 - lib/use_cases/version.rb
 - use_cases.gemspec
 homepage: https://github.com/listminut/use_cases
@@ -193,7 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Use Cases

data/lib/use_cases/authorize.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module UseCases
-  module Authorize
-    class NoAuthorizationError < StandardError; end
-
-    def self.included(base)
-      base.class_eval do
-        extend DSL
-      end
-    end
-
-    module DSL
-      def authorize(step_name, options = {})
-        options[:failure] = :unauthorized
-        check step_name, **options
-      end
-    end
-  end
-end

data/lib/use_cases/base.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-require "use_case"
-module UseCases
-  class Base
-    include UseCase
-  end
-end

data/lib/use_cases/errors.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module UseCases
-  class StepArgumentError < ArgumentError; end
-
-  class MissingStepError < NoMethodError; end
-
-  class PreviousStepInvalidReturn < StandardError; end
-end

data/lib/use_cases/notifications.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module UseCases
-  module Notifications
-    def self.included(base)
-      base.extend DSL
-    end
-
-    module DSL
-      def subscribe_to_step(event_id, listener)
-        step_subscriptions << StepSubscription.new(event_id, listener)
-      end
-
-      def bind_step_subscriptions
-        step_subscriptions.each { |subscription| subscription.bind(__steps__) }
-      end
-
-      def step_subscriptions
-        @step_subscriptions ||= []
-      end
-    end
-
-    class StepSubscription
-      attr_reader :event_id, :listener, :steps
-
-      def initialize(event_id, listener)
-        @event_id = event_id
-        @listener = listener
-      end
-
-      def bind(steps)
-        @steps = steps
-
-        step = steps.find { |s| s.name == step_name }
-        step.subscribe(event_predicate, listener)
-      end
-
-      def event_predicate
-        predicate = event_id.to_s.gsub(step_name.to_s, "")
-
-        "step#{predicate}".to_sym
-      end
-
-      def step_name
-        steps.map(&:name).find { |step_name| step_name.start_with?(event_id.to_s) }
-      end
-    end
-  end
-end