interaktor 0.3.0 → 0.5.0

data/lib/interaktor/interaction.rb

@@ -0,0 +1,154 @@
+module Interaktor
+  class Interaction
+    attr_reader :input_args, :success_args, :failure_args
+
+    # @param interaktor [Interaktor]
+    # @param input [Hash, Interaction]
+    def initialize(interaktor, input)
+      @interaktor = interaktor
+      @executed = false
+      @failed = false
+      @rolled_back = false
+
+      @input_args = case input
+      when Hash
+        input.transform_keys(&:to_sym)
+      when Interaction
+        input
+          .input_args
+          .merge(input.success_args || {})
+          .slice(*(interaktor.class.input_attributes || []))
+      else
+        raise ArgumentError, "Invalid input type: #{input.class}"
+      end
+    end
+
+    # Whether the interaction is successful.
+    def success?
+      if !@executed
+        raise Interaktor::Error::InvalidMethodForStateError.new(
+          self,
+          "Cannot call `success?` before interaktor execution is complete"
+        )
+      end
+
+      !failure?
+    end
+
+    # Whether the interaction has failed.
+    def failure?
+      if !@executed
+        raise Interaktor::Error::InvalidMethodForStateError.new(
+          self,
+          "Cannot call `failure?` before interaktor execution is complete"
+        )
+      end
+
+      @failed
+    end
+
+    # @param args [Hash]
+    #
+    # @raises [Interaktor::Failure]
+    def fail!(args = {})
+      if @executed
+        raise Interaktor::Error::InvalidMethodForStateError.new(
+          self,
+          "Cannot call `fail!` after interaktor execution is already complete"
+        )
+      end
+
+      @executed = true
+      @failed = true
+      @failure_args = args.transform_keys(&:to_sym)
+      raise Interaktor::Failure, self
+    end
+
+    # @param args [Hash]
+    def success!(args = {})
+      if @executed
+        raise Interaktor::Error::InvalidMethodForStateError.new(
+          self,
+          "Cannot call `success!` after interaktor execution is already complete"
+        )
+      end
+
+      @executed = true
+      @success_args = args.transform_keys(&:to_sym)
+      early_return!
+    end
+
+    def allowable_success_attributes
+      @interaktor.class.success_attributes
+    end
+
+    def allowable_failure_attributes
+      @interaktor.class.failure_attributes
+    end
+
+    # Only allow access to arguments when appropriate. Input arguments should be
+    # accessible only during the interaction's execution, and after the
+    # execution is complete, either the success or failure arguments should be
+    # accessible, depending on the outcome.
+    def method_missing(method_name, *args, &block)
+      if !@executed && input_args.key?(method_name)
+        input_args[method_name]
+      elsif success? && allowable_success_attributes.include?(method_name)
+        success_args[method_name]
+      elsif failure? && allowable_failure_attributes.include?(method_name)
+        failure_args[method_name]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      input_args.key?(method_name) ||
+        success_args&.key?(method_name) ||
+        failure_args&.key?(method_name) ||
+        super
+    end
+
+    # Roll back the interaction. Successful interactions may have this method
+    # called to roll back their state.
+    #
+    # @return [Boolean] true if rolled back successfully, false if already
+    #   rolled back
+    def rollback!
+      return false if @rolled_back
+
+      _called.reverse_each(&:rollback)
+      @rolled_back = true
+    end
+
+    # Track that an Interaktor has been called. The `#called!` method is used by
+    # the interaktor being invoked. After an interaktor is successfully called,
+    # the interaction is tracked for the purpose of potential future rollback.
+    #
+    # @param interaktor [Interaktor] an interaktor that has been successfully
+    #   called
+    def called!(interaktor)
+      @executed = true
+      _called << interaktor
+    end
+
+    # An array of successfully called Interaktor instances invoked against this
+    # interaction instance.
+    #
+    # @return [Array<Interaktor>]
+    def _called
+      @called ||= []
+    end
+
+    # Trigger an early return throw.
+    def early_return!
+      @early_return = true
+      throw :early_return, self
+    end
+
+    # Whether or not the interaction has been returned from early.
+    def early_return?
+      (@early_return == true) || false
+    end
+  end
+end

data/lib/interaktor/organizer.rb

@@ -41,8 +41,16 @@ module Interaktor::Organizer
     def call
       check_attribute_flow_valid
 
+      latest_interaction = nil
+
       self.class.organized.each do |interaktor|
-        catch(:early_return) { interaktor.call!(@context) }
+        catch(:early_return) do
+          latest_interaction = interaktor.call!(latest_interaction || @interaction)
+        end
+      end
+
+      if latest_interaction
+        @interaction.instance_variable_set(:@success_args, latest_interaction.success_args)
       end
     end
 

data/lib/interaktor.rb

@@ -14,99 +14,87 @@ module Interaktor
       extend ClassMethods
       include Hooks
       include Callable
