axn 0.1.0.pre.alpha.2.5.3.1 → 0.1.0.pre.alpha.2.6

data/lib/action/core.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "action/context"
+
+require "action/strategies"
+require "action/core/hooks"
+require "action/core/logging"
+require "action/core/hoist_errors"
+require "action/core/handle_exceptions"
+require "action/core/automatic_logging"
+require "action/core/use_strategy"
+
+# CONSIDER: make class names match file paths?
+require "action/core/validation/validators/model_validator"
+require "action/core/validation/validators/type_validator"
+require "action/core/validation/validators/validate_validator"
+
+require "action/core/contract_validation"
+require "action/core/contract"
+require "action/core/contract_for_subfields"
+require "action/core/timing"
+
+module Action
+  module Core
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        include Core::Hooks
+        include Core::Logging
+        include Core::AutomaticLogging
+
+        include Core::HandleExceptions
+
+        include Core::ContractValidation
+        include Core::Contract
+        include Core::ContractForSubfields
+
+        include Core::HoistErrors
+        include Core::UseStrategy
+      end
+    end
+
+    module ClassMethods
+      def call(context = {})
+        new(context).tap(&:run).result
+      end
+
+      def call!(context = {})
+        result = call(context)
+        return result if result.ok?
+
+        raise result.exception || Action::Failure.new(result.error)
+      end
+    end
+
+    def initialize(context = {})
+      @context = Action::Context.build(context)
+    end
+
+    def with_tracing(&)
+      return yield unless Action.config.wrap_with_trace
+
+      Action.config.wrap_with_trace.call(self.class.name || "AnonymousClass", &)
+    rescue StandardError => e
+      Axn::Util.piping_error("running trace hook", action: self, exception: e)
+    end
+
+    def with_logging
+      timing_start = Core::Timing.now
+      _log_before
+      yield
+    ensure
+      _log_after(timing_start:, outcome: _determine_outcome)
+    end
+
+    def with_contract
+      _apply_inbound_preprocessing!
+      _apply_defaults!(:inbound)
+      _validate_contract!(:inbound)
+
+      yield
+
+      _apply_defaults!(:outbound)
+      _validate_contract!(:outbound)
+
+      # TODO: improve location of this triggering
+      trigger_on_success if respond_to?(:trigger_on_success)
+    end
+
+    def with_exception_swallowing
+      yield
+    rescue StandardError => e
+      # on_error handlers run for both unhandled exceptions and fail!
+      self.class._error_handlers.each do |handler|
+        handler.execute_if_matches(exception: e, action: self)
+      end
+
+      # on_failure handlers run ONLY for fail!
+      if e.is_a?(Action::Failure)
+        @context.instance_variable_set("@error_from_user", e.message) if e.message.present?
+
+        self.class._failure_handlers.each do |handler|
+          handler.execute_if_matches(exception: e, action: self)
+        end
+      else
+        # on_exception handlers run for ONLY for unhandled exceptions. AND NOTE: may be skipped if the exception is rescued via `rescues`.
+        trigger_on_exception(e)
+
+        @context.exception = e
+      end
+
+      @context.instance_variable_set("@failure", true)
+    end
+
+    def run
+      with_tracing do
+        with_logging do
+          with_exception_swallowing do # Exceptions stop here; outer wrappers access result status (and must not introduce another exception layer)
+            with_contract do # Library internals -- any failures (e.g. contract violations) *should* fail the Action::Result
+              with_hooks do # User hooks -- any failures here *should* fail the Action::Result
+                call
+              end
+            end
+          end
+        end
+      end
+    ensure
+      _emit_metrics
+    end
+
+    def call; end
+
+    private
+
+    def _emit_metrics
+      return unless Action.config.emit_metrics
+
+      Action.config.emit_metrics.call(
+        self.class.name || "AnonymousClass",
+        _determine_outcome,
+      )
+    rescue StandardError => e
+      Axn::Util.piping_error("running metrics hook", action: self, exception: e)
+    end
+
+    def _determine_outcome
+      return "exception" if @context.exception
+      return "failure" if @context.failure?
+
+      "success"
+    end
+  end
+end

data/lib/action/enqueueable.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "enqueueable/via_sidekiq"
+require "action/enqueueable/via_sidekiq"
 
 module Action
   module Enqueueable

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Action
-  # Raised internally when fail! is called -- triggers failure + rollback handling
+  # Raised internally when fail! is called
   class Failure < StandardError
     DEFAULT_MESSAGE = "Execution was halted"
 
@@ -17,24 +17,6 @@ module Action
     def inspect = "#<#{self.class.name} '#{message}'>"
   end
 
