servus 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f20bb1c0b41657377b94a29aef1915dc7a0c4c65442d21b9f6a60c75537dd8a
-  data.tar.gz: 9273a9d2e3efa50c3ce2d80935e7538a1fa89e0cc3195acfde974621f7960277
+  metadata.gz: 7e468137fc40c9d2f18214dea55b9c3fc6211e5479e73f5b0917ed168d116a2f
+  data.tar.gz: 5390b065cb3478d837cbd90047a7f8facaaf33273b0e2aa4d459167343354d8d
 SHA512:
-  metadata.gz: e2e4ec7e3390784c35acbe238b3d809c4e07859c39ccd159a1618daf3439d04d7bb4eb3c847ea30e1a3b94a1d4dfac2508601ce263160ddee1d7e0a9e20ed13b
-  data.tar.gz: 4f135793c078f9230436a6ff3f9508847469a198dfa818afadcbace146b7b85fdb78844a864538b96bded6cb3eed910002c0fdc8b6802ad4cae3189e06349a54
+  metadata.gz: 20e5b65a0cd82207a0c494b76e21d0562ce41ca27394b418e7d6921b841c4f47d4f8384f157146195eea713f1af3d28d09b81c210fd7f8a5041b13f8464d66a2
+  data.tar.gz: 52f7ca40905dc890fa6850cf87b8394471a94607749457aaeb4784c4524315fd769e40daa4322aae12b5bd84eb9282524a90836bab8a31ab9abfe01d021211a7

data/lib/generators/servus/event_handler/event_handler_generator.rb

@@ -44,7 +44,7 @@ module Servus
       # @return [String] spec file path
       # @api private
       def handler_spec_path
-        File.join('spec', Servus.config.events_dir, "#{file_name}_handler_spec.rb")
+        File.join(Servus.config.tests_dir, Servus.config.events_dir, "#{file_name}_handler_spec.rb")
       end
 
       # Returns the handler class name.

data/lib/generators/servus/guard/guard_generator.rb

@@ -44,7 +44,7 @@ module Servus
       # @return [String] spec file path
       # @api private
       def guard_spec_path
-        File.join('spec', Servus.config.guards_dir, "#{file_name}_guard_spec.rb")
+        File.join(Servus.config.tests_dir, Servus.config.guards_dir, "#{file_name}_guard_spec.rb")
       end
 
       # Returns the guard class name.

data/lib/generators/servus/guard/templates/guard.rb.erb

@@ -34,14 +34,16 @@ class <%= guard_class_name %> < Servus::Guard
 
   # Tests whether the <%= file_name.humanize.downcase %> condition is met.
   #
-  # @param kwargs [Hash] the arguments to validate
+  # Arguments passed to `enforce_*!` / `check_*?` are stored as `@kwargs`
+  # and exposed via `method_missing`, so read them directly off the instance.
+  #
   # @return [Boolean] true if validation passes
-  def test(**kwargs)
+  def test
     # TODO: Implement validation logic
     # Return true if the condition is met, false otherwise
     #
     # Example:
-    #   def test(account:, amount:)
+    #   def test
     #     account.balance >= amount
     #   end
     true

data/lib/generators/servus/service/service_generator.rb

@@ -57,7 +57,7 @@ module Servus
       # @return [String] spec file path
       # @api private
       def service_path_spec
-        "spec/services/#{file_path}/service_spec.rb"
+        "#{Servus.config.tests_dir}/services/#{file_path}/service_spec.rb"
       end
 
       # Returns the path for the result schema file.

data/lib/servus/base.rb

@@ -48,6 +48,7 @@ module Servus
   class Base
     include Servus::Support::Errors
     include Servus::Support::Rescuer
+    include Servus::Support::Lockdown
     include Servus::Events::Emitter
     include Servus::Guards
 
@@ -88,6 +89,8 @@ module Servus
     # The failure is logged automatically and returns a response containing the error.
     #
     # @param message [String, nil] custom error message (uses error type's default if nil)
+    # @param data [Object, nil] optional structured data to attach to the failure response.
+    #   When a +failure+ schema is defined, this data will be validated against it.
     # @param type [Class] error class to instantiate (must inherit from ServiceError)
     # @return [Servus::Support::Response] response with success: false and the error
     #
