service_actor 3.5.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76d96df8529ca670b0380e22ae56b4a2b7f32af6bd50e8b311fd6cef056b5f88
-  data.tar.gz: 7bfea37c9b431c615cccd6e60e00500372aabe3e7b0c8bb4061a2df129a99bc4
+  metadata.gz: cd30f97e96402732d11711e040cd4a65ab96962a60338a5358bcae13c9578b06
+  data.tar.gz: 42694afe490d30e236c3a42bde46547759fd5adf7d8a52556dc7838a45be937e
 SHA512:
-  metadata.gz: 03bae9c5a662507d5170eaa133ac344469fef28c956d49f9ef0d2d619146a365221bb8705e43224bb54c3328262e5fca8adc718760cc536564563058f4eb35e9
-  data.tar.gz: 7e477e327a244f1fa3fe9e90fbff8f18e1d53f208bac2ea62ec7701c9c82abddc1a8d712a20719f31a6e8c866de697aa8a2ac05e3615f5f62c81f16604ee995a
+  metadata.gz: 6d5d01ce6b421df89f2074753c84ee84c9d166219316ee92c69a2d35e186f28faad4482e020c1144cac05caf1ca0ee2e56ee567dd1793f8bbf33c5b87dea31df
+  data.tar.gz: '038d365e4f8cff50b7fbc71ba757da5095d62487cd1e043338f386e9c04dd49fd1fe99081d84f7c4ac94f30b3bc35774ea6460825ae98c6380aa17760f8f133d'

data/lib/service_actor/base.rb

@@ -6,15 +6,12 @@ module ServiceActor::Base
   def self.included(base)
     # Essential mechanics
     base.include(ServiceActor::Core)
-    base.include(ServiceActor::Raisable)
+    base.include(ServiceActor::Configurable)
     base.include(ServiceActor::Attributable)
     base.include(ServiceActor::Playable)
 
     # Extra concerns
-    base.include(ServiceActor::TypeCheckable)
-    base.include(ServiceActor::NilCheckable)
-    base.include(ServiceActor::Conditionable)
-    base.include(ServiceActor::Collectionable)
+    base.include(ServiceActor::Checkable)
     base.include(ServiceActor::Defaultable)
     base.include(ServiceActor::Failable)
   end

data/lib/service_actor/checkable.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ServiceActor::Checkable
+  def self.included(base)
+    base.prepend(PrependedMethods)
+  end
+
+  module PrependedMethods
+    def _call
+      self.service_actor_argument_errors = []
+
+      service_actor_checks_for(:input)
+      super
+      service_actor_checks_for(:output)
+    end
+
+    private
+
+    attr_accessor :service_actor_argument_errors
+
+    # rubocop:disable Metrics/MethodLength
+    def service_actor_checks_for(origin)
+      self.class.public_send("#{origin}s").each do |input_key, input_options|
+        input_options.each do |check_name, check_conditions|
+          check_classes.each do |check_class|
+            argument_errors = check_class.check(
+              check_name: check_name,
+              origin: origin,
+              input_key: input_key,
+              actor: self.class,
+              conditions: check_conditions,
+              result: result,
+              input_options: input_options,
+            )
+
+            service_actor_argument_errors.push(*argument_errors)
+          end
+        end
+
+        raise_actor_argument_errors
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def raise_actor_argument_errors
+      return if service_actor_argument_errors.empty?
+
+      raise self.class.argument_error_class,
+            service_actor_argument_errors.first
+    end
+
+    def check_classes
+      [
+        ServiceActor::Checks::TypeCheck,
+        ServiceActor::Checks::MustCheck,
+        ServiceActor::Checks::InclusionCheck,
+        ServiceActor::Checks::NilCheck,
+        ServiceActor::Checks::DefaultCheck
+      ]
+    end
+  end
+end

data/lib/service_actor/checks/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class ServiceActor::Checks::Base
+  def initialize
+    @argument_errors = []
+  end
+
+  attr_reader :argument_errors
+
+  protected
+
+  def add_argument_error(message, **arguments)
+    message = message.call(**arguments) if message.is_a?(Proc)
+
+    argument_errors.push(message)
+  end
+end

