use_cases 0.2.5

data/lib/use_case.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+require "dry/events"
+require "dry/monads/do"
+require "dry/monads/do/all"
+require "dry/matcher/result_matcher"
+
+require "use_cases/authorize"
+require "use_cases/dsl"
+require "use_cases/errors"
+require "use_cases/validate"
+require "use_cases/stack"
+require "use_cases/params"
+require "use_cases/stack_runner"
+require "use_cases/step_result"
+require "use_cases/notifications"
+require "use_cases/prepare"
+require "use_cases/step_adapters"
+require "use_cases/module_optins"
+
+module UseCase
+  extend UseCases::ModuleOptins
+
+  def self.included(base)
+    super
+    base.class_eval do
+      include Dry::Monads[:result]
+      include Dry::Monads::Do.for(:call)
+      include Dry::Matcher.for(:call, with: Dry::Matcher::ResultMatcher)
+
+      extend UseCases::DSL
+      extend UseCases::ModuleOptins
+
+      include UseCases::StepAdapters
+      include UseCases::Notifications
+    end
+  end
+
+  attr_reader :stack
+
+  def initialize(*)
+    @stack = UseCases::Stack.new(self.class.__steps__).bind(self)
+    # self.class.bind_step_subscriptions
+  end
+
+  def call(params, current_user = nil)
+    params = UseCases::Params.new(params)
+    do_call(params, current_user)
+  end
+
+  private
+
+  def do_call(*args)
+    UseCases::StackRunner.new(stack).call(*args)
+  end
+end

data/lib/use_cases/authorize.rb

@@ -0,0 +1,20 @@
+# 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

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

data/lib/use_cases/dsl.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "active_support/inflector/methods"
+
+module UseCases
+  module DSL
+    include ActiveSupport::Inflector
+
+    def register_adapter(step_class)
+      step_name = underscore(demodulize(step_class.name))
+
+      define_singleton_method(step_name) do |name, options = {}|
+        __steps__ << step_class.new(name, nil, options)
+      end
+    end
+
+    def __steps__
+      @__steps__ ||= []
+    end
+
+    def subscribe(listeners)
+      @listeners = listeners
+
+      if listeners.is_a?(Hash)
+        listeners.each do |step_name, listener|
+          __steps__.detect { |step| step.name == step_name }.subscribe(listener)
+        end
+      else
+        __steps__.each do |step|
+          step.subscribe(listeners)
+        end
+      end
+    end
+  end
+end

data/lib/use_cases/errors.rb

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

data/lib/use_cases/module_optins.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "use_cases/authorize"
+require "use_cases/prepare"
+require "use_cases/transaction"
+require "use_cases/validate"
+
+module UseCases
+  module ModuleOptins
+    attr_accessor :options
+
+    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
+
+    def included(base)
+      super
+      @modules ||= []
+      return if @modules.empty?
+
+      base.include(*@modules)
+      @modules = nil
+    end
+
+    def inherited(base)
+      super
+      @modules ||= []
+      return if @modules.empty?
+
+      base.include(*@modules)
+      @modules = nil
+    end
+
+    def descendants
+      ObjectSpace.each_object(Class).select { |klass| klass < self }
+    end
+  end
+end

data/lib/use_cases/notifications.rb

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

data/lib/use_cases/params.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "active_support/hash_with_indifferent_access"
+
+module UseCases
+  class Params < ActiveSupport::HashWithIndifferentAccess
+    def initialize(params)
+      if defined?(Rails) && params.is_a?(ActionController::Parameters)
+        super(params.permit!.to_h)
+      else
+        super(params)
+      end
+    end
+  end
+end

data/lib/use_cases/prepare.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "use_cases/step_adapters/tee"
+
+module UseCases
+  module Prepare
+    def self.included(base)
+      base.class_eval do
+        extend DSL
+      end
+    end
+
+    module DSL
+      def prepare(name, options = {})
+        __steps__.unshift StepAdapters::Tee.new(name, nil, options)
+      end
+    end
+  end
+end

