service_actor 1.1.0 → 2.0.0

data/lib/service_actor.rb

@@ -1,90 +1,8 @@
 # frozen_string_literal: true
 
-require 'ostruct'
+require 'service_actor/base'
 
-require 'actor/failure'
-require 'actor/success'
-require 'actor/context'
-require 'actor/filtered_context'
-
-require 'actor/playable'
-require 'actor/attributable'
-require 'actor/defaultable'
-require 'actor/type_checkable'
-require 'actor/requireable'
-require 'actor/conditionable'
-
-# Actors should start with a verb, inherit from Actor and implement a `call`
-# method.
+# Class to inherit from in your application.
 class Actor
-  include Attributable
-  include Playable
-  prepend Defaultable
-  prepend TypeCheckable
-  prepend Requireable
-  prepend Conditionable
-
-  class << self
-    # Call an actor with a given context. Returns the context.
-    #
-    #   CreateUser.call(name: 'Joe')
-    def call(context = {}, **arguments)
-      context = Actor::Context.to_context(context).merge!(arguments)
-      new(context).run
-      context
-    rescue Actor::Success
-      context
-    end
-
-    alias call! call
-
-    # Call an actor with a given context. Returns the context and does not raise
-    # on failure.
-    #
-    #   CreateUser.result(name: 'Joe')
-    def result(context = {}, **arguments)
-      call(context, **arguments)
-    rescue Actor::Failure => e
-      e.context
-    end
-  end
-
-  # :nodoc:
-  def initialize(context)
-    @context = context
-  end
-
-  # To implement in your actors.
-  def call; end
-
-  # To implement in your actors.
-  def rollback; end
-
-  # :nodoc:
-  def before; end
-
-  # :nodoc:
-  def after; end
-
-  # :nodoc:
-  def run
-    before
-    call
-    after
-  end
-
-  private
-
-  # Returns the current context from inside an actor.
-  attr_reader :context
-
-  # Can be called from inside an actor to stop execution and mark as failed.
-  def fail!(**arguments)
-    @context.fail!(**arguments)
-  end
-
-  # Can be called from inside an actor to stop execution early.
-  def succeed!(**arguments)
-    @context.succeed!(**arguments)
-  end
+  include ServiceActor::Base
 end

data/lib/service_actor/argument_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ServiceActor
+  # Raised when an input or output does not match the given conditions.
+  class ArgumentError < Error; end
+end

data/lib/{actor → service_actor}/attributable.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class Actor
+module ServiceActor
   # DSL to document the accepted attributes.
   #
   #   class CreateUser < Actor
@@ -10,7 +10,6 @@ class Actor
   module Attributable
     def self.included(base)
       base.extend(ClassMethods)
-      base.prepend(PrependedMethods)
     end
 
     module ClassMethods
@@ -25,10 +24,10 @@ class Actor
         inputs[name] = arguments
 
         define_method(name) do
-          context.public_send(name)
+          result[name]
         end
 
-        private name
+        protected name
       end
 
       def inputs
@@ -37,23 +36,21 @@ class Actor
 
       def output(name, **arguments)
         outputs[name] = arguments
-      end
 
-      def outputs
-        @outputs ||= { error: { type: 'String' } }
+        define_method(name) do
+          result[name]
+        end
+
+        define_method("#{name}=") do |value|
+          result[name] = value
+        end
+
+        protected name, "#{name}="
       end
-    end
 
-    module PrependedMethods
-      # rubocop:disable Naming/MemoizedInstanceVariableName
-      def context
-        @filtered_context ||= Actor::FilteredContext.new(
-          super,
-          readers: self.class.inputs.keys,
-          setters: self.class.outputs.keys,
-        )
+      def outputs
+        @outputs ||= {}
       end
-      # rubocop:enable Naming/MemoizedInstanceVariableName
     end
   end
 end

data/lib/service_actor/base.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'service_actor/core'
+
+# Exceptions
+require 'service_actor/error'
+require 'service_actor/failure'
+require 'service_actor/success'
+require 'service_actor/argument_error'
+
+# Core
+require 'service_actor/result'
+require 'service_actor/attributable'
+require 'service_actor/playable'
+require 'service_actor/core'
+
+# Concerns
+require 'service_actor/type_checkable'
+require 'service_actor/nil_checkable'
+require 'service_actor/conditionable'
+require 'service_actor/defaultable'
+
+module ServiceActor
+  module Base
+    def self.included(base)
+      # Core
+      base.include(Core)
+
+      # Concerns
+      base.include(TypeCheckable)
+      base.include(NilCheckable)
+      base.include(Conditionable)
+      base.include(Defaultable)
+    end
+  end
+end