@@ -109,12 +112,17 @@ module Servus
     #     # Uses "Not found" as the message
     #   end
     #
+    # @example Attaching structured data to a failure
+    #   def call
+    #     return failure("Approval required", data: { requires_human_approval: true })
+    #   end
+    #
     # @see #success
     # @see #error!
     # @see Servus::Support::Errors
-    def failure(message = nil, type: Servus::Support::Errors::ServiceError)
+    def failure(message = nil, data: nil, type: Servus::Support::Errors::ServiceError)
       error = type.new(message)
-      Response.new(false, nil, error)
+      Response.new(false, data, error)
     end
 
     # Logs an error and raises an exception, halting service execution.
@@ -150,6 +158,46 @@ module Servus
       raise type, message
     end
 
+    # Invokes another service from within this service's {#call} and returns its
+    # data on success. On failure, halts the outer service with the sub-service's
+    # failure Response — the outer service's caller receives that Response
+    # unchanged (same error object, message, code, http_status).
+    #
+    # Sugar over:
+    #
+    #   result = SubService.call(**params)
+    #   return result unless result.success?
+    #   data = result.data
+    #
+    # Only call from within a service's `#call` (or helpers reachable from
+    # it); the throw is caught by {Servus::Base.call}.
+    #
+    # @example Composing services
+    #   class SendDigitalCash::Service < Servus::Base
+    #     def call
+    #       data1 = call!(Accounts::Lookup::Service, id: account_id)
+    #       data2 = call!(Ledger::RecordTransfer::Service, account:, amount:)
+    #       success(ref: data2.ref)
+    #     end
+    #   end
+    #
+    # For invoking a service from *outside* a service context (controllers,
+    # rake tasks, jobs, consoles), see
+    # {Servus::Helpers::ControllerHelpers#run_service!}.
+    #
+    # @param service_class [Class<Servus::Base>] the sub-service to invoke
+    # @param params [Hash] keyword arguments to pass to the sub-service
+    # @return [Servus::Support::DataObject, Object] the sub-service's data on success
+    # @throw [:guard_failure, Servus::Support::Response] the failure Response, otherwise
+    #
+    # @see Servus::Helpers::ControllerHelpers#run_service!
+    def call!(service_class, **params)
+      result = service_class.call(**params)
+      return result.data if result.success?
+
+      throw(:guard_failure, result)
+    end
+
     class << self
       # Executes the service with automatic validation, logging, and benchmarking.
       #
@@ -189,11 +237,13 @@ module Servus
 
         # Wrap execution in catch block to handle guard failures
         result = catch(:guard_failure) do
-          benchmark(**args) { instance.call }
+          benchmark(**args) { instance.send(:call) }
         end
 
-        # If result is a GuardError, a guard failed - wrap in failure Response
-        result = Response.new(false, nil, result) if result.is_a?(Servus::Support::Errors::GuardError)
+        if result.is_a?(Servus::Support::Errors::GuardError)
+          Logger.log_guard_failure(self, result)
+          result = Response.new(false, nil, result)
+        end
 
         after_call(result, instance)
 
@@ -207,15 +257,16 @@ module Servus
       end
       # rubocop:enable Metrics/MethodLength
 
-      # Defines schema validation rules for the service's arguments and/or result.
+      # Defines schema validation rules for the service's arguments, result, and/or failure data.
       #
       # This method provides a clean DSL for specifying JSON schemas that will be used
       # to validate service inputs and outputs. Schemas defined via this method take
-      # precedence over ARGUMENTS_SCHEMA and RESULT_SCHEMA constants. The next major
-      # version will deprecate those constants in favor of this DSL.
+      # precedence over ARGUMENTS_SCHEMA, RESULT_SCHEMA, and FAILURE_SCHEMA constants.
+      # The next major version will deprecate those constants in favor of this DSL.
       #
       # @param arguments [Hash, nil] JSON schema for validating service arguments
       # @param result [Hash, nil] JSON schema for validating service result data
+      # @param failure [Hash, nil] JSON schema for validating failure response data
       # @return [void]
       #
       # @example Defining both arguments and result schemas
@@ -245,9 +296,10 @@ module Servus
       #   end
       #
       # @see Servus::Support::Validator