-  class StepsRequiredForInheritanceSupportError < StandardError
-    def message
-      <<~MSG
-        ** Inheritance support requires the following steps: **
-
-        Add this to your Gemfile:
-          gem "interactor", github: "kaspermeyer/interactor", branch: "fix-hook-inheritance"
-
-        Explanation:
-          Unfortunately the upstream interactor gem does not support inheritance of hooks, which is required for this feature.
-          This branch is a temporary fork that adds support for inheritance of hooks, but published gems cannot specify a branch dependency.
-          In the future we may inline the upstream Interactor gem entirely and remove this necessity, but while we're in alpha we're continuing
-          to use the upstream gem for stability (and there has been recent activity on the project, so they *may* be adding additional functionality
-          soon).
-      MSG
-    end
-  end
-
   class ContractViolation < StandardError
     class ReservedAttributeError < ContractViolation
       def initialize(name)

data/lib/axn/factory.rb

@@ -22,8 +22,6 @@ module Axn
         after: nil,
         around: nil,
 
-        # Allow dynamically assigning rollback method
-        rollback: nil,
         &block
       )
         args = block.parameters.each_with_object(_hash_with_default_array) { |(type, field), hash| hash[type] << field }
@@ -84,16 +82,6 @@ module Axn
           axn.after(after) if after.present?
           axn.around(around) if around.present?
 
-          # Rollback
-          if rollback.present?
-            raise ArgumentError, "[Axn::Factory] Rollback must be a callable" unless rollback.respond_to?(:call) && rollback.respond_to?(:arity)
-            raise ArgumentError, "[Axn::Factory] Rollback must be a callable with no arguments" unless rollback.arity.zero?
-
-            axn.define_method(:rollback) do
-              instance_exec(&rollback)
-            end
-          end
-
           # Default exposure
           axn.exposes(expose_return_as, allow_blank: true) if expose_return_as.present?
         end

data/lib/axn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Axn
-  VERSION = "0.1.0-alpha.2.5.3.1"
+  VERSION = "0.1.0-alpha.2.6"
 end

data/lib/axn.rb

@@ -1,31 +1,19 @@
 # frozen_string_literal: true
 
-module Axn; end
-require_relative "axn/version"
-require_relative "axn/util"
-
-require "interactor"
 require "active_support"
 
-require_relative "action/core/validation/validators/model_validator"
-require_relative "action/core/validation/validators/type_validator"
-require_relative "action/core/validation/validators/validate_validator"
+module Axn; end
+require "axn/version"
+require "axn/util"
+require "axn/factory"
 
-require_relative "action/core/exceptions"
-require_relative "action/core/logging"
-require_relative "action/core/configuration"
-require_relative "action/core/top_level_around_hook"
-require_relative "action/core/contract"
-require_relative "action/core/contract_for_subfields"
-require_relative "action/core/handle_exceptions"
-require_relative "action/core/hoist_errors"
-require_relative "action/core/use_strategy"
+require "action/configuration"
+require "action/exceptions"
 
-require_relative "axn/factory"
+require "action/core"
 
-require_relative "action/attachable"
-require_relative "action/enqueueable"
-require_relative "action/strategies"
+require "action/attachable"
+require "action/enqueueable"
 
 def Axn(callable, **) # rubocop:disable Naming/MethodName
   return callable if callable.is_a?(Class) && callable < Action
@@ -36,22 +24,7 @@ end
 module Action
   def self.included(base)
     base.class_eval do
-      include Interactor
-
-      # Include first so other modules can assume `log` is available
-      include Logging
-
-      # NOTE: include before any others that set hooks (like contract validation), so we
-      # can include those hook executions in any traces set from this hook.
-      include TopLevelAroundHook
-
-      include HandleExceptions
-      include Contract
-      include ContractForSubfields
-
-      include HoistErrors
-
-      include UseStrategy
+      include Core
 
       # --- Extensions ---
       include Attachable
@@ -59,16 +32,6 @@ module Action
 
       # Allow additional automatic includes to be configured
       Array(Action.config.additional_includes).each { |mod| include mod }
-
-      # ----
-
-      # ALPHA: Everything below here is to support inheritance
-
-      base.define_singleton_method(:inherited) do |base_klass|
-        return super(base_klass) if Interactor::Hooks::ClassMethods.private_method_defined?(:ancestor_hooks)
-
-        raise StepsRequiredForInheritanceSupportError
-      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: axn
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.alpha.2.5.3.1
+  version: 0.1.0.pre.alpha.2.6
 platform: ruby
 authors:
 - Kali Donovan
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-07-30 00:00:00.000000000 Z
+date: 2025-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -38,20 +38,6 @@ dependencies:
     - - ">"
       - !ruby/object:Gem::Version
         version: '7.0'