data/lib/service_actor/checks/default_check.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# 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
+#
+#   class MultiplyThing < Actor
+#     input :counter,
+#           default: {
+#             is: 1,
+#             message: "Counter is required"
+#           }
+#
+#     input :multiplier,
+#           default: {
+#             is: -> { rand(1..10) },
+#             message: (lambda do |input_key:, actor:|
+#               "Input \"#{input_key}\" is required"
+#             end)
+#           }
+#   end
+class ServiceActor::Checks::DefaultCheck < ServiceActor::Checks::Base
+  def self.check(result:, input_key:, input_options:, actor:, **)
+    new(
+      result: result,
+      input_key: input_key,
+      input_options: input_options,
+      actor: actor,
+    ).check
+  end
+
+  def initialize(result:, input_key:, input_options:, actor:)
+    super()
+
+    @result = result
+    @input_key = input_key
+    @input_options = input_options
+    @actor = actor
+  end
+
+  def check # rubocop:disable Metrics/MethodLength
+    return if @result.key?(@input_key)
+
+    unless @input_options.key?(:default)
+      return add_argument_error(
+        "The \"#{@input_key}\" input on \"#{@actor}\" is missing",
+      )
+    end
+
+    default = @input_options[:default]
+
+    if default.is_a?(Hash)
+      default_for_advanced_mode_with(default)
+    else
+      default_for_normal_mode_with(default)
+    end
+
+    nil
+  end
+
+  private
+
+  def default_for_normal_mode_with(default)
+    default = default.call if default.is_a?(Proc)
+    @result[@input_key] = default
+  end
+
+  def default_for_advanced_mode_with(content)
+    default, message = content.values_at(:is, :message)
+
+    unless default
+      return add_argument_error(
+        message,
+        input_key: @input_key,
+        actor: self.class,
+      )
+    end
+
+    default = default.call if default.is_a?(Proc)
+    @result[@input_key] = default
+
+    message.call(@input_key, self.class)
+  end
+end

data/lib/service_actor/checks/inclusion_check.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Add checks to your inputs, by specifying what values are authorized under the
+# "in" key.
+#
+# Example:
+#
+#   class Pay < Actor
+#     input :provider, inclusion: ["MANGOPAY", "PayPal", "Stripe"]
+#   end
+#
+#   class Pay < Actor
+#     input :provider,
+#           inclusion: {
+#             in: ["MANGOPAY", "PayPal", "Stripe"],
+#             message: (lambda do |input_key:, actor:, inclusion_in:, value:|
+#               "Payment system \"#{value}\" is not supported"
+#             end)
+#           }
+#   end
+class ServiceActor::Checks::InclusionCheck < ServiceActor::Checks::Base
+  DEFAULT_MESSAGE = lambda do |input_key:, actor:, inclusion_in:, value:|
+    "The \"#{input_key}\" input must be included " \
+      "in #{inclusion_in.inspect} on \"#{actor}\" " \
+        "instead of #{value.inspect}"
+  end
+
+  private_constant :DEFAULT_MESSAGE
+
+  def self.check(check_name:, input_key:, actor:, conditions:, result:, **) # rubocop:disable Metrics/ParameterLists
+    # DEPRECATED: `in` is deprecated in favor of `inclusion`.
+    return unless %i[inclusion in].include?(check_name)
+
+    new(
+      input_key: input_key,
+      actor: actor,
+      inclusion: conditions,
+      value: result[input_key],
+    ).check
+  end
+
+  def initialize(input_key:, actor:, inclusion:, value:)
+    super()
+
+    @input_key = input_key
+    @actor = actor
+    @inclusion = inclusion
+    @value = value
+  end
+
+  def check
+    inclusion_in, message = define_inclusion_and_message
+
+    return if inclusion_in.nil?
+    return if inclusion_in.include?(@value)
+
+    add_argument_error(
+      message,
+      input_key: @input_key,
+      actor: @actor,
+      inclusion_in: inclusion_in,
+      value: @value,
+    )
+  end
+
+  private
+
+  def define_inclusion_and_message
+    if @inclusion.is_a?(Hash)
+      @inclusion.values_at(:in, :message)
+    else
+      [@inclusion, DEFAULT_MESSAGE]
+    end
+  end
+end