-      def schema(arguments: nil, result: nil)
+      def schema(arguments: nil, result: nil, failure: nil)
         @arguments_schema = arguments.with_indifferent_access if arguments
         @result_schema    = result.with_indifferent_access    if result
+        @failure_schema   = failure.with_indifferent_access   if failure
       end
 
       # Returns the arguments schema defined via the schema DSL method.
@@ -262,6 +314,12 @@ module Servus
       # @api private
       attr_reader :result_schema
 
+      # Returns the failure schema defined via the schema DSL method.
+      #
+      # @return [Hash, nil] the failure schema or nil if not defined
+      # @api private
+      attr_reader :failure_schema
+
       # Executes pre-call hooks including logging and argument validation.
       #
       # This method is automatically called before service execution and handles:

data/lib/servus/config.rb

@@ -51,22 +51,90 @@ module Servus
     # @return [String] the guards directory path
     attr_accessor :guards_dir
 
+    # The directory where generated spec/test files are placed.
+    #
+    # Defaults to `"spec"`. Projects using Minitest or a custom test layout
+    # can override this (e.g., `"test"`) so generators write files into the
+    # correct location.
+    #
+    # @return [String] the tests directory path
+    attr_accessor :tests_dir
+
     # Whether to include the default built-in guards (EnsurePresent, EnsurePositive).
     #
     # @return [Boolean] true to include default guards, false to exclude them
     attr_accessor :include_default_guards
 
+    # Whether to require all services to define an arguments schema.
+    #
+    # When enabled, raises {Servus::Support::Errors::SchemaRequiredError} when
+    # a service is called without an arguments schema defined.
+    #
+    # @return [Boolean] true to require arguments schemas, false to allow schema-less services
+    attr_accessor :require_service_arguments_schema
+
+    # Whether to require all services to define a result schema.
+    #
+    # When enabled, raises {Servus::Support::Errors::SchemaRequiredError} when
+    # a service returns a successful response without a result schema defined.
+    # Failure schemas remain optional regardless of this setting.
+    #
+    # @return [Boolean] true to require result schemas, false to allow schema-less services
+    attr_accessor :require_service_result_schema
+
+    # Whether to require all event handlers to define a payload schema.
+    #
+    # When enabled, raises {Servus::Support::Errors::SchemaRequiredError} when
+    # an event handler validates a payload without a payload schema defined.
+    #
+    # @return [Boolean] true to require payload schemas, false to allow schema-less handlers
+    attr_accessor :require_event_payload_schema
+
+    # Whether external instantiation of services is blocked and instance
+    # `#call` methods are automatically privatized.
+    #
+    # When enabled (default), callers must invoke services via the class
+    # method {Servus::Base.call}, which runs argument validation, logging,
+    # benchmarking, guards, result validation, and event emission. Calling
+    # `MyService.new` or `instance.call` directly raises `NoMethodError`.
+    #
+    # Disable this if you have existing code that instantiates services
+    # directly or otherwise prefer to opt out of the enforcement.
+    #
+    # @return [Boolean] true to enforce lockdown (default), false to allow
+    #   direct instantiation and public instance `#call`
+    # @see Servus::Support::Lockdown
+    attr_reader :lockdown_enabled
+
+    # Sets whether lockdown is enforced, immediately re-applying the
+    # resulting `.new` visibility to {Servus::Base}.
+    #
+    # @param value [Boolean] the new lockdown setting
+    # @return [Boolean] the new value
+    def lockdown_enabled=(value)
+      @lockdown_enabled = value
+      Servus::Base.apply_lockdown!
+    end
+
     # Initializes a new configuration with default values.
     #
     # @api private
     def initialize
+      set_default_directories
+      @strict_event_validation          = true
+      @include_default_guards           = true
+      @lockdown_enabled                 = true
+      @require_service_arguments_schema = false
+      @require_service_result_schema    = false
+      @require_event_payload_schema     = false
+    end
+
+    def set_default_directories
       @guards_dir   = 'app/guards'
       @events_dir   = 'app/events'
       @schemas_dir  = 'app/schemas'
       @services_dir = 'app/services'
-
-      @strict_event_validation = true
-      @include_default_guards  = true
+      @tests_dir    = 'spec'
     end
 
     # Returns the full path to a service's schema file.

