axn 0.1.0.pre.alpha.1.1 → 0.1.0.pre.alpha.2.1

data/docs/usage/using.md

@@ -7,11 +7,11 @@ outline: deep
 
 ## Common Case
 
-An action is usually executed via `#call`, and _always_ returns an instance of the `Action::Result` class.
+An action executed via `#call` _always_ returns an instance of the `Action::Result` class.
 
-This means the result _always_ implements a consistent interface, including `ok?` and `error` (see [full details](/reference/action-result)) as well as any variables that it `exposes`.  Remember any exceptions have been swallowed.
+This means the result _always_ implements a consistent interface, including `ok?` and `error` (see [full details](/reference/action-result)) as well as any variables that the action `exposes`.
 
-As a consumer, you usually want a conditional that surfaces `error` unless the result is `ok?`, and otherwise takes whatever success action is relevant.
+As a consumer, you usually want a conditional that surfaces `error` unless the result is `ok?` (remember that any exceptions have been swallowed), and otherwise takes whatever success action is relevant.
 
 For example:
 
@@ -23,9 +23,9 @@ class MessagesController < ApplicationController
       message: params[:message],
     )
 
-    if result.ok?  # [!code focus:2]
+    if result.ok?  # [!code focus:3]
       @thread_id = result.thread_id # Because `thread_id` was explicitly exposed
-      flash.now[:success] = "Sent the Slack message"
+      flash.now[:success] = result.success
     else
       flash[:alert] = result.error # [!code focus]
       redirect_to action: :new
@@ -34,21 +34,13 @@ class MessagesController < ApplicationController
 end
 ```
 
-<!-- TODO: replace manual flash success with result.success (here and in guide?) -->
-
-
 ## Advanced Usage
 
 ### `#call!`
 
-::: danger ALPHA
-* TODO - flesh out this section
-:::
-
+An action executed via `#call!` (note the `!`) does _not_ swallow exceptions -- a _successful_ action will return an `Action::Result` just like `call`, but any exceptions will bubble up uncaught (note: technically they _will_ be caught, your on_exception handler triggered, and then re-raised) and any explicit `fail!` calls will raise an `Action::Failure` exception with your custom message.
 
-* `call!`
-    * call! -- will raise any exceptions OR our own Action::Failure if user-facing error occurred (otherwise non-bang will never raise)
-    * note call! still logs completion even if failure (from configuration's on_exception)
+This is a much less common pattern, as you're giving up the benefits of error swallowing and the consistent return interface guarantee, but it can be useful in limited contexts (usually for smaller, one-off scripts where it's easier to just let a failure bubble up rather than worry about adding conditionals for error handling).
 
 
 ### `#enqueue`

data/docs/usage/writing.md

@@ -22,7 +22,7 @@ The first step is to determine what arguments you expect to be passed into `call
 
 If you want to expose any results to the caller, declare that via the `exposes` keyword.
 
-Both of these optionally accept `type:`, `allow_blank:`, and any other ActiveModel validation (see: [reference](/reference/class)).
+Both of these optionally accept `type:`, `allow_nil:`, `allow_blank:`, and any other ActiveModel validation (see: [reference](/reference/class)).
 
 
 ```ruby
@@ -66,10 +66,39 @@ See [the reference doc](/reference/instance) for a few more handy helper methods
 
 ## Customizing messages
 
-::: danger ALPHA
-* TODO: document `messages` setup
-:::
+The default `error` and `success` message strings ("Something went wrong" / "Action completed successfully", respectively) _are_ technically safe to show users, but you'll often want to set them to something more useful.
+
+There's a `messages` declaration for that -- you can set strings (most common) or a callable (note for the error case, if you give it a callable that expects a single argument, the exception that was raised will be passed in).
+
+For instance, configuring the action like this:
+
+```ruby
+class Foo
+  include Action
 
+  expects :name, type: String
+  exposes :meaning_of_life
+
+  messages success: -> { "Revealed the secret of life to #{name}" }, # [!code focus:2]
+           error: ->(e) { "No secret of life for you: #{e.message}" }
+
+  def call
+    fail! "Douglas already knows the meaning" if name == "Doug"
+
+    msg = "Hello #{name}, the meaning of life is 42"
+    expose meaning_of_life: msg
+  end
+end
+```
+
+Would give us these outputs:
+
+```ruby
+Foo.call.error # => "No secret of life for you: Name can't be blank"
+Foo.call(name: "Doug").error # => "Douglas already knows the meaning"
+Foo.call(name: "Adams").success # => "Revealed the secret of life to Adams"
+Foo.call(name: "Adams").meaning_of_life # => "Hello Adams, the meaning of life is 42"
+```
 
 ## Lifecycle methods
 