data/lib/service_actor/conditionable.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ServiceActor
+  # Add checks to your inputs, by calling lambdas with the name of you choice.
+  # Will raise an error if any check does return a truthy value.
+  #
+  # Example:
+  #
+  #   class Pay < Actor
+  #     input :provider,
+  #           must: {
+  #             exist: ->(provider) { PROVIDERS.include?(provider) }
+  #           }
+  #   end
+  module Conditionable
+    def self.included(base)
+      base.prepend(PrependedMethods)
+    end
+
+    module PrependedMethods
+      def _call
+        self.class.inputs.each do |key, options|
+          next unless options[:must]
+
+          options[:must].each do |name, check|
+            value = result[key]
+            next if check.call(value)
+
+            raise ArgumentError,
+                  "Input #{key} must #{name} but was #{value.inspect}."
+          end
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/service_actor/core.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module ServiceActor
+  # Actors should start with a verb, inherit from Actor and implement a `call`
+  # method.
+  module Core
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.include(Attributable)
+      base.include(Playable)
+    end
+
+    module ClassMethods
+      # Call an actor with a given result. Returns the result.
+      #
+      #   CreateUser.call(name: 'Joe')
+      def call(options = nil, **arguments)
+        result = Result.to_result(options).merge!(arguments)
+        new(result)._call
+        result
+      # DEPRECATED
+      rescue Success
+        result
+      end
+
+      # :nodoc:
+      def call!(**arguments)
+        warn "DEPRECATED: Prefer `#{name}.call` to `#{name}.call!`."
+        call(**arguments)
+      end
+
+      # Call an actor with arguments. Returns the result and does not raise on
+      # failure.
+      #
+      #   CreateUser.result(name: 'Joe')
+      def result(data = nil, **arguments)
+        call(data, **arguments)
+      rescue Failure => e
+        e.result
+      end
+    end
+
+    # :nodoc:
+    def initialize(result)
+      @result = result
+    end
+
+    # To implement in your actors.
+    def call; end
+
+    # To implement in your actors.
+    def rollback; end
+
+    # :nodoc:
+    def _call
+      call
+    end
+
+    private
+
+    # Returns the current context from inside an actor.
+    attr_reader :result
+
+    def context
+      warn "DEPRECATED: Prefer `result.` to `context.` in #{self.class.name}."
+
+      result
+    end
+
+    # Can be called from inside an actor to stop execution and mark as failed.
+    def fail!(**arguments)
+      result.fail!(**arguments)
+    end
+
+    # DEPRECATED
+    def succeed!(**arguments)
+      result.succeed!(**arguments)
+    end
+  end
+end

data/lib/service_actor/defaultable.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ServiceActor
+  # Adds the `default:` option to inputs. Accepts regular values and lambdas.
+  # If no default is set and the value has not been given, raises an error.
+  #
+  # Example:
+  #
+  #   class MultiplyThing < Actor
+  #     input :counter, default: 1
+  #     input :multiplier, default: -> { rand(1..10) }
+  #   end
+  module Defaultable
+    def self.included(base)
+      base.prepend(PrependedMethods)
+    end
+
+    module PrependedMethods
+      def _call
+        self.class.inputs.each do |name, input|
+          next if result.key?(name)
+
+          unless input.key?(:default)
+            raise ArgumentError, "Input #{name} on #{self.class} is missing."
+          end
+
+          default = input[:default]
+          default = default.call if default.respond_to?(:call)
+          result[name] = default
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/service_actor/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ServiceActor
+  # Standard exception from which other inherit.
+  class Error < StandardError; end
+end

data/lib/service_actor/failure.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ServiceActor
+  # Error raised when using `fail!` inside an actor.
+  class Failure < Error
+    def initialize(result)
+      @result = result
+
+      error = result.respond_to?(:error) ? result.error : nil
+
+      super(error)
+    end
+
+    attr_reader :result
+  end
+end

data/lib/service_actor/nil_checkable.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ServiceActor
+  # Ensure your inputs and outputs are not nil by adding `allow_nil: false`.
+  #
+  # Example:
+  #
+  #   class CreateUser < Actor
+  #     input :name, allow_nil: false
+  #     output :user, allow_nil: false
+  #   end
+  module NilCheckable
+    def self.included(base)
+      base.prepend(PrependedMethods)
+    end
+
+    module PrependedMethods
+      def _call
+        check_context_for_nil(self.class.inputs, origin: 'input')
+
+        super
+
+        check_context_for_nil(self.class.outputs, origin: 'output')
+      end
+
+      private
+
+      def check_context_for_nil(definitions, origin:)
+        definitions.each do |name, options|
+          warn_of_deprecated_required_option(options, name, origin)
+
+          next if !result[name].nil? || allow_nil?(options)
+
+          raise ArgumentError,
+                "The #{origin} \"#{name}\" on #{self.class} does not allow " \
+                'nil values.'
+        end
+      end
+
+      def warn_of_deprecated_required_option(options, name, origin)
+        return unless options.key?(:required)
+
+        warn 'DEPRECATED: The "required" option is deprecated. Replace ' \
+            "`#{origin} :#{name}, required: #{options[:required]}` by " \
+            "`#{origin} :#{name}, allow_nil: #{!options[:required]}` in " \
+            "#{self.class}."
+      end
+
+      def allow_nil?(options)
+        if options.key?(:allow_nil)
+          options[:allow_nil]
+        elsif options.key?(:required)
+          !options[:required]
+        elsif options.key?(:default) && options[:default].nil?
+          true
+        elsif options[:type]
+          false
+        else
+          true
+        end
+      end
+    end
+  end
+end