service_actor 3.6.1 → 3.8.0

data/lib/service_actor/checks/nil_check.rb

@@ -35,23 +35,25 @@ class ServiceActor::Checks::NilCheck < ServiceActor::Checks::Base
 
   private_constant :DEFAULT_MESSAGE
 
-  def self.check( # rubocop:disable Metrics/ParameterLists
-    origin:,
-    input_key:,
-    input_options:,
-    actor:,
-    conditions:,
-    result:,
-    **
-  ) # do
-    new(
-      origin: origin,
-      input_key: input_key,
-      input_options: input_options,
-      actor: actor,
-      allow_nil: conditions,
-      value: result[input_key],
-    ).check
+  class << self
+    def check(
+      origin:,
+      input_key:,
+      input_options:,
+      actor:,
+      conditions:,
+      result:,
+      **
+    ) # do
+      new(
+        origin: origin,
+        input_key: input_key,
+        input_options: input_options,
+        actor: actor,
+        allow_nil: conditions,
+        value: result[input_key],
+      ).check
+    end
   end
 
   def initialize( # rubocop:disable Metrics/ParameterLists
@@ -92,6 +94,7 @@ class ServiceActor::Checks::NilCheck < ServiceActor::Checks::Base
 
   def define_allow_nil_and_message_from(allow_nil)
     if allow_nil.is_a?(Hash)
+      allow_nil[:message] ||= DEFAULT_MESSAGE
       allow_nil.values_at(:is, :message)
     else
       [allow_nil, DEFAULT_MESSAGE]

data/lib/service_actor/checks/type_check.rb

@@ -34,24 +34,26 @@ class ServiceActor::Checks::TypeCheck < ServiceActor::Checks::Base
 
   private_constant :DEFAULT_MESSAGE
 
-  def self.check( # rubocop:disable Metrics/ParameterLists
-    check_name:,
-    origin:,
-    input_key:,
-    actor:,
-    conditions:,
-    result:,
-    **
-  ) # do
-    return unless check_name == :type
-
-    new(
-      origin: origin,
-      input_key: input_key,
-      actor: actor,
-      type_definition: conditions,
-      given_type: result[input_key],
-    ).check
+  class << self
+    def check(
+      check_name:,
+      origin:,
+      input_key:,
+      actor:,
+      conditions:,
+      result:,
+      **
+    ) # do
+      return unless check_name == :type
+
+      new(
+        origin: origin,
+        input_key: input_key,
+        actor: actor,
+        type_definition: conditions,
+        given_type: result[input_key],
+      ).check
+    end
   end
 
   def initialize(origin:, input_key:, actor:, type_definition:, given_type:)
@@ -86,6 +88,8 @@ class ServiceActor::Checks::TypeCheck < ServiceActor::Checks::Base
 
   def define_types_and_message
     if @type_definition.is_a?(Hash)
+      @type_definition[:message] ||= DEFAULT_MESSAGE
+
       @type_definition, message =
         @type_definition.values_at(:is, :message)
     else

data/lib/service_actor/configurable.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module ServiceActor::Configurable
-  def self.included(base)
-    base.extend(ClassMethods)
+  class << self
+    def included(base)
+      base.extend(ClassMethods)
+    end
   end
 
   module ClassMethods
@@ -15,6 +17,18 @@ module ServiceActor::Configurable
       child.failure_class = failure_class || ServiceActor::Failure
     end
 
-    attr_accessor :argument_error_class, :failure_class
+    def argument_error_class=(value)
+      ServiceActor::ArgumentsValidator.validate_error_class(value)
+
+      @argument_error_class = value
+    end
+
+    def failure_class=(value)
+      ServiceActor::ArgumentsValidator.validate_error_class(value)
+
+      @failure_class = value
+    end
+
+    attr_reader :argument_error_class, :failure_class
   end
 end

data/lib/service_actor/core.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module ServiceActor::Core
-  def self.included(base)
-    base.extend(ClassMethods)
+  class << self
+    def included(base)
+      base.extend(ClassMethods)
+    end
   end
 
   module ClassMethods

data/lib/service_actor/defaultable.rb

@@ -26,8 +26,10 @@
 #           }
 #   end
 module ServiceActor::Defaultable
-  def self.included(base)
-    base.prepend(PrependedMethods)
+  class << self
+    def included(base)
+      base.prepend(PrependedMethods)
+    end
   end
 
   module PrependedMethods
@@ -43,21 +45,26 @@ module ServiceActor::Defaultable
 
         default = input[:default]
 
-        if default.is_a?(Hash)
+        if default.is_a?(Hash) && default[:is]
           default_for_advanced_mode_with(result, key, default)
         else
           default_for_normal_mode_with(result, key, default)
         end
       end
 
+      self.class.outputs.each do |key, options|
+        unless result.key?(key)
+          result.send(:"#{key}=", options[:default])
+        end
+      end
+
       super
     end
 
     private
 
     def default_for_normal_mode_with(result, key, default)
-      default = default.call if default.is_a?(Proc)
-      result[key] = default
+      result[key] = reify_default(result, default)
     end
 
     def default_for_advanced_mode_with(result, key, content)
@@ -67,8 +74,7 @@ module ServiceActor::Defaultable
         raise_error_with(message, input_key: key, actor: self.class)
       end
 
-      default = default.call if default.is_a?(Proc)
-      result[key] = default
+      result[key] = reify_default(result, default)
 
       message.call(key, self.class)
     end
@@ -79,5 +85,11 @@ module ServiceActor::Defaultable
 
       raise self.class.argument_error_class, message
     end
+
+    def reify_default(result, default)
+      return default unless default.is_a?(Proc)
+
+      default.arity.zero? ? default.call : default.call(result)
+    end
   end
 end

data/lib/service_actor/failable.rb

@@ -7,9 +7,11 @@
 #     fail_on ServiceActor::ArgumentError
 #   end
 module ServiceActor::Failable
-  def self.included(base)
-    base.extend(ClassMethods)
-    base.prepend(PrependedMethods)
+  class << self
+    def included(base)
+      base.extend(ClassMethods)
+      base.prepend(PrependedMethods)
+    end
   end
 
   module ClassMethods
@@ -20,6 +22,10 @@ module ServiceActor::Failable
     end
 
     def fail_on(*exceptions)
+      exceptions.each do |exception|
+        ServiceActor::ArgumentsValidator.validate_error_class(exception)
+      end
+
       fail_ons.push(*exceptions)
     end
 

data/lib/service_actor/playable.rb

@@ -9,9 +9,11 @@
 #          SendWelcomeEmail
 #   end
 module ServiceActor::Playable
-  def self.included(base)
-    base.extend(ClassMethods)
-    base.prepend(PrependedMethods)
+  class << self
+    def included(base)
+      base.extend(ClassMethods)
+      base.prepend(PrependedMethods)
+    end
   end
 
   module ClassMethods
@@ -20,6 +22,12 @@ module ServiceActor::Playable
     end
 
     def alias_input(**options)
+      options.each_key do |new|
+        ServiceActor::ArgumentsValidator.validate_origin_name(
+          new, origin: :alias
+        )
+      end
+
       lambda do |actor|
         options.each do |new, original|
           define_alias_input(actor, new, original)
@@ -39,24 +47,15 @@ module ServiceActor::Playable
 
     private
 
-    def define_alias_input(actor, new, original)
-      actor[new] = actor[original]
-      actor.instance_exec do
-        [original, new].each do |method|
-          singleton_class.send(:undef_method, "#{method}=")
-          define_singleton_method("#{method}=") do |v|
-            actor[original] = v
-            actor[new] = v
-          end
-        end
-      end
+    def define_alias_input(actor, new_input, original_input)
+      actor[new_input] = actor.delete!(original_input)
     end
   end
 
   module PrependedMethods
     def call
       self.class.play_actors.each do |options|
-        next if options[:if] && !options[:if].call(result)
+        next unless callable_actor?(options)
 
         options[:actors].each { |actor| play_actor(actor) }
       end
@@ -77,6 +76,13 @@ module ServiceActor::Playable
 
     private
 
+    def callable_actor?(options)
+      return false if options[:if] && !options[:if].call(result)
+      return false if options[:unless]&.call(result)
+
+      true
+    end
+
     def play_actor(actor)
       play_service_actor(actor) ||
         play_method(actor) ||
@@ -106,7 +112,7 @@ module ServiceActor::Playable
       return unless actor.is_a?(Class)
       return unless actor.ancestors.map(&:name).include?("Interactor")
 
-      result.merge!(actor.call(result).to_h)
+      result.merge!(actor.call(result.to_h).to_h)
     end
   end
 end

data/lib/service_actor/result.rb

@@ -1,30 +1,46 @@
 # frozen_string_literal: true
 
-require "ostruct"
-
 # 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)
+class ServiceActor::Result < BasicObject
+  class << self
+    def to_result(data)
+      return data if data.is_a?(self)
+
+      new(data.to_h)
+    end
+  end
 
-    new(data.to_h)
+  %i[class is_a? kind_of? send tap then block_given?].each do |method_name|
+    define_method(method_name, ::Kernel.instance_method(method_name))
+  end
+
+  alias_method :yield_self, :then
+
+  def initialize(data = {})
+    @data = data.to_h
+  end
+
+  def to_h
+    data
   end
 
   def inspect
     "<#{self.class.name} #{to_h}>"
   end
 
+  alias_method :pretty_print, :inspect
+
   def fail!(failure_class = nil, result = {})
-    if failure_class.nil? || failure_class.is_a?(Hash)
+    if failure_class.nil? || failure_class.is_a?(::Hash)
       result = failure_class.to_h
-      failure_class = ServiceActor::Failure
+      failure_class = ::ServiceActor::Failure
     end
 
-    merge!(result)
-    merge!(failure?: true)
+    data.merge!(result)
+    data[:failure] = true
 
-    raise failure_class, self
+    ::Kernel.raise failure_class, self
   end
 
   def success?
@@ -32,13 +48,11 @@ class ServiceActor::Result < OpenStruct
   end
 
   def failure?
-    self[:failure?] || false
+    data[:failure] || false
   end
 
   def merge!(result)
-    result.each_pair do |key, value|
-      self[key] = value
-    end
+    data.merge!(result)
 
     self
   end
@@ -48,34 +62,63 @@ class ServiceActor::Result < OpenStruct
   end
 
   def [](name)
-    to_h[name]
+    data[name]
   end
 
-  # Defined here to override the method on `Object`.
-  def display
-    to_h.fetch(:display)
+  def []=(key, value)
+    data[key] = value
   end
 
-  private
+  def delete!(key)
+    data.delete(key)
+  end
 
-  def respond_to_missing?(method_name, include_private = false)
-    method_name.to_s.end_with?("?") || super
+  def respond_to?(method_name, include_private = false)
+    self.class.instance_methods.include?(method_name) ||
+      respond_to_missing?(method_name, include_private)
   end
 
-  def method_missing(symbol, *args)
-    attribute = symbol.to_s.chomp("?")
+  def deconstruct_keys(keys)
+    deconstructed_keys = to_h.merge(success: success?, failure: failure?)
+
+    keys ? deconstructed_keys.slice(*keys) : deconstructed_keys
+  end
 
-    if symbol.to_s.end_with?("?") && respond_to?(attribute)
-      define_singleton_method symbol do
-        value = send(attribute.to_sym)
+  private
 
-        # Same as ActiveSupport’s #present?
-        value.respond_to?(:empty?) ? !value.empty? : !!value
-      end
+  attr_reader :data
 
-      return send(symbol)
+  def respond_to_missing?(method_name, _include_private = false)
+    return true if method_name.end_with?("=")
+    if method_name.end_with?("?") &&
+        data.key?(method_name.to_s.chomp("?").to_sym)
+      return true
     end
 
-    super symbol, *args
+    return true if data.key?(method_name)
+
+    false
+  end
+
+  def method_missing(method_name, *args) # rubocop:disable Metrics/AbcSize
+    if method_name.end_with?("?") &&
+        data.key?(key = method_name.to_s.chomp("?").to_sym)
+      value = data[key]
+      value.respond_to?(:empty?) ? !value.empty? : !!value
+    elsif method_name.end_with?("=")
+      data[method_name.to_s.chomp("=").to_sym] = args.first
+    elsif data.key?(method_name)
+      data[method_name]
+    else
+      warn_on_undefined_method_invocation(method_name)
+    end
+  end
+
+  def warn_on_undefined_method_invocation(message)
+    ::Kernel.warn(
+      "DEPRECATED: Invoking undefined methods on `ServiceActor::Result` will " \
+        "lead to runtime errors in the next major release of Actor. " \
+        "Invoked method: `#{message}`",
+    )
   end
 end

data/lib/service_actor/version.rb

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