data/lib/servus/events/bus.rb

@@ -91,6 +91,35 @@ module Servus
           ActiveSupport::Notifications.instrument(notification_name(event_name), payload)
         end
 
+        # Subscribes to all Servus event emissions.
+        #
+        # Yields the clean event name and payload as positional args, plus
+        # +started_at+, +finished_at+, and +id+ as keyword args.
+        # Returns the subscription for manual unsubscribe.
+        #
+        # @yield [event_name, payload, started_at:, finished_at:, id:]
+        # @yieldparam event_name [Symbol] the event name
+        # @yieldparam payload [Hash] the event payload
+        # @yieldparam started_at [Time] when the event was emitted
+        # @yieldparam finished_at [Time] when the instrumented block completed
+        # @yieldparam id [String] unique notification ID
+        # @return [Object] the ActiveSupport::Notifications subscription
+        #
+        # @example Forward all events to an external system
+        #   Servus::Events::Bus.subscribe_all do |event_name, payload, started_at:, **|
+        #     EventusForwardJob.perform_later(
+        #       event: event_name.to_s,
+        #       payload: payload.as_json,
+        #       occurred_at: started_at.utc.iso8601(6)
+        #     )
+        #   end
+        def subscribe_all(&block)
+          ActiveSupport::Notifications.subscribe(/^servus\.events\./) do |name, started, finished, id, payload|
+            event_name = name.delete_prefix('servus.events.').to_sym
+            block.call(event_name, payload, started_at: started, finished_at: finished, id: id)
+          end
+        end
+
         # Clears all registered handlers and unsubscribes from notifications.
         #
         # Useful for testing and development mode reloading.

data/lib/servus/events/emitter.rb

@@ -127,6 +127,8 @@ module Servus
       def emit_events_for(trigger, result)
         self.class.emissions_for(trigger).each do |emission|
           payload = build_event_payload(emission, result)
+          validate_event_payload!(emission[:event_name], payload)
+          Servus::Support::Logger.log_event(emission[:event_name], payload)
           Servus::Events::Bus.emit(emission[:event_name], payload)
         end
       end
@@ -134,6 +136,19 @@ module Servus
       # Instance methods for emitting events during service execution
       private
 
+      # Validates the payload against all handler schemas registered for the event.
+      #
+      # @param event_name [Symbol] the event name
+      # @param payload [Hash] the event payload
+      # @return [void]
+      # @raise [Servus::Support::Errors::ValidationError] if payload fails validation
+      # @api private
+      def validate_event_payload!(event_name, payload)
+        Servus::Events::Bus.handlers_for(event_name).each do |handler_class|
+          Servus::Support::Validator.validate_event_payload!(handler_class, payload)
+        end
+      end
+
       # Builds the event payload using the configured payload builder or defaults.
       #
       # @param emission [Hash] the emission configuration

