service_actor 3.3.0 → 3.4.0

data/lib/service_actor/playable.rb

@@ -1,91 +1,89 @@
 # frozen_string_literal: true
 
-module ServiceActor
-  # Play class method to call a series of actors with the same result. On
-  # failure, calls rollback on actors that succeeded.
-  #
-  #   class CreateUser < Actor
-  #     play SaveUser,
-  #          CreateSettings,
-  #          SendWelcomeEmail
-  #   end
-  module Playable
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.prepend(PrependedMethods)
-    end
+# Play class method to call a series of actors with the same result. On failure,
+# calls rollback on actors that succeeded.
+#
+#   class CreateUser < Actor
+#     play SaveUser,
+#          CreateSettings,
+#          SendWelcomeEmail
+#   end
+module ServiceActor::Playable
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.prepend(PrependedMethods)
+  end
 
-    module ClassMethods
-      def play(*actors, **options)
-        play_actors.push(actors: actors, **options)
-      end
+  module ClassMethods
+    def play(*actors, **options)
+      play_actors.push(actors: actors, **options)
+    end
 
-      def play_actors
-        @play_actors ||= []
-      end
+    def play_actors
+      @play_actors ||= []
+    end
 
-      def inherited(child)
-        super
+    def inherited(child)
+      super
 
-        child.play_actors.concat(play_actors)
-      end
+      child.play_actors.concat(play_actors)
     end
+  end
 
-    module PrependedMethods
-      def call
-        self.class.play_actors.each do |options|
-          next if options[:if] && !options[:if].call(result)
+  module PrependedMethods
+    def call
+      self.class.play_actors.each do |options|
+        next if options[:if] && !options[:if].call(result)
 
-          options[:actors].each { |actor| play_actor(actor) }
-        end
-      rescue Failure
-        rollback
-        raise
+        options[:actors].each { |actor| play_actor(actor) }
       end
+    rescue self.class.failure_class
+      rollback
+      raise
+    end
 
-      def rollback
-        return unless defined?(@played_actors)
+    def rollback
+      return unless defined?(@played_actors)
 
-        @played_actors.each do |actor|
-          next unless actor.respond_to?(:rollback)
+      @played_actors.each do |actor|
+        next unless actor.respond_to?(:rollback)
 
-          actor.rollback
-        end
+        actor.rollback
       end
+    end
 
-      private
+    private
 
-      def play_actor(actor)
-        play_service_actor(actor) ||
-          play_method(actor) ||
-          play_interactor(actor) ||
-          actor.call(result)
-      end
+    def play_actor(actor)
+      play_service_actor(actor) ||
+        play_method(actor) ||
+        play_interactor(actor) ||
+        actor.call(result)
+    end
 
-      def play_service_actor(actor)
-        return unless actor.is_a?(Class)
-        return unless actor.ancestors.include?(ServiceActor::Core)
+    def play_service_actor(actor)
+      return unless actor.is_a?(Class)
+      return unless actor.ancestors.include?(ServiceActor::Core)
 
-        actor = actor.new(result)
-        actor._call
+      actor = actor.new(result)
+      actor._call
 
-        (@played_actors ||= []).unshift(actor)
-      end
+      (@played_actors ||= []).unshift(actor)
+    end
 
-      def play_method(actor)
-        return unless actor.is_a?(Symbol)
+    def play_method(actor)
+      return unless actor.is_a?(Symbol)
 
-        send(actor)
+      send(actor)
 
-        true
-      end
+      true
+    end
 
-      def play_interactor(actor)
-        return unless actor.is_a?(Class)
-        return unless actor.ancestors.map(&:name).include?("Interactor")
+    def play_interactor(actor)
+      return unless actor.is_a?(Class)
+      return unless actor.ancestors.map(&:name).include?("Interactor")
 
-        result.merge!(actor.call(result).to_h)
-      end
+      result.merge!(actor.call(result).to_h)
     end
   end
 end

data/lib/service_actor/raisable.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ServiceActor::Raisable
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def inherited(child)
+      super
+
+      child.argument_error_class =
+        argument_error_class || ServiceActor::ArgumentError
+
+      child.failure_class = failure_class || ServiceActor::Failure
+    end
+
+    attr_accessor :argument_error_class, :failure_class
+  end
+end