data/lib/use_cases/rspec/matchers.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+RSpec::Matchers.define(:fail_with_code) do |expected_code|
+  match do |test_subject|
+    expect(test_subject.failure?).to be true
+    expect(test_subject.failure.first).to eq expected_code
+  end
+end
+
+RSpec::Matchers.define(:fail_with_payload) do |expected_result|
+  match do |test_subject|
+    expect(test_subject.failure?).to be true
+    expect(test_subject.failure.last).to eq expected_result
+  end
+end
+
+RSpec::Matchers.define(:fail_with) do |*expected_failure|
+  match do |test_subject|
+    expect(test_subject.failure?).to be true
+    expect(test_subject.failure).to eq expected_failure
+  end
+end
+
+RSpec::Matchers.define(:succeed_with) do |expected_result|
+  match do |test_subject|
+    expect(test_subject.success?).to be true
+    expect(test_subject.success).to eq expected_result
+  end
+end

data/lib/use_cases/stack.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module UseCases
+  class Stack
+    attr_reader :steps
+
+    attr_accessor :prev_step_result, :current_step
+
+    def initialize(steps)
+      @steps = steps
+    end
+
+    def bind(object)
+      steps.map! { |step| step.bind(object) }
+      self
+    end
+
+    def call(initial_value = nil)
+      steps.reduce(initial_value) do |prev_result, current_step|
+        self.current_step = current_step
+        self.prev_step_result = prev_result
+
+        yield
+      end
+    end
+
+    def in_first_step?
+      steps.find_index(current_step).zero?
+    end
+
+    def previous_result_empty?
+      prev_step_result.nil?
+    end
+
+    def previous_step_value
+      prev_step_result.value
+    end
+
+    def step_names
+      steps.map(&:name)
+    end
+
+    def include_step?(step_name)
+      step_names.include?(step_name)
+    end
+
+    def find_step(step_name)
+      steps.find { |step| step.name == step_name }
+    end
+  end
+end

data/lib/use_cases/stack_runner.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module UseCases
+  class StackRunner
+    attr_reader :stack
+
+    def initialize(stack)
+      @stack = stack
+    end
+
+    def call(*args, &around_block)
+      return around_block.call { do_call(*args) } if around_block
+
+      do_call(*args)
+    end
+
+    private
+
+    def do_call(*args)
+      stack.call do
+        result = _run_step(stack, args)
+
+        return result if result.failure?
+
+        result
+      end
+    end
+
+    def _run_step(stack, args)
+      step = stack.current_step
+      expected_args_count = step.args_count
+      step_args = _assert_step_arguments_with_count(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
+
+      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)
+    end
+
+    def _should_prepend_previous_step_result_to_args?(stack)
+      !stack.previous_result_empty? && !stack.in_first_step?
+    end
+  end
+end

data/lib/use_cases/step_active_job_adapter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "active_support/inflector"
+
+return unless defined? ActiveJob
+
+module UseCases
+  class StepActiveJobAdapter < ActiveJob::Base
+    def perform(use_case_name, step_name, *args)
+      args = deserialize_step_arguments(args)
+
+      use_case = ActiveSupport::Inflector.constantize(use_case_name)
+      use_case.new.send(step_name, *args)
+    end
+
+    def deserialize_step_arguments(args)
+      args.map { |arg| arg.is_a?(Hash) && arg.delete("_serialized_by_use_case") ? arg.deserialize : arg }
+    end
+
+    def self.serialize_step_arguments(args)
+      args.select.with_index do |arg, index|
+        ActiveJob::Arguments.send(:serialize_argument, arg)
+
+      rescue ActiveJob::SerializationError => _e
+        arg.serialize.merge("_serialized_by_use_case" => true)
+
+      rescue NoMethodError => _e
+        puts "[WARNING] #{arg.class} (index = #{index})" \
+             "is not serializable and does not repond to #serialize and will be ignored."
+        false
+      end
+    end
+  end
+end

data/lib/use_cases/step_adapters/abstract.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "dry/monads/all"
+
+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
+
+      def initialize(name, *args, **options)
+        @name = name
+        @object = args.first
+        @options = options
+      end
+
+      def previous_step_result
+        object.stack.prev_step_result
+      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
+      end
+
+      def do_call(*args)
+        callable_proc.call(*args)
+      end
+
+      def bind(object)
+        self.class.new(name, object, options)
+      end
+
+      def callable_proc
+        callable_object.method(callable_method)
+      end
+
+      def callable_object
+        case options[:with]
+        when NilClass, FalseClass then object
+        when String               then object.send(options[:with])
+        else                           options[:with]
+        end
+      end
+
+      def callable_method
+        case options[:with]
+        when NilClass, FalseClass then name
+        else                           :call
+        end
+      end
+
+      def external?
+        options[:with].present?
+      end
+
+      def args_count
+        callable_proc.parameters.count
+      end
+
+      def missing?
+        !callable_object.respond_to?(callable_method, true)
+      end
+
+      def before_call(*args); end
+
+      def after_call_success(*args); end
+
+      def after_call_failure(*args); end
+
+      def around_call(*_args, &blk)
+        blk.call
+      end
+    end
+  end
+end