+
+      interaction_class = Class.new(Interaktor::Interaction) do
+      end
+
+      base.const_set(:Interaction, interaction_class)
     end
   end
 
   module ClassMethods
   end
 
-  # @param context [Hash, Interaktor::Context] the context object as a hash
+  # @param args [Hash, Interaktor::Interaction] the context object as a hash
   #   with attributes or an already-built context
-  def initialize(context = {})
-    @context = Interaktor::Context.build(context)
+  def initialize(args = {})
+    @interaction = self.class::Interaction.new(self, args)
   end
 
-  # Fail the current interaktor.
-  #
-  # @param failure_attributes [Hash{Symbol=>Object}] the context attributes
-  #
-  # @return [void]
-  def fail!(failure_attributes = {})
-    # Silently remove any attributes that are not included in the schema
-    allowed_keys = self.class.failure_schema.key_map.keys.map { |k| k.name.to_sym }
-    failure_attributes.select! { |k, _| allowed_keys.include?(k.to_sym) }
-
-    self.class.validate_failure_schema(failure_attributes)
+  # @param args [Hash{Symbol=>Object}]
+  def fail!(args = {})
+    if (disallowed_key = args.keys.find { |k| !self.class.failure_attributes.include?(k.to_sym) })
+      raise Interaktor::Error::UnknownAttributeError.new(self, disallowed_key)
+    end
 
-    @context.fail!(failure_attributes)
+    self.class.validate_failure_schema(args)
+    @interaction.fail!(args)
   end
 
-  # Terminate execution of the current interaktor and copy the success
-  # attributes into the context.
-  #
-  # @param success_attributes [Hash{Symbol=>Object}] the context attributes
-  #
-  # @return [void]
-  def success!(success_attributes = {})
-    # Silently remove any attributes that are not included in the schema
-    allowed_keys = self.class.success_schema.key_map.keys.map { |k| k.name.to_sym }
-    success_attributes.select! { |k, _| allowed_keys.include?(k.to_sym) }
-
-    self.class.validate_success_schema(success_attributes)
+  # @param args [Hash]
+  def success!(args = {})
+    if (disallowed_key = args.keys.find { |k| !self.class.success_attributes.include?(k.to_sym) })
+      raise Interaktor::Error::UnknownAttributeError.new(self, disallowed_key)
+    end
 
-    @context.success!(success_attributes)
+    self.class.validate_success_schema(args)
+    @interaction.success!(args)
   end
 
   # Invoke an Interaktor instance without any hooks, tracking, or rollback. It
   # is expected that the `#call` instance method is overwritten for each
   # interaktor class.
-  #
-  # @return [void]
-  def call; end
+  def call
+  end
 
   # Reverse prior invocation of an Interaktor instance. Any interaktor class
   # that requires undoing upon downstream failure is expected to overwrite the
   # `#rollback` instance method.
-  #
-  # @return [void]
-  def rollback; end
-
-  # Invoke an interaktor instance along with all defined hooks. The `run`
-  # method is used internally by the `call` class method. After successful
-  # invocation of the interaktor, the instance is tracked within the context.
-  # If the context is failed or any error is raised, the context is rolled
-  # back.
-  #
-  # @return [void]
+  def rollback
+  end
+
+  # Invoke an interaktor instance along with all defined hooks. The `run` method
+  # is used internally by the `call` class method. After successful invocation
+  # of the interaktor, the instance is tracked within the context. If the
+  # context is failed or any error is raised, the context is rolled back.
   def run
     run!
-  rescue Interaktor::Failure # rubocop:disable Lint/SuppressedException
+  rescue Interaktor::Failure
   end
 
   # Invoke an Interaktor instance along with all defined hooks, typically used
   # internally by `.call!`. After successful invocation of the interaktor, the
-  # instance is tracked within the context. If the context is failed or any
-  # error is raised, the context is rolled back. This method behaves
-  # identically to `#run` with one notable exception - if the context is failed
-  # during the invocation of the interaktor, `Interaktor::Failure` is raised.
+  # instance is tracked within the interaction. If the interaction is failed or
+  # any error is raised, the interaction is rolled back. This method behaves
+  # identically to `#run` with one notable exception - if the interaction is
+  # failed during the invocation of the interaktor, `Interaktor::Failure` is
+  # raised.
   #
   # @raises [Interaktor::Failure]
-  #
-  # @return [void]
   def run!
     with_hooks do
       catch(:early_return) do
         call
       end
 
-      if !@context.early_return? && self.class.required_success_attributes.any?
+      if self.class.required_success_attributes.any? && !@interaction.success_args
         raise Interaktor::Error::MissingExplicitSuccessError.new(self, self.class.required_success_attributes)
       end
 
-      @context.called!(self)
+      @interaction.called!(self)
     end
-  rescue StandardError
-    @context.rollback!
+  rescue
+    @interaction.rollback!
     raise
   end
 end