-- !ruby/object:Gem::Dependency
-  name: interactor
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.1.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.1.2
 description: Pattern for writing callable service objects with contract validation
   and error swallowing
 email:
@@ -90,16 +76,20 @@ files:
 - lib/action/attachable/base.rb
 - lib/action/attachable/steps.rb
 - lib/action/attachable/subactions.rb
-- lib/action/core/configuration.rb
+- lib/action/configuration.rb
+- lib/action/context.rb
+- lib/action/core.rb
+- lib/action/core/automatic_logging.rb
 - lib/action/core/context_facade.rb
 - lib/action/core/contract.rb
 - lib/action/core/contract_for_subfields.rb
+- lib/action/core/contract_validation.rb
 - lib/action/core/event_handlers.rb
-- lib/action/core/exceptions.rb
 - lib/action/core/handle_exceptions.rb
 - lib/action/core/hoist_errors.rb
+- lib/action/core/hooks.rb
 - lib/action/core/logging.rb
-- lib/action/core/top_level_around_hook.rb
+- lib/action/core/timing.rb
 - lib/action/core/use_strategy.rb
 - lib/action/core/validation/fields.rb
 - lib/action/core/validation/subfields.rb
@@ -108,6 +98,7 @@ files:
 - lib/action/core/validation/validators/validate_validator.rb
 - lib/action/enqueueable.rb
 - lib/action/enqueueable/via_sidekiq.rb
+- lib/action/exceptions.rb
 - lib/action/strategies.rb
 - lib/action/strategies/transaction.rb
 - lib/axn.rb

data/lib/action/core/top_level_around_hook.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-module Action
-  module TopLevelAroundHook
-    def self.included(base)
-      base.class_eval do
-        around :__top_level_around_hook
-
-        extend AutologgingClassMethods
-        include AutologgingInstanceMethods
-        include InstanceMethods
-      end
-    end
-
-    module AutologgingClassMethods
-      def default_autolog_level = Action.config.default_autolog_level
-    end
-
-    module AutologgingInstanceMethods
-      private
-
-      def _log_before
-        public_send(
-          self.class.default_autolog_level,
-          [
-            "About to execute",
-            _log_context(:inbound),
-          ].compact.join(" with: "),
-          before: Action.config.env.production? ? nil : "\n------\n",
-        )
-      end
-
-      def _log_after(outcome:, timing_start:)
-        elapsed_mils = ((Time.now - timing_start) * 1000).round(3)
-
-        public_send(
-          self.class.default_autolog_level,
-          [
-            "Execution completed (with outcome: #{outcome}) in #{elapsed_mils} milliseconds",
-            _log_context(:outbound),
-          ].compact.join(". Set: "),
-          after: Action.config.env.production? ? nil : "\n------\n",
-        )
-      end
-
-      def _log_context(direction)
-        data = context_for_logging(direction)
-        return unless data.present?
-
-        max_length = 150
-        suffix = "…<truncated>…"
-
-        _log_object(data).tap do |str|
-          return str[0, max_length - suffix.length] + suffix if str.length > max_length
-        end
-      end
-
-      def _log_object(data)
-        case data
-        when Hash
-          # NOTE: slightly more manual in order to avoid quotes around ActiveRecord objects' <Class#id> formatting
-          "{#{data.map { |k, v| "#{k}: #{_log_object(v)}" }.join(", ")}}"
-        when Array
-          data.map { |v| _log_object(v) }
-        else
-          return data.to_unsafe_h if defined?(ActionController::Parameters) && data.is_a?(ActionController::Parameters)
-          return "<#{data.class.name}##{data.to_param.presence || "unpersisted"}>" if defined?(ActiveRecord::Base) && data.is_a?(ActiveRecord::Base)
-
-          data.inspect
-        end
-      end
-    end
-
-    module InstanceMethods
-      def __top_level_around_hook(hooked)
-        timing_start = Time.now
-        _log_before
-
-        _configurable_around_wrapper do
-          (@outcome, @exception) = _call_and_return_outcome(hooked)
-        end
-
-        _log_after(timing_start:, outcome: @outcome)
-
-        raise @exception if @exception
-      end
-
-      private
-
-      def _configurable_around_wrapper(&)
-        return yield unless Action.config.top_level_around_hook
-
-        Action.config.top_level_around_hook.call(self.class.name || "AnonymousClass", &)
-      end
-
-      def _call_and_return_outcome(hooked)
-        hooked.call
-
-        "success"
-      rescue StandardError => e
-        [
-          e.is_a?(Action::Failure) ? "failure" : "exception",
-          e,
-        ]
-      end
-    end
-  end
-end