data/lib/servus/extensions/lazily/call.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Servus
+  module Extensions
+    module Lazily
+      # Provides lazy record resolution for service inputs.
+      #
+      # This module extends {Servus::Base} with the {#lazily} class method, enabling
+      # services to accept either a record ID or an already-loaded record instance.
+      # Resolution happens lazily on first access and is memoized.
+      #
+      # @see Lazily#lazily
+      module Call
+        # Declares a lazy record resolver for a service input.
+        #
+        # Defines an accessor method that lazily resolves the input value to a record.
+        # If the value is already an instance of the target class, it is returned directly.
+        # If the value is an ID (or other lookup value), it is resolved via the target
+        # class's +.find+ or +.find_by!+ method. Arrays are resolved via +.where+.
+        #
+        # The resolved record is written back to the instance variable, so subsequent
+        # calls return the same object without re-querying.
+        #
+        # @param name [Symbol] the param/ivar name, also becomes the accessor method
+        # @param finds [Class] the model class to resolve against (e.g., +User+, +Account+)
+        # @param by [Symbol] the lookup column (default: +:id+). When +:id+, uses +.find+.
+        #   Otherwise uses +.find_by!(column: value)+.
+        # @return [void]
+        #
+        # @example Basic usage with .find
+        #   lazily :user, finds: User
+        #   # user: 123       → User.find(123)
+        #   # user: user_inst → returns user_inst directly
+        #
+        # @example Custom column lookup
+        #   lazily :account, finds: Account, by: :uuid
+        #   # account: "abc-def" → Account.find_by!(uuid: "abc-def")
+        #
+        # @example Array input
+        #   lazily :users, finds: User
+        #   # users: [1, 2, 3] → User.where(id: [1, 2, 3])
+        #
+        # @note Only available when ActiveRecord is loaded (via Railtie)
+        # @see Servus::Base.call
+        def lazily(name, finds:, by: :id)
+          (@lazy_resolvers ||= {})[name] = { klass: finds, by: by }
+          define_resolver_method(name, finds, by)
+        end
+
+        # Returns the hash of registered lazy resolvers for this service class.
+        #
+        # @return [Hash{Symbol => Hash}] resolver configurations keyed by name
+        # @api private
+        def lazy_resolvers
+          @lazy_resolvers || {}
+        end
+
+        private
+
+        # Defines a lazy accessor method on a prepended module.
+        #
+        # @param name [Symbol] the method/ivar name
+        # @param klass [Class] the target model class
+        # @param by [Symbol] the lookup column
+        # @api private
+        def define_resolver_method(name, klass, by)
+          mod = (@_resolver_module ||= Module.new)
+          prepend(mod) unless ancestors.include?(mod)
+
+          mod.define_method(name) do
+            @_lazily_resolved ||= {}
+            return instance_variable_get(:"@#{name}") if @_lazily_resolved[name]
+
+            resolved = Resolver.call(instance_variable_get(:"@#{name}"), klass: klass, by: by, name: name)
+            @_lazily_resolved[name] = true
+            instance_variable_set(:"@#{name}", resolved)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/servus/extensions/lazily/errors.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Servus
+  module Extensions
+    module Lazily
+      # Error classes for lazy record resolution.
+      #
+      # These errors are raised when lazy resolution fails, such as when
+      # a required record reference is nil.
+      module Errors
+        # Base error class for all lazily extension errors.
+        #
+        # All lazy resolution errors inherit from this class for easy rescue handling.
+        class LazilyError < StandardError; end
+
+        # Raised when a lazily-resolved record reference is nil.
+        #
+        # This occurs when a service declares +lazily :user, finds: User+ but
+        # receives +user: nil+. A nil reference is always a bug at the call site.
+        #
+        # @example
+        #   class MyService < Servus::Base
+        #     lazily :user, finds: User
+        #
+        #     def initialize(user:)
+        #       @user = user
+        #     end
+        #
+        #     def call
+        #       user # => raises NotFoundError if @user is nil
+        #     end
+        #   end
+        class NotFoundError < LazilyError; end
+      end
+    end
+  end
+end

data/lib/servus/extensions/lazily/ext.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Servus
+  module Extensions
+    # Lazy record resolution extensions for Servus services.
+    #
+    # This module provides the infrastructure for lazily resolving record
+    # references (IDs or instances) in service inputs. When loaded, it extends
+    # {Servus::Base} with the {Call#lazily} class method.
+    #
+    # @see Servus::Extensions::Lazily::Call
+    module Lazily
+      require 'servus/extensions/lazily/errors'
+      require 'servus/extensions/lazily/resolver'
+      require 'servus/extensions/lazily/call'
+
+      # Extension module for lazily functionality.
+      #
+      # @api private
+      module Ext; end
+    end
+  end
+end

data/lib/servus/extensions/lazily/resolver.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Servus
+  module Extensions
+    module Lazily
+      # Performs the actual record resolution for a lazily-declared input.
+      #
+      # Handles the decision logic: is the raw value already an instance,
+      # nil, an array, or a lookup value? Delegates to the appropriate
+      # finder method on the target class.
+      #
+      # @api private
+      class Resolver
+        # Resolves a raw value to a record (or collection of records).
+        #
+        # @param raw [Object] the raw input value (ID, instance, Array, or nil)
+        # @param klass [Class] the target model class
+        # @param by [Symbol] the lookup column
+        # @param name [Symbol] the param name (for error messages)
+        # @return [Object] the resolved record or collection
+        # @raise [Errors::NotFoundError] if raw is nil
+        def self.call(raw, klass:, by:, name:)
+          return raw if raw.is_a?(klass)
+          raise Errors::NotFoundError, "Couldn't find #{klass} (#{name} was nil)" if raw.nil?
+          return klass.where(by => raw) if raw.is_a?(Array)
+
+          by == :id ? klass.find(raw) : klass.find_by!(by => raw)
+        end
+      end
+    end
+  end
+end