data/lib/service_actor/checks/must_check.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# Add checks to your inputs, by calling lambdas with the name of you choice
+# under the "must" key.
+#
+# Will raise an error if any check returns a truthy value.
+#
+# Example:
+#
+#   class Pay < Actor
+#     input :provider,
+#           must: {
+#             exist: -> provider { PROVIDERS.include?(provider) },
+#           }
+#   end
+#
+#   class Pay < Actor
+#     input :provider,
+#           must: {
+#             exist: {
+#               is: -> provider { PROVIDERS.include?(provider) },
+#               message: (lambda do |input_key:, check_name:, actor:, value:|
+#                 "The specified provider \"#{value}\" was not found."
+#               end)
+#             }
+#           }
+#   end
+class ServiceActor::Checks::MustCheck < ServiceActor::Checks::Base
+  DEFAULT_MESSAGE = lambda do |input_key:, actor:, check_name:, value:|
+    "The \"#{input_key}\" input on \"#{actor}\" must \"#{check_name}\" " \
+      "but was #{value.inspect}"
+  end
+
+  private_constant :DEFAULT_MESSAGE
+
+  def self.check(check_name:, input_key:, actor:, conditions:, result:, **) # rubocop:disable Metrics/ParameterLists
+    return unless check_name == :must
+
+    new(
+      input_key: input_key,
+      actor: actor,
+      nested_checks: conditions,
+      value: result[input_key],
+    ).check
+  end
+
+  def initialize(input_key:, actor:, nested_checks:, value:)
+    super()
+
+    @input_key = input_key
+    @actor = actor
+    @nested_checks = nested_checks
+    @value = value
+  end
+
+  def check
+    @nested_checks.each do |nested_check_name, nested_check_conditions|
+      check, message = define_check_and_message_from(nested_check_conditions)
+
+      next if check.call(@value)
+
+      add_argument_error(
+        message,
+        input_key: @input_key,
+        actor: @actor,
+        check_name: nested_check_name,
+        value: @value,
+      )
+    end
+
+    @argument_errors
+  end
+
+  private
+
+  def define_check_and_message_from(nested_check_conditions)
+    if nested_check_conditions.is_a?(Hash)
+      nested_check_conditions.values_at(:is, :message)
+    else
+      [nested_check_conditions, DEFAULT_MESSAGE]
+    end
+  end
+end

data/lib/service_actor/checks/nil_check.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+# 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
+#
+#   class CreateUser < Actor
+#     input :name,
+#           allow_nil: {
+#             is: false,
+#             message: (lambda do |origin:, input_key:, actor:|
+#               "The value \"#{input_key}\" cannot be empty"
+#             end)
+#           }
+#
+#     input :phone, allow_nil: { is: false, message: "Phone must be present" }
+#
+#     output :user,
+#             allow_nil: {
+#               is: false,
+#               message: (lambda do |origin:, input_key:, actor:|
+#                 "The value \"#{input_key}\" cannot be empty"
+#               end)
+#             }
+#   end
+class ServiceActor::Checks::NilCheck < ServiceActor::Checks::Base
+  DEFAULT_MESSAGE = lambda do |origin:, input_key:, actor:|
+    "The \"#{input_key}\" #{origin} on \"#{actor}\" does not allow nil values"
+  end
+
+  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
+  end
+
+  def initialize( # rubocop:disable Metrics/ParameterLists
+    origin:,
+    input_key:,
+    input_options:,
+    actor:,
+    allow_nil:,
+    value:
+  ) # do
+    super()
+
+    @origin = origin
+    @input_key = input_key
+    @input_options = input_options
+    @actor = actor
+    @allow_nil = allow_nil
+    @value = value
+  end
+
+  def check
+    return unless @value.nil?
+
+    allow_nil, message =
+      define_allow_nil_and_message_from(@input_options[:allow_nil])
+
+    return if allow_nil?(allow_nil)
+
+    add_argument_error(
+      message,
+      origin: @origin,
+      input_key: @input_key,
+      actor: @actor,
+    )
+  end
+
+  private
+
+  def define_allow_nil_and_message_from(allow_nil)
+    if allow_nil.is_a?(Hash)
+      allow_nil.values_at(:is, :message)
+    else
+      [allow_nil, DEFAULT_MESSAGE]
+    end
+  end
+
+  def allow_nil?(tmp_allow_nil)
+    return tmp_allow_nil unless tmp_allow_nil.nil?
+
+    if @input_options.key?(:default) && @input_options[:default].nil?
+      return true
+    end
+
+    !@input_options[:type]
+  end
+end

data/lib/service_actor/checks/type_check.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+# 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
+class ServiceActor::Checks::TypeCheck < ServiceActor::Checks::Base
+  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
+
+  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
+  end
+
+  def initialize(origin:, input_key:, actor:, type_definition:, given_type:)
+    super()
+
+    @origin = origin
+    @input_key = input_key
+    @actor = actor
+    @type_definition = type_definition
+    @given_type = given_type
+  end
+
+  def check
+    return if @type_definition.nil?
+    return if @given_type.nil?
+
+    types, message = define_types_and_message
+
+    return if types.any? { |type| @given_type.is_a?(type) }
+
+    add_argument_error(
+      message,
+      origin: @origin,
+      input_key: @input_key,
+      actor: @actor,
+      expected_type: types.join(", "),
+      given_type: @given_type.class,
+    )
+  end
+
+  private
+
+  def define_types_and_message
+    if @type_definition.is_a?(Hash)
+      @type_definition, message =
+        @type_definition.values_at(:is, :message)
+    else
+      message = DEFAULT_MESSAGE
+    end
+
+    types = Array(@type_definition).map do |name|
+      name.is_a?(String) ? Object.const_get(name) : name
+    end
+
+    [types, message]
+  end
+end