data/lib/service_actor/result.rb

@@ -2,77 +2,75 @@
 
 require "ostruct"
 
-module ServiceActor
-  # Represents the context of an actor, holding the data from both its inputs
-  # and outputs.
-  class Result < OpenStruct
-    def self.to_result(data)
-      return data if data.is_a?(self)
-
-      new(data.to_h)
-    end
+# Represents the context of an actor, holding the data from both its inputs
+# and outputs.
+class ServiceActor::Result < OpenStruct
+  def self.to_result(data)
+    return data if data.is_a?(self)
 
-    def inspect
-      "<#{self.class.name} #{to_h}>"
-    end
+    new(data.to_h)
+  end
 
-    def fail!(result = {})
-      merge!(result)
-      merge!(failure?: true)
+  def inspect
+    "<#{self.class.name} #{to_h}>"
+  end
 
-      raise Failure, self
-    end
+  def fail!(failure_class, result = {})
+    merge!(result)
+    merge!(failure?: true)
 
-    def success?
-      !failure?
-    end
+    raise failure_class, self
+  end
 
-    def failure?
-      self[:failure?] || false
-    end
+  def success?
+    !failure?
+  end
 
-    def merge!(result)
-      result.each_pair do |key, value|
-        self[key] = value
-      end
+  def failure?
+    self[:failure?] || false
+  end
 
-      self
+  def merge!(result)
+    result.each_pair do |key, value|
+      self[key] = value
     end
 
-    def key?(name)
-      to_h.key?(name)
-    end
+    self
+  end
 
-    def [](name)
-      to_h[name]
-    end
+  def key?(name)
+    to_h.key?(name)
+  end
 
-    # Defined here to override the method on `Object`.
-    def display
-      to_h.fetch(:display)
-    end
+  def [](name)
+    to_h[name]
+  end
 
-    private
+  # Defined here to override the method on `Object`.
+  def display
+    to_h.fetch(:display)
+  end
 
-    def respond_to_missing?(method_name, include_private = false)
-      method_name.to_s.end_with?("?") || super
-    end
+  private
 
-    def method_missing(symbol, *args)
-      attribute = symbol.to_s.chomp("?")
+  def respond_to_missing?(method_name, include_private = false)
+    method_name.to_s.end_with?("?") || super
+  end
 
-      if symbol.to_s.end_with?("?") && respond_to?(attribute)
-        define_singleton_method symbol do
-          attribute_value = send(attribute.to_sym)
+  def method_missing(symbol, *args)
+    attribute = symbol.to_s.chomp("?")
 
-          # Same as ActiveSupport’s #present?
-          attribute_value.respond_to?(:empty?) ? !attribute_value.empty? : !!attribute_value
-        end
+    if symbol.to_s.end_with?("?") && respond_to?(attribute)
+      define_singleton_method symbol do
+        value = send(attribute.to_sym)
 
-        return send(symbol)
+        # Same as ActiveSupport’s #present?
+        value.respond_to?(:empty?) ? !value.empty? : !!value
       end
 
-      super symbol, *args
+      return send(symbol)
     end
+
+    super symbol, *args
   end
 end

data/lib/service_actor/support/loader.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+
+lib = File.expand_path("../..", __dir__)
+
+loader = Zeitwerk::Loader.new
+loader.tag = "service_actor"
+loader.inflector = Zeitwerk::GemInflector.new(
+  File.expand_path("service_actor.rb", lib),
+)
+loader.push_dir(lib)
+loader.ignore(__dir__)
+loader.setup
+
+module ServiceActor; end

data/lib/service_actor/type_checkable.rb

@@ -1,50 +1,90 @@
 # frozen_string_literal: true
 