@@ -77,11 +106,17 @@ In addition to `#call`, there are a few additional pieces to be aware of:
 
 ### `#rollback`
 
+::: danger ALPHA
+* ⚠️ `#rollback` is _expected_ to be added shortly, but is not yet functional!
+:::
+
 If you define a `#rollback` method, it'll be called (_before_ returning an `Action::Result` to the caller) whenever your action fails.
 
 ### Hooks
 
-`before`, `after`, and `around` hooks are also supported.
+`before` and `after` hooks are also supported. They can receive a block directly, or the symbol name of a local method.
+
+Note execution is halted whenever `fail!` is called or an exception is raised (so a `before` block failure won't execute `call` or `after`, while an `after` block failure will make `resuilt.ok?` be false even though `call` completed successfully).
 
 ### Concrete example
 
@@ -91,17 +126,24 @@ Given this series of methods and hooks:
 class Foo
   include Action
 
-  before { log("before hook") }
-  after { log("after hook") }
+  before { log("before hook") } # [!code focus:2]
+  after :log_after
 
   def call
     log("in call")
-    raise "oh no something borked"
   end
 
   def rollback
     log("rolling back")
   end
+
+  private
+
+  def log_after
+    log("after hook")
+    raise "oh no something borked"
+    log("after after hook raised")
+  end
 end
 ```
 

data/lib/action/attachable/base.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Action
+  module Attachable
+    module Base
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def axn_for_attachment(
+          attachment_type: "Action",
+          name: nil,
+          axn_klass: nil,
+          superclass: nil,
+          **kwargs,
+          &block
+        )
+          raise ArgumentError, "#{attachment_type} name must be a string or symbol" unless name.is_a?(String) || name.is_a?(Symbol)
+          raise ArgumentError, "#{attachment_type} '#{name}' must be given an existing action class or a block" if axn_klass.nil? && !block_given?
+
+          if axn_klass && block_given?
+            raise ArgumentError,
+                  "#{attachment_type} '#{name}' was given both an existing action class and a block - only one is allowed"
+          end
+
+          if axn_klass
+            unless axn_klass.respond_to?(:<) && axn_klass < Action
+              raise ArgumentError,
+                    "#{attachment_type} '#{name}' was given an already-existing class #{axn_klass.name} that does NOT inherit from Action as expected"
+            end
+
+            if kwargs.present?
+              raise ArgumentError, "#{attachment_type} '#{name}' was given an existing action class and also keyword arguments - only one is allowed"
+            end
+
+            return axn_klass
+          end
+
+          Axn::Factory.build(superclass: superclass || self, name:, **kwargs, &block)
+        end
+      end
+    end
+  end
+end

data/lib/action/attachable/steps.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Action
+  module Attachable
+    module Steps
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_axn_steps, default: []
+      end
+
+      Entry = Data.define(:label, :axn)
+
+      class_methods do
+        def steps(*steps)
+          self._axn_steps += Array(steps).compact
+        end
+
+        def step(name, axn_klass = nil, **kwargs, &block)
+          axn_klass = axn_for_attachment(
+            name:,
+            axn_klass:,
+            attachment_type: "Step",
+            superclass: Object, # NOTE: steps skip inheriting from the wrapping class (to avoid duplicate field expectations/exposures)
+            **kwargs,
+            &block
+          )
+
+          # Add the step to the list of steps
+          steps Entry.new(label: name, axn: axn_klass)
+        end
+      end
+
+      def call
+        self.class._axn_steps.each_with_index do |step, idx|
+          # Set a default label if we were just given an array of unlabeled steps
+          # TODO: should Axn have a default label passed in already that we could pull out?
+          step = Entry.new(label: "Step #{idx + 1}", axn: step) if step.is_a?(Class)
+
+          hoist_errors(prefix: "#{step.label} step") do
+            step.axn.call(@context)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action/attachable/subactions.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Action
+  module Attachable
+    module Subactions
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_axnable_methods, default: {}
+        class_attribute :_axns, default: {}
+      end
+
+      class_methods do
+        def axnable_method(name, axn_klass = nil, **action_kwargs, &block)
+          raise ArgumentError, "Unable to attach Axn -- '#{name}' is already taken" if respond_to?(name)
+
+          self._axnable_methods = _axnable_methods.merge(name => { axn_klass:, action_kwargs:, block: })
+
+          action_kwargs[:expose_return_as] ||= :value unless axn_klass
+          axn_klass = axn_for_attachment(name:, axn_klass:, **action_kwargs, &block)
+
+          define_singleton_method("#{name}_axn") do |**kwargs|
+            axn_klass.call(**kwargs)
+          end
+
+          define_singleton_method("#{name}!") do |**kwargs|
+            result = axn_klass.call!(**kwargs)
+            result.public_send(action_kwargs[:expose_return_as])
+          end
+        end
+
+        def axn(name, axn_klass = nil, **action_kwargs, &block)
+          raise ArgumentError, "Unable to attach Axn -- '#{name}' is already taken" if respond_to?(name)
+
+          self._axns = _axns.merge(name => { axn_klass:, action_kwargs:, block: })
+
+          axn_klass = axn_for_attachment(name:, axn_klass:, **action_kwargs, &block)
+
+          define_singleton_method(name) do |**kwargs|
+            axn_klass.call(**kwargs)
+          end
+
+          # TODO: do we also need an instance-level version that auto-wraps in hoist_errors(label: name)?
+
+          define_singleton_method("#{name}!") do |**kwargs|
+            axn_klass.call!(**kwargs)
+          end
+
+          self._axns = _axns.merge(name => axn_klass)
+        end
+
+        def inherited(subclass)
+          super
+
+          return unless subclass.name.present? # TODO: not sure why..
+
+          # Need to redefine the axnable methods on the subclass to ensure they properly reference the subclass's
+          # helper method definitions and not the superclass's.
+          _axnable_methods.each do |name, config|
+            subclass.axnable_method(name, config[:axn_klass], **config[:action_kwargs], &config[:block])
+          end
+
+          _axns.each do |name, config|
+            subclass.axn(name, config[:axn_klass], **config[:action_kwargs], &config[:block])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action/attachable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "attachable/base"
+require_relative "attachable/steps"
+require_relative "attachable/subactions"
+
+module Action
+  module Attachable
+    extend ActiveSupport::Concern
+
+    included do
+      include Base
+      include Steps
+      include Subactions
+    end
+  end
+end

data/lib/action/{configuration.rb → core/configuration.rb}

@@ -12,7 +12,7 @@ module Action
 
     def on_exception(e, action:, context: {})
       if @on_exception
-        # TODO: only pass action: or context: if requested
+        # TODO: only pass action: or context: if requested (and update documentation)
         @on_exception.call(e, action:, context:)
       else
         log("[#{action.class.name.presence || "Anonymous Action"}] Exception swallowed: #{e.class.name} - #{e.message}")

data/lib/action/{context_facade.rb → core/context_facade.rb}

@@ -51,36 +51,15 @@ module Action
     def determine_error_message(only_default: false)
       return @context.error_from_user if @context.error_from_user.present?
 
+      exception = @context.exception || (only_default ? Action::Failure.new(@context) : nil)
+      msg = action._error_msg
+
       unless only_default
-        msg = message_from_rescues
-        return msg if msg.present?
+        interceptor = action.class._error_interceptor_for(exception:, action:)
+        msg = interceptor.message if interceptor
       end
 
-      the_exception = @context.exception || (only_default ? Action::Failure.new(@context) : nil)
-      stringified(action._error_msg, exception: the_exception).presence || "Something went wrong"
-    end
-
-    def message_from_rescues
-      Array(action._error_rescues).each do |(matcher, value)|
-        matches = if matcher.respond_to?(:call)
-                    if matcher.arity == 1
-                      !!action.instance_exec(exception, &matcher)
-                    else
-                      !!action.instance_exec(&matcher)
-                    end
-                  elsif matcher.is_a?(String) || matcher.is_a?(Symbol)
-                    klass = Object.const_get(matcher.to_s)
-                    klass && exception.is_a?(klass)
-                  elsif matcher < Exception
-                    exception.is_a?(matcher)
-                  else
-                    action.warn("Ignoring matcher #{matcher.inspect} in rescues command")
-                  end
-
-        return stringified(value, exception:) if matches
-      end
-
-      nil
+      stringified(msg, exception:).presence || "Something went wrong"
     end
 
     # Allow for callable OR string messages
@@ -113,11 +92,22 @@ module Action
 
   # Outbound / External ContextFacade
   class Result < ContextFacade
+    # For ease of mocking return results in tests
+    class << self
+      def ok = Class.new { include(Action) }.call
+
+      def error(msg = "Something went wrong")
+        Class.new { include(Action) }.tap do |klass|
+          klass.define_method(:call) { fail!(msg) }
+        end.call
+      end
+    end
+
     # Poke some holes for necessary internal control methods
     delegate :called!, :rollback!, :each_pair, to: :context
 
     # External interface
-    delegate :success?, :failure?, :exception, to: :context
+    delegate :success?, :exception, to: :context
     def ok? = success?
 
     def error

data/lib/action/{contract.rb → core/contract.rb}

@@ -4,8 +4,8 @@ require "active_model"
 require "active_support/core_ext/enumerable"
 require "active_support/core_ext/module/delegation"
 
-require "action/contract_validator"
-require "action/context_facade"
+require "action/core/contract_validator"
+require "action/core/context_facade"
 
 module Action
   module Contract
@@ -34,9 +34,9 @@ module Action
     FieldConfig = Data.define(:field, :validations, :default, :preprocess, :sensitive)
 
     module ClassMethods
-      def expects(*fields, allow_blank: false, default: nil, preprocess: nil, sensitive: false,
+      def expects(*fields, allow_blank: false, allow_nil: false, default: nil, preprocess: nil, sensitive: false,
                   **validations)
-        _parse_field_configs(*fields, allow_blank:, default:, preprocess:, sensitive:, **validations).tap do |configs|
+        _parse_field_configs(*fields, allow_blank:, allow_nil:, default:, preprocess:, sensitive:, **validations).tap do |configs|
           duplicated = internal_field_configs.map(&:field) & configs.map(&:field)
           raise Action::DuplicateFieldError, "Duplicate field(s) declared: #{duplicated.join(", ")}" if duplicated.any?
 
@@ -45,8 +45,8 @@ module Action
         end
       end
 
-      def exposes(*fields, allow_blank: false, default: nil, sensitive: false, **validations)
-        _parse_field_configs(*fields, allow_blank:, default:, preprocess: nil, sensitive:, **validations).tap do |configs|
+      def exposes(*fields, allow_blank: false, allow_nil: false, default: nil, sensitive: false, **validations)
+        _parse_field_configs(*fields, allow_blank:, allow_nil:, default:, preprocess: nil, sensitive:, **validations).tap do |configs|
           duplicated = external_field_configs.map(&:field) & configs.map(&:field)
           raise Action::DuplicateFieldError, "Duplicate field(s) declared: #{duplicated.join(", ")}" if duplicated.any?
 
@@ -57,11 +57,19 @@ module Action
 
       private
 
-      def _parse_field_configs(*fields, allow_blank: false, default: nil, preprocess: nil, sensitive: false,
+      RESERVED_FIELD_NAMES = %w[
+        declared_fields inspect fail!
+        default_error
+        called! rollback! each_pair success? exception ok ok? error success message
+      ].freeze
+
+      def _parse_field_configs(*fields, allow_nil: false, allow_blank: false, default: nil, preprocess: nil, sensitive: false,
                                **validations)
         # Allow local access to explicitly-expected fields -- even externally-expected needs to be available locally
         # (e.g. to allow success message callable to reference exposed fields)
         fields.each do |field|
+          raise ContractViolation::ReservedAttributeError, field if RESERVED_FIELD_NAMES.include?(field.to_s)
+
           define_method(field) { internal_context.public_send(field) }
         end
 
@@ -70,10 +78,13 @@ module Action
             v = { value: v } unless v.is_a?(Hash)
             { allow_blank: true }.merge(v)
           end
-        elsif validations.key?(:boolean)
-          validations[:presence] = false
+        elsif allow_nil
+          validations.transform_values! do |v|
+            v = { value: v } unless v.is_a?(Hash)
+            { allow_nil: true }.merge(v)
+          end
         else
-          validations[:presence] = true unless validations.key?(:presence)
+          validations[:presence] = true unless validations.key?(:presence) || Array(validations[:type]).include?(:boolean)
         end
 
         fields.map { |field| FieldConfig.new(field:, validations:, default:, preprocess:, sensitive:) }

data/lib/action/{contract_validator.rb → core/contract_validator.rb}

@@ -43,23 +43,21 @@ module Action
       end
     end
 
-    class BooleanValidator < ActiveModel::EachValidator
-      def validate_each(record, attribute, value)
-        return if [true, false].include?(value)
-
-        record.errors.add(attribute, "must be true or false")
-      end
-    end
-
     class TypeValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
-        return if value.blank? # Handled with a separate default presence validator
-
         # TODO: the last one (:value) might be my fault from the make-it-a-hash fallback in #parse_field_configs
         types = options[:in].presence || Array(options[:with]).presence || Array(options[:value]).presence
 
+        return if value.blank? && !types.include?(:boolean) # Handled with a separate default presence validator
+
         msg = types.size == 1 ? "is not a #{types.first}" : "is not one of #{types.join(", ")}"
-        record.errors.add attribute, (options[:message] || msg) unless types.any? { |type| value.is_a?(type) }
+        record.errors.add attribute, (options[:message] || msg) unless types.any? do |type|
+          if type == :boolean
+            [true, false].include?(value)
+          else
+            value.is_a?(type)
+          end
+        end
       end
     end
   end

data/lib/action/{exceptions.rb → core/exceptions.rb}

@@ -12,6 +12,8 @@ module Action
     end
 
     def message = @message.presence || "Execution was halted"
+
+    def inspect = "#<#{self.class.name} '#{message}'>"
   end
 
   class StepsRequiredForInheritanceSupportError < StandardError
@@ -33,6 +35,15 @@ module Action
   end
 
   class ContractViolation < StandardError
+    class ReservedAttributeError < ContractViolation
+      def initialize(name)
+        @name = name
+        super()
+      end
+
+      def message = "Cannot call expects or exposes with reserved field name: #{@name}"
+    end
+
     class MethodNotAllowed < ContractViolation; end
     class PreprocessingError < ContractViolation; end
 

data/lib/action/{hoist_errors.rb → core/hoist_errors.rb}

@@ -25,7 +25,7 @@ module Action
         result = begin
           yield
         rescue StandardError => e
-          warn "hoist_errors block swallowed an exception: #{e.message}"
+          log "hoist_errors block transforming a #{e.class.name} exception: #{e.message}"
           MinimalFailedResult.new(error: nil, exception: e)
         end
 
@@ -44,7 +44,8 @@ module Action
         @context.exception = result.exception if result.exception.present?
         @context.error_prefix = prefix if prefix.present?
 
-        fail! result.error
+        error = result.exception.is_a?(Action::Failure) ? result.exception.message : result.error
+        fail! error
       end
     end
   end

data/lib/action/{swallow_exceptions.rb → core/swallow_exceptions.rb}

@@ -2,20 +2,43 @@
 
 module Action
   module SwallowExceptions
+    CustomErrorInterceptor = Data.define(:matcher, :message, :should_report_error)
+    class CustomErrorInterceptor
+      def matches?(exception:, action:)
+        if matcher.respond_to?(:call)
+          if matcher.arity == 1
+            !!action.instance_exec(exception, &matcher)
+          else
+            !!action.instance_exec(&matcher)
+          end
+        elsif matcher.is_a?(String) || matcher.is_a?(Symbol)
+          klass = Object.const_get(matcher.to_s)
+          klass && exception.is_a?(klass)
+        elsif matcher < Exception
+          exception.is_a?(matcher)
+        else
+          action.warn("Ignoring apparently-invalid matcher #{matcher.inspect} -- could not find way to apply it")
+          false
+        end
+      rescue StandardError => e
+        action.warn("Ignoring #{e.class.name} raised while determining matcher: #{e.message}")
+        false
+      end
+    end
+
     def self.included(base)
       base.class_eval do
         class_attribute :_success_msg, :_error_msg
-        class_attribute :_error_rescues, default: []
+        class_attribute :_custom_error_interceptors, default: []
 
         include InstanceMethods
         extend ClassMethods
 
         def run_with_exception_swallowing!
           original_run!
-        rescue Action::Failure => e
-          # Just re-raise these (so we don't hit the unexpected-error case below)
-          raise e
         rescue StandardError => e
+          raise if e.is_a?(Action::Failure) # TODO: avoid raising if this was passed along from a child action (esp. if wrapped in hoist_errors)
+
           # Add custom hook for intercepting exceptions (e.g. Teamshares automatically logs to Honeybadger)
           trigger_on_exception(e)
 
@@ -36,6 +59,9 @@ module Action
         end
 
         def trigger_on_exception(e)
+          interceptor = self.class._error_interceptor_for(exception: e, action: self)
+          return if interceptor&.should_report_error == false
+
           Action.config.on_exception(e,
                                      action: self,
                                      context: respond_to?(:context_for_logging) ? context_for_logging : @context.to_h)
@@ -69,13 +95,32 @@ module Action
         true
       end
 
-      def rescues(matcher = nil, message = nil, **match_and_messages)
-        raise ArgumentError, "rescues must be called with a key, value pair or else keyword args" if [matcher, message].compact.size == 1
+      def error_from(matcher = nil, message = nil, **match_and_messages)
+        _register_error_interceptor(matcher, message, should_report_error: true, **match_and_messages)
+      end
 
-        { matcher => message }.compact.merge(match_and_messages).each { |mam| self._error_rescues += [mam] }
+      def rescues(matcher = nil, message = nil, **match_and_messages)
+        _register_error_interceptor(matcher, message, should_report_error: false, **match_and_messages)
       end
 
       def default_error = new.internal_context.default_error
+
+      # Private helpers
+
+      def _error_interceptor_for(exception:, action:)
+        Array(_custom_error_interceptors).detect do |int|
+          int.matches?(exception:, action:)
+        end
+      end
+
+      def _register_error_interceptor(matcher, message, should_report_error:, **match_and_messages)
+        method_name = should_report_error ? "error_from" : "rescues"
+        raise ArgumentError, "#{method_name} must be called with a key/value pair, or else keyword args" if [matcher, message].compact.size == 1
+
+        { matcher => message }.compact.merge(match_and_messages).each do |(matcher, message)| # rubocop:disable Lint/ShadowingOuterLocalVariable
+          self._custom_error_interceptors += [CustomErrorInterceptor.new(matcher:, message:, should_report_error:)]
+        end
+      end
     end
 
     module InstanceMethods

data/lib/action/{top_level_around_hook.rb → core/top_level_around_hook.rb}

@@ -44,10 +44,21 @@ module Action
 
         debug [
           "Execution completed (with outcome: #{outcome}) in #{elapsed_mils} milliseconds",
-          context_for_logging(:outbound).presence&.inspect,
+          _log_after_data_peak,
         ].compact.join(". Set: ")
       end
 
+      def _log_after_data_peak
+        return unless (data = context_for_logging(:outbound)).present?
+
+        max_length = 100
+        suffix = "...<truncated>...}"
+
+        data.inspect.tap do |str|
+          return str[0, max_length - suffix.length] + suffix if str.length > max_length
+        end
+      end
+
       def _call_and_return_outcome(hooked)
         hooked.call