data/lib/servus/guard.rb

@@ -19,7 +19,7 @@ module Servus
   #       }
   #     end
   #
-  #     def test(account:, amount:)
+  #     def test
   #       account.balance >= amount
   #     end
   #   end
@@ -52,7 +52,7 @@ module Servus
       #   Servus::Guard.execute!(EnsurePositive, amount: -10) # throws :guard_failure
       def execute!(guard_class, **)
         guard = guard_class.new(**)
-        return if guard.test(**)
+        return if guard.test
 
         throw(:guard_failure, guard.error)
       end
@@ -69,7 +69,7 @@ module Servus
       #   Servus::Guard.execute?(EnsurePositive, amount: 100) # => true
       #   Servus::Guard.execute?(EnsurePositive, amount: -10) # => false
       def execute?(guard_class, **)
-        guard_class.new(**).test(**)
+        guard_class.new(**).test
       end
 
       # Declares the HTTP status code for API responses.
@@ -218,14 +218,15 @@ module Servus
 
     # Tests whether the guard passes.
     #
-    # Subclasses must implement this method with explicit keyword arguments
-    # that define the guard's contract.
+    # Subclasses must implement this zero-argument method. Arguments passed
+    # to `new` are stored as `@kwargs` and exposed via `method_missing`, so
+    # `test` reads them directly off the instance.
     #
     # @return [Boolean] true if the guard passes, false otherwise
     # @raise [NotImplementedError] if not implemented by subclass
     #
     # @example
-    #   def test(account:, amount:)
+    #   def test
     #     account.balance >= amount
     #   end
     def test

data/lib/servus/guards/falsey_guard.rb

@@ -24,10 +24,10 @@ module Servus
 
       # Tests whether all specified attributes are falsey.
       #
-      # @param on [Object] the object to check
-      # @param check [Symbol, Array<Symbol>] attribute(s) to verify
+      # Reads `on` and `check` from the kwargs stored at initialization.
+      #
       # @return [Boolean] true if all attributes are falsey
-      def test(on:, check:)
+      def test
         Array(check).all? { |attr| !on.public_send(attr) }
       end
 

data/lib/servus/guards/presence_guard.rb

@@ -36,12 +36,12 @@ module Servus
       # Tests whether all provided values are present.
       #
       # A value is considered present if it is not nil and not empty
-      # (for values that respond to empty?).
+      # (for values that respond to empty?). Reads all values from the
+      # kwargs stored at initialization.
       #
-      # @param values [Hash] keyword arguments to validate
       # @return [Boolean] true if all values are present
-      def test(**values)
-        values.all? { |_, value| present?(value) }
+      def test
+        kwargs.all? { |_, value| present?(value) }
       end
 
       private

data/lib/servus/guards/state_guard.rb

@@ -24,12 +24,11 @@ module Servus
 
       # Tests whether the attribute matches the expected value(s).
       #
-      # @param on [Object] the object to check
-      # @param check [Symbol] the attribute to verify
-      # @param is [Object, Array] expected value(s) - passes if attribute matches any
+      # Reads `on`, `check`, and `is` from the kwargs stored at initialization.
+      #
       # @return [Boolean] true if attribute matches expected value(s)
-      def test(on:, check:, is:) # rubocop:disable Naming/MethodParameterName
-        Array(is).include?(on.public_send(check))
+      def test
+        Array(kwargs[:is]).include?(on.public_send(check))
       end
 
       private

data/lib/servus/guards/truthy_guard.rb

@@ -24,10 +24,10 @@ module Servus
 
       # Tests whether all specified attributes are truthy.
       #
-      # @param on [Object] the object to check
-      # @param check [Symbol, Array<Symbol>] attribute(s) to verify
+      # Reads `on` and `check` from the kwargs stored at initialization.
+      #
       # @return [Boolean] true if all attributes are truthy
-      def test(on:, check:)
+      def test
         Array(check).all? { |attr| !!on.public_send(attr) }
       end