-module ServiceActor
-  # Adds `type:` checking to inputs and outputs. Accepts class names or classes
-  # that should match an ancestor. Also accepts arrays.
-  #
-  # Example:
-  #
-  #   class ReduceOrderAmount < Actor
-  #     input :order, type: "Order"
-  #     input :amount, type: [Integer, Float]
-  #     input :bonus_applied, type: [TrueClass FalseClass]
-  #   end
-  module TypeCheckable
-    def self.included(base)
-      base.prepend(PrependedMethods)
+# Adds `type:` checking to inputs and outputs. Accepts class names or classes
+# that should match an ancestor. Also accepts arrays.
+#
+# Example:
+#
+#   class ReduceOrderAmount < Actor
+#     input :order, type: "Order"
+#     input :amount, type: [Integer, Float]
+#     input :bonus_applied, type: [TrueClass, FalseClass]
+#   end
+#
+#   class ReduceOrderAmount < Actor
+#     input :order, type: { is: Order, message: "Order is required" }
+#     input :amount, type: { is: Integer, message: "Incorrect amount" }
+#
+#     input :bonus_applied,
+#           type: {
+#             is: [TrueClass, FalseClass],
+#             message: (lambda do |origin:, input_key:, actor:, expected_type:, given_type:| # rubocop:disable Layout/LineLength
+#               "Wrong type \"#{given_type}\" for \"#{input_key}\". " \
+#               "Expected: \"#{expected_type}\""
+#             end)
+#           }
+#   end
+module ServiceActor::TypeCheckable
+  def self.included(base)
+    base.prepend(PrependedMethods)
+  end
+
+  module PrependedMethods
+    DEFAULT_MESSAGE = lambda do
+      |origin:, input_key:, actor:, expected_type:, given_type:|
+
+      "The \"#{input_key}\" #{origin} on \"#{actor}\" must be of type " \
+      "\"#{expected_type}\" but was \"#{given_type}\""
     end
 
-    module PrependedMethods
-      def _call
-        check_type_definitions(self.class.inputs, kind: "Input")
+    private_constant :DEFAULT_MESSAGE
 
-        super
+    def _call
+      check_type_definitions(self.class.inputs, origin: "input")
 
-        check_type_definitions(self.class.outputs, kind: "Output")
-      end
+      super
+
+      check_type_definitions(self.class.outputs, origin: "output")
+    end
+
+    private
 
-      private
+    def check_type_definitions(definitions, origin:) # rubocop:disable Metrics/MethodLength
+      definitions.each do |key, options|
+        type_definition = options[:type] || next
+        value = result[key] || next
 
-      def check_type_definitions(definitions, kind:)
-        definitions.each do |key, options|
-          type_definition = options[:type] || next
-          value = result[key] || next
+        types, message = define_types_with(type_definition)
 
-          types = types_for_definition(type_definition)
-          next if types.any? { |type| value.is_a?(type) }
+        next if types.any? { |type| value.is_a?(type) }
 
-          raise ArgumentError,
-                "#{kind} #{key} on #{self.class} must be of type " \
-                "#{types.join(', ')} but was #{value.class}"
-        end
+        raise_error_with(
+          message,
+          origin: origin,
+          input_key: key,
+          actor: self.class,
+          expected_type: types.join(", "),
+          given_type: value.class,
+        )
       end
+    end
+
+    def define_types_with(type_definition)
+      if type_definition.is_a?(Hash)
+        type_definition, message =
+          type_definition.values_at(:is, :message)
+      else
+        message = DEFAULT_MESSAGE
+      end
+
+      types = types_for_definition(type_definition)
+
+      [types, message]
+    end
 
-      def types_for_definition(type_definition)
-        Array(type_definition).map do |name|
-          name.is_a?(String) ? Object.const_get(name) : name
-        end
+    def types_for_definition(type_definition)
+      Array(type_definition).map do |name|
+        name.is_a?(String) ? Object.const_get(name) : name
       end
     end
   end

data/lib/service_actor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ServiceActor
-  VERSION = "3.3.0"
+  VERSION = "3.4.0"
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: service_actor
 version: !ruby/object:Gem::Version
-  version: 3.3.0
+  version: 3.4.0
 platform: ruby
 authors:
 - Sunny Ripert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-18 00:00:00.000000000 Z
+date: 2022-09-22 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -100,6 +114,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: code-scanning-rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -152,7 +180,9 @@ files:
 - lib/service_actor/failure.rb
 - lib/service_actor/nil_checkable.rb
 - lib/service_actor/playable.rb
+- lib/service_actor/raisable.rb
 - lib/service_actor/result.rb
+- lib/service_actor/support/loader.rb
 - lib/service_actor/type_checkable.rb
 - lib/service_actor/version.rb
 homepage: https://github.com/sunny/actor