data/lib/service_actor/{raisable.rb → configurable.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module ServiceActor::Raisable
+module ServiceActor::Configurable
   def self.included(base)
     base.extend(ClassMethods)
   end

data/lib/service_actor/core.rb

@@ -11,7 +11,10 @@ module ServiceActor::Core
     #   CreateUser.call(name: "Joe")
     def call(result = nil, **arguments)
       result = ServiceActor::Result.to_result(result).merge!(arguments)
-      new(result)._call
+
+      instance = new(result)
+      instance._call
+
       result
     end
 
@@ -54,13 +57,4 @@ module ServiceActor::Core
   def fail!(**arguments)
     result.fail!(self.class.failure_class, **arguments)
   end
-
-  private
-
-  # Raises an error depending on the mode
-  def raise_error_with(message, **arguments)
-    message = message.call(**arguments) if message.is_a?(Proc)
-
-    raise self.class.argument_error_class, message
-  end
 end

data/lib/service_actor/defaultable.rb

@@ -72,5 +72,12 @@ module ServiceActor::Defaultable
 
       message.call(key, self.class)
     end
+
+    # Raises an error depending on the mode
+    def raise_error_with(message, **arguments)
+      message = message.call(**arguments) if message.is_a?(Proc)
+
+      raise self.class.argument_error_class, message
+    end
   end
 end

data/lib/service_actor/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: service_actor
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 3.6.0
 platform: ruby
 authors:
 - Sunny Ripert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-20 00:00:00.000000000 Z
+date: 2022-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -171,19 +171,22 @@ files:
 - lib/service_actor/argument_error.rb
 - lib/service_actor/attributable.rb
 - lib/service_actor/base.rb
-- lib/service_actor/collectionable.rb
-- lib/service_actor/conditionable.rb
+- lib/service_actor/checkable.rb
+- lib/service_actor/checks/base.rb
+- lib/service_actor/checks/default_check.rb
+- lib/service_actor/checks/inclusion_check.rb
+- lib/service_actor/checks/must_check.rb
+- lib/service_actor/checks/nil_check.rb
+- lib/service_actor/checks/type_check.rb
+- lib/service_actor/configurable.rb
 - lib/service_actor/core.rb
 - lib/service_actor/defaultable.rb
 - lib/service_actor/error.rb
 - lib/service_actor/failable.rb
 - 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
 licenses:

data/lib/service_actor/collectionable.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-# Add checks to your inputs, by specifying what values are authorized under the
-# "in" key.
-#
-# Example:
-#
-#   class Pay < Actor
-#     input :provider, inclusion: ["MANGOPAY", "PayPal", "Stripe"]
-#   end
-#
-#   class Pay < Actor
-#     input :provider,
-#           inclusion: {
-#             in: ["MANGOPAY", "PayPal", "Stripe"],
-#             message: (lambda do |input_key:, actor:, inclusion_in:, value:|
-#               "Payment system \"#{value}\" is not supported"
-#             end)
-#           }
-#   end
-module ServiceActor::Collectionable
-  def self.included(base)
-    base.prepend(PrependedMethods)
-  end
-
-  module PrependedMethods
-    DEFAULT_MESSAGE = lambda do |input_key:, actor:, inclusion_in:, value:|
-      "The \"#{input_key}\" input must be included " \
-      "in #{inclusion_in.inspect} on \"#{actor}\" " \
-      "instead of #{value.inspect}"
-    end
-
-    private_constant :DEFAULT_MESSAGE
-
-    def _call # rubocop:disable Metrics/MethodLength
-      self.class.inputs.each do |key, options|
-        value = result[key]
-
-        # DEPRECATED: `in` is deprecated in favor of `inclusion`.
-        inclusion = options[:inclusion] || options[:in]
-
-        inclusion_in, message = define_inclusion_from(inclusion)
-
-        next if inclusion_in.nil?
-        next if inclusion_in.include?(value)
-
-        raise_error_with(
-          message,
-          input_key: key,
-          actor: self.class,
-          inclusion_in: inclusion_in,
-          value: value,
-        )
-      end
-
-      super
-    end
-
-    private
-
-    def define_inclusion_from(inclusion)
-      if inclusion.is_a?(Hash)
-        inclusion.values_at(:in, :message)
-      else
-        [inclusion, DEFAULT_MESSAGE]
-      end
-    end
-  end
-end

data/lib/service_actor/conditionable.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-# Add checks to your inputs, by calling lambdas with the name of you choice
-# under the "must" key.
-#
-# Will raise an error if any check returns a truthy value.
-#
-# Example:
-#
-#   class Pay < Actor
-#     input :provider,
-#           must: {
-#             exist: -> provider { PROVIDERS.include?(provider) },
-#           }
-#   end
-#
-#   class Pay < Actor
-#     input :provider,
-#           must: {
-#             exist: {
-#               is: -> provider { PROVIDERS.include?(provider) },
-#               message: (lambda do |input_key:, check_name:, actor:, value:|
-#                 "The specified provider \"#{value}\" was not found."
-#               end)
-#             }
-#           }
-#   end
-module ServiceActor::Conditionable
-  def self.included(base)
-    base.prepend(PrependedMethods)
-  end
-
-  module PrependedMethods
-    DEFAULT_MESSAGE = lambda do |input_key:, check_name:, actor:, value:|
-      "The \"#{input_key}\" input on \"#{actor}\" must \"#{check_name}\" " \
-        "but was #{value.inspect}"
-    end
-
-    private_constant :DEFAULT_MESSAGE
-
-    def _call # rubocop:disable Metrics/MethodLength
-      self.class.inputs.each do |key, options|
-        next unless options[:must]
-
-        options[:must].each do |check_name, check|
-          value = result[key]
-
-          check, message = define_check_from(check)
-
-          next if check.call(value)
-
-          raise_error_with(
-            message,
-            input_key: key,
-            check_name: check_name,
-            actor: self.class,
-            value: value,
-          )
-        end
-      end
-
-      super
-    end
-
-    private
-
-    def define_check_from(check)
-      if check.is_a?(Hash)
-        check.values_at(:is, :message)
-      else
-        [check, DEFAULT_MESSAGE]
-      end
-    end
-  end
-end

data/lib/service_actor/nil_checkable.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-# 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
-#
-#   class CreateUser < Actor
-#     input :name,
-#           allow_nil: {
-#             is: false,
-#             message: (lambda do |origin:, input_key:, actor:|
-#               "The value \"#{input_key}\" cannot be empty"
-#             end)
-#           }
-#
-#     input :phone, allow_nil: { is: false, message: "Phone must be present" }
-#
-#     output :user,
-#             allow_nil: {
-#               is: false,
-#               message: (lambda do |origin:, input_key:, actor:|
-#                 "The value \"#{input_key}\" cannot be empty"
-#               end)
-#             }
-#   end
-module ServiceActor::NilCheckable
-  def self.included(base)
-    base.prepend(PrependedMethods)
-  end
-
-  module PrependedMethods
-    DEFAULT_MESSAGE = lambda do |origin:, input_key:, actor:|
-      "The \"#{input_key}\" #{origin} on \"#{actor}\" does not allow " \
-      "nil values"
-    end
-
-    private_constant :DEFAULT_MESSAGE
-
-    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 |key, options|
-        value = result[key]
-
-        next unless value.nil?
-
-        allow_nil, message = define_allow_nil_from(options[:allow_nil])
-
-        next if allow_nil?(allow_nil, options)
-
-        raise_error_with(
-          message,
-          origin: origin,
-          input_key: key,
-          actor: self.class,
-        )
-      end
-    end
-
-    def define_allow_nil_from(allow_nil)
-      if allow_nil.is_a?(Hash)
-        allow_nil.values_at(:is, :message)
-      else
-        [allow_nil, DEFAULT_MESSAGE]
-      end
-    end
-
-    def allow_nil?(allow_nil, options)
-      return allow_nil unless allow_nil.nil?
-      return true if options.key?(:default) && options[:default].nil?
-
-      !options[:type]
-    end
-  end
-end

data/lib/service_actor/type_checkable.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-# 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
-
-    private_constant :DEFAULT_MESSAGE
-
-    def _call
-      check_type_definitions(self.class.inputs, origin: "input")
-
-      super
-
-      check_type_definitions(self.class.outputs, origin: "output")
-    end
-
-    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
-
-        types, message = define_types_with(type_definition)
-
-        next if types.any? { |type| value.is_a?(type) }
-
-        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
-    end
-  end
-end