data/lib/use_cases/step_adapters/authorize.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "use_cases/step_adapters/check"
+
+module UseCases
+  module StepAdapters
+    class Authorize < UseCases::StepAdapters::Check
+      class InvalidReturnValue < StandardError; end
+
+      def do_call(*args)
+        result = super(*args)
+        prev_result = previous_step_result.value
+        raise InvalidReturnValue, "The return value should not be a Monad." if result.is_a?(Dry::Monads::Result)
+
+        failure_code = options[:failure] || :check_failure
+        failure_message = options[:failure_message] || "Failed"
+
+        result ? Success(prev_result) : Failure([failure_code, failure_message])
+      end
+    end
+  end
+end

data/lib/use_cases/step_adapters/check.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "use_cases/step_adapters/abstract"
+
+module UseCases
+  module StepAdapters
+    class Check < UseCases::StepAdapters::Abstract
+      class InvalidReturnValue < StandardError; end
+
+      def do_call(*args)
+        result = super(*args)
+        prev_result = previous_step_result.value
+        raise InvalidReturnValue, "The return value should not be a Monad." if result.is_a?(Dry::Monads::Result)
+
+        failure_code = options[:failure] || :check_failure
+        failure_message = options[:failure_message] || "Failed"
+
+        result ? Success(prev_result) : Failure([failure_code, failure_message])
+      end
+    end
+  end
+end

data/lib/use_cases/step_adapters/enqueue.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module UseCases
+  module StepAdapters
+    class Enqueue < UseCases::StepAdapters::Tee
+      def do_call(*base_args)
+        args = [object.class.name, name.to_s, *base_args]
+        args = ::UseCases::StepActiveJobAdapter.serialize_step_arguments(args)
+
+        job_options = options.slice(:queue, :wait, :wait_until, :priority)
+
+        ::UseCases::StepActiveJobAdapter.set(job_options).perform_later(*args)
+
+        Success(previous_step_result.value)
+      end
+    end
+  end
+end

data/lib/use_cases/step_adapters/map.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "use_cases/step_adapters/abstract"
+
+module UseCases
+  module StepAdapters
+    class Map < UseCases::StepAdapters::Abstract
+      class InvalidReturnValue < StandardError; end
+
+      def do_call(*args)
+        result = super(*args)
+        raise InvalidReturnValue, "The return value should not be a Monad." if result.is_a?(Dry::Monads::Result)
+
+        Success(result)
+      end
+    end
+  end
+end

data/lib/use_cases/step_adapters/step.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "use_cases/step_adapters/abstract"
+
+module UseCases
+  module StepAdapters
+    class Step < UseCases::StepAdapters::Abstract
+      class InvalidReturnValue < StandardError; end
+
+      def do_call(*args)
+        result = super(*args)
+        raise InvalidReturnValue, "Return value should be a Monad" unless result.is_a?(Dry::Monads::Result)
+
+        result
+      end
+    end
+  end
+end

data/lib/use_cases/step_adapters/tee.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "use_cases/step_adapters/abstract"
+
+module UseCases
+  module StepAdapters
+    class Tee < UseCases::StepAdapters::Abstract
+      class InvalidReturnValue < StandardError; end
+
+      def do_call(*args)
+        result = super(*args)
+      rescue StandardError => _e
+        raise InvalidReturnValue, "For a tee step, a Monad will have no effect." if result.is_a?(Dry::Monads::Result)
+
+        prev_result = previous_step_result.value
+        Success(prev_result)
+      end
+    end
+  end
+end

data/lib/use_cases/step_adapters/try.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "use_cases/step_adapters/abstract"
+
+module UseCases
+  module StepAdapters
+    class Try < UseCases::StepAdapters::Abstract
+      class InvalidReturnValue < StandardError; end
+
+      def do_call(*args)
+        result = super(*args)
+        raise InvalidReturnValue, "The return value should not be a Monad." if result.is_a?(Dry::Monads::Result)
+
+        Success(result)
+      rescue options[:catch] || StandardError => e
+        Failure([options[:failure], e.message])
+      end
+    end
+  end
+end