interaktor 0.5.0 → 0.6.0.pre

data/lib/interaktor/callable.rb

@@ -1,279 +1,58 @@
-require "dry-schema"
-
-Dry::Schema.load_extensions(:info)
-
 module Interaktor::Callable
   # When the module is included in a class, add the relevant class methods to
   # that class.
   #
   # @param base [Class] the class which is including the module
   def self.included(base)
-    base.class_eval { extend ClassMethods }
+    base.class_eval do
+      extend ClassMethods
+    end
   end
 
   module ClassMethods
-    ####################
-    # INPUT ATTRIBUTES #
-    ####################
-
-    # The list of attributes which are required to be passed in when calling
-    # the interaktor.
-    #
-    # @return [Array<Symbol>]
-    def required_input_attributes
-      @required_input_attributes ||= input_schema
-        .info[:keys]
-        .select { |_, info| info[:required] }
-        .keys
-    end
-
-    # The list of attributes which are not required to be passed in when
-    # calling the interaktor.
-    #
-    # @return [Array<Symbol>]
-    def optional_input_attributes
-      # Adding an optional attribute with NO predicates with Dry::Schema is
-      # sort of a "nothing statement" - the schema can sort of ignore it. The
-      # problem is that the optional-with-no-predicate key is not included in
-      # the #info results, so we need to find an list of keys elsewhere, find
-      # the ones that are listed there but not in the #info results, and find
-      # the difference. The result are the keys that are omitted from the #info
-      # result because they are optional and have no predicates.
-      #
-      # See https://github.com/dry-rb/dry-schema/issues/347
-      @optional_input_attributes ||= begin
-        attributes_in_info = input_schema.info[:keys].keys
-        all_attributes = input_schema.key_map.keys.map(&:id)
-        optional_attributes_by_exclusion = all_attributes - attributes_in_info
+    def input(&block)
+      raise "Input block already defined" if defined?(self::InputAttributesModel)
 
-        explicitly_optional_attributes = input_schema.info[:keys].reject { |_, info| info[:required] }.keys
+      # Define self::InputAttributesModel
+      Class.new(Interaktor::Attributes, &block).tap do |klass|
+        klass.define_singleton_method(:inspect) { name.to_s }
+        klass.define_singleton_method(:to_s) { inspect }
 
-        explicitly_optional_attributes + optional_attributes_by_exclusion
-      end
-    end
+        const_set(:InputAttributesModel, klass)
 
-    # The complete list of input attributes.
-    #
-    # @return [Array<Symbol>]
-    def input_attributes
-      required_input_attributes + optional_input_attributes
-    end
-
-    # Get the input attribute schema. Fall back to an empty schema with a
-    # configuration that will deny ALL provided attributes - not defining an
-    # input schema should mean the interaktor has no input attributes.
-    #
-    # @return [Dry::Schema::Params]
-    def input_schema
-      @input_schema || Dry::Schema.Params
-    end
-
-    # @param args [Hash]
-    def validate_input_schema(args)
-      return if !input_schema
-
-      if (errors = input_schema.call(args).errors).any?
-        raise Interaktor::Error::AttributeSchemaValidationError.new(
-          self,
-          errors.to_h
-        )
-      end
-    end
+        klass.check_for_disallowed_attribute_names!
 
-    # @param schema [Dry::Schema::Params, nil] a predefined schema object
-    # @yield a new Dry::Schema::Params definition block
-    def input(schema = nil, &block)
-      raise "No schema or schema definition block provided to interaktor input." if schema.nil? && !block
-
-      raise "Provided both a schema and a schema definition block for interaktor input." if schema && block
-
-      if schema
-        raise "Provided argument is not a Dry::Schema::Params object." unless schema.is_a?(Dry::Schema::Params)
-
-        @input_schema = schema
-      elsif block
-        @input_schema = Dry::Schema.Params { instance_eval(&block) }
-      end
-
-      # define the getters and setters for the input attributes
-      @input_schema.key_map.keys.each do |key| # rubocop:disable Style/HashEachMethods
-        attribute_name = key.id
-
-        # Define getter
-        define_method(attribute_name) { @interaction.send(attribute_name) }
-
-        # Define setter
-        define_method(:"#{attribute_name}=") do |value|
-          @interaction.send(:"#{attribute_name}=", value)
+        klass.attribute_names.each do |name|
+          define_method(name) { @interaction.send(name) }
         end
       end
     end
 
-    ######################
-    # FAILURE ATTRIBUTES #
-    ######################
-
-    # The list of attributes which are required to be provided when failing the
-    # interaktor.
-    #
-    # @return [Array<Symbol>]
-    def required_failure_attributes
-      @required_failure_attributes ||= failure_schema.info[:keys]
-        .select { |_, info| info[:required] }
-        .keys
-    end
+    def failure(&block)
+      raise "Failure block already defined" if defined?(self::FailureAttributesModel)
 
-    # The list of attributes which are not required to be provided when failing
-    # the interaktor.
-    #
-    # @return [Array<Symbol>]
-    def optional_failure_attributes
-      # Adding an optional attribute with NO predicates with Dry::Schema is
-      # sort of a "nothing statement" - the schema can sort of ignore it. The
-      # problem is that the optional-with-no-predicate key is not included in
-      # the #info results, so we need to find an list of keys elsewhere, find
-      # the ones that are listed there but not in the #info results, and find
-      # the difference. The result are the keys that are omitted from the #info
-      # result because they are optional and have no predicates.
-      #
-      # See https://github.com/dry-rb/dry-schema/issues/347
-      @optional_failure_attributes ||= begin
-        attributes_in_info = failure_schema.info[:keys].keys
-        all_attributes = failure_schema.key_map.keys.map(&:id)
-        optional_attributes_by_exclusion = all_attributes - attributes_in_info
+      # Define self::FailureAttributesModel
+      Class.new(Interaktor::Attributes, &block).tap do |klass|
+        klass.define_singleton_method(:inspect) { name.to_s }
+        klass.define_singleton_method(:to_s) { inspect }
 
-        explicitly_optional_attributes = failure_schema.info[:keys].reject { |_, info| info[:required] }.keys
+        const_set(:FailureAttributesModel, klass)
 
-        explicitly_optional_attributes + optional_attributes_by_exclusion
+        klass.check_for_disallowed_attribute_names!
       end
     end
 
-    # The complete list of failure attributes.
-    #
-    # @return [Array<Symbol>]
-    def failure_attributes
-      required_failure_attributes + optional_failure_attributes
-    end
+    def success(&block)
+      raise "Success block already defined" if defined?(self::SuccessAttributesModel)
 
-    # Get the failure attribute schema. Fall back to an empty schema with a
-    # configuration that will deny ALL provided attributes - not defining an
-    # failure schema should mean the interaktor has no failure attributes.
-    #
-    # @return [Dry::Schema::Params]
-    def failure_schema
-      @failure_schema || Dry::Schema.Params
-    end
+      # Define self::SuccessAttributesModel
+      Class.new(Interaktor::Attributes, &block).tap do |klass|
+        klass.define_singleton_method(:inspect) { name.to_s }
+        klass.define_singleton_method(:to_s) { inspect }
 
-    # @param args [Hash]
-    #
-    # @return [void]
-    def validate_failure_schema(args)
-      return if !failure_schema
+        const_set(:SuccessAttributesModel, klass)
 
-      if (errors = failure_schema.call(args).errors).any?
-        raise Interaktor::Error::AttributeSchemaValidationError.new(
-          self,
-          errors.to_h
-        )
-      end
-    end
-
-    # @param schema [Dry::Schema::Params, nil] a predefined schema object
-    # @yield a new Dry::Schema::Params definition block
-    def failure(schema = nil, &block)
-      raise "No schema or schema definition block provided to interaktor failure method." if schema.nil? && !block
-
-      raise "Provided both a schema and a schema definition block for interaktor failure method." if schema && block
-
-      if schema
-        raise "Provided argument is not a Dry::Schema::Params object." unless schema.is_a?(Dry::Schema::Params)
-
-        @failure_schema = schema
-      elsif block
-        @failure_schema = Dry::Schema.Params { instance_eval(&block) }
-      end
-    end
-
-    ######################
-    # SUCCESS ATTRIBUTES #
-    ######################
-
-    # The list of attributes which are required to be provided when the
-    # interaktor succeeds.
-    #
-    # @return [Array<Symbol>]
-    def required_success_attributes
-      @required_success_attributes ||= success_schema.info[:keys]
-        .select { |_, info| info[:required] }
-        .keys
-    end
-
-    # The list of attributes which are not required to be provided when failing
-    # the interaktor.
-    #
-    # @return [Array<Symbol>]
-    def optional_success_attributes
-      # Adding an optional attribute with NO predicates with Dry::Schema is
-      # sort of a "nothing statement" - the schema can sort of ignore it. The
-      # problem is that the optional-with-no-predicate key is not included in
-      # the #info results, so we need to find an list of keys elsewhere, find
-      # the ones that are listed there but not in the #info results, and find
-      # the difference. The result are the keys that are omitted from the #info
-      # result because they are optional and have no predicates.
-      #
-      # See https://github.com/dry-rb/dry-schema/issues/347
-      @optional_success_attributes ||= begin
-        attributes_in_info = success_schema.info[:keys].keys
-        all_attributes = success_schema.key_map.keys.map(&:id)
-        optional_attributes_by_exclusion = all_attributes - attributes_in_info
-
-        explicitly_optional_attributes = success_schema.info[:keys].reject { |_, info| info[:required] }.keys
-
-        explicitly_optional_attributes + optional_attributes_by_exclusion
-      end
-    end
-
-    # The complete list of success attributes.
-    #
-    # @return [Array<Symbol>]
-    def success_attributes
-      required_success_attributes + optional_success_attributes
-    end
-
-    # Get the success attribute schema. Fall back to an empty schema with a
-    # configuration that will deny ALL provided attributes - not defining an
-    # success schema should mean the interaktor has no success attributes.
-    #
-    # @return [Dry::Schema::Params]
-    def success_schema
-      @success_schema || Dry::Schema.Params
-    end
-
-    # @param args [Hash]
-    def validate_success_schema(args)
-      return if !success_schema
-
-      if (errors = success_schema.call(args).errors).any?
-        raise Interaktor::Error::AttributeSchemaValidationError.new(
-          self,
-          errors.to_h
-        )
-      end
-    end
-
-    # @param schema [Dry::Schema::Params, nil] a predefined schema object
-    # @yield a new Dry::Schema::Params definition block
-    def success(schema = nil, &block)
-      raise "No schema or schema definition block provided to interaktor success method." if schema.nil? && !block
-
-      raise "Provided both a schema and a schema definition block for interaktor success method." if schema && block
-
-      if schema
-        raise "Provided argument is not a Dry::Schema::Params object." unless schema.is_a?(Dry::Schema::Params)
-
-        @success_schema = schema
-      elsif block
-        @success_schema = Dry::Schema.Params { instance_eval(&block) }
+        klass.check_for_disallowed_attribute_names!
       end
     end
 
@@ -312,22 +91,23 @@ module Interaktor::Callable
     #
     # @return [Interaktor::Interaction]
     def execute(args, raise_exception:)
-      run_method = raise_exception ? :run! : :run
-
-      case args
-      when Hash
-        if (disallowed_key = args.keys.find { |k| !input_attributes.include?(k.to_sym) })
-          raise Interaktor::Error::UnknownAttributeError.new(self, disallowed_key)
-        end
-
-        validate_input_schema(args)
-        new(args).tap(&run_method).instance_variable_get(:@interaction)
-      when Interaktor::Interaction
-        new(args).tap(&run_method).instance_variable_get(:@interaction)
+      interaction = case args
+      when Hash, Interaktor::Interaction
+        new(args)
+          .tap(&(raise_exception ? :run! : :run))
+          .instance_variable_get(:@interaction)
       else
         raise ArgumentError,
           "Expected a hash argument when calling the interaktor, got a #{args.class} instead."
       end
+
+      if interaction.success? &&
+          !interaction.early_return? &&
+          defined?(self::SuccessAttributesModel)
+        raise Interaktor::Error::MissingExplicitSuccessError.new(self)
+      end
+
+      interaction
     end
   end
 end

data/lib/interaktor/error/attribute_error.rb

@@ -1,9 +1,9 @@
 class Interaktor::Error::AttributeError < Interaktor::Error::Base
-  # @return [Array<Symbol>]
+  # @return [Array<String>]
   attr_reader :attributes
 
   # @param interaktor [Class]
-  # @param attributes [Array<Symbol>]
+  # @param attributes [Array<String>]
   def initialize(interaktor, attributes)
     super(interaktor)
 

data/lib/interaktor/error/attribute_validation_error.rb

@@ -0,0 +1,20 @@
+class Interaktor::Error::AttributeValidationError < Interaktor::Error::Base
+  attr_reader :model
+
+  # @param model [Object]
+  def initialize(interaktor, model)
+    super(interaktor)
+
+    @model = model
+  end
+
+  # @return [Hash{Symbol=>Array<String>}]
+  def validation_errors
+    model.errors.messages
+  end
+
+  # @return [String]
+  def message
+    "Interaktor attributes failed validation:\n  #{model.errors.full_messages.join("\n  ")}"
+  end
+end

data/lib/interaktor/error/missing_explicit_success_error.rb

@@ -1,5 +1,10 @@
-class Interaktor::Error::MissingExplicitSuccessError < Interaktor::Error::AttributeError
+class Interaktor::Error::MissingExplicitSuccessError < Interaktor::Error::Base
   def message
-    "#{interaktor} interaktor execution finished successfully but requires one or more success parameters to have been provided: #{attributes.join(", ")}"
+    <<~MSG.gsub(/\s+/, " ")
+      #{interaktor} interaktor execution finished successfully, but the
+      interaktor definition includes a `success` attribute definition, and as a
+      result the interaktor must call the `success!` method with the appropriate
+      attributes.
+    MSG
   end
 end

data/lib/interaktor/error/organizer_missing_passed_attribute_error.rb

@@ -1,21 +1,21 @@
 class Interaktor::Error::OrganizerMissingPassedAttributeError < Interaktor::Error::AttributeError
-  # @return [Symbol]
+  # @return [String]
   attr_reader :attribute
 
   # @param next_interaktor [Class]
-  # @param attribute [Symbol]
+  # @param attribute [Symbol, String]
   def initialize(interaktor, attribute)
-    super(interaktor, [attribute])
+    super(interaktor, [attribute.to_s])
 
-    @attribute = attribute
+    @attribute = attribute.to_s
   end
 
   def message
     <<~MESSAGE.strip.tr("\n", " ")
-      An organized #{interaktor} interaktor requires a '#{attribute}' input
+      An organized #{interaktor} interaktor defines a '#{attribute}' input
       attribute, but none of the interaktors that come before it in the
-      organizer list it as a success attribute, and the organizer does not list
-      it as a required attribute.
+      organizer list it as a success attribute, and the organizer does not
+      define it as an input attribute.
     MESSAGE
   end
 end

data/lib/interaktor/error/organizer_success_attribute_missing_error.rb

@@ -1,13 +1,13 @@
 class Interaktor::Error::OrganizerSuccessAttributeMissingError < Interaktor::Error::AttributeError
-  # @return [Symbol]
+  # @return [String]
   attr_reader :attribute
 
   # @param interaktor [Class]
-  # @param attribute [Symbol]
+  # @param attribute [Symbol, String]
   def initialize(interaktor, attribute)
-    super(interaktor, [attribute])
+    super(interaktor, [attribute.to_s])
 
-    @attribute = attribute
+    @attribute = attribute.to_s
   end
 
   def message

data/lib/interaktor/error/unknown_attribute_error.rb

@@ -1,13 +1,13 @@
 class Interaktor::Error::UnknownAttributeError < Interaktor::Error::AttributeError
-  # @return [Symbol]
+  # @return [String]
   attr_reader :attribute
 
   # @param interaktor [Class]
-  # @param attribute [Symbol]
+  # @param attribute [Symbol, String]
   def initialize(interaktor, attribute)
-    super(interaktor, [attribute])
+    super(interaktor, [attribute.to_s])
 
-    @attribute = attribute
+    @attribute = attribute.to_s
   end
 
   def message

data/lib/interaktor/interaction.rb

@@ -1,6 +1,15 @@
+require "active_model"
+
 module Interaktor
   class Interaction
-    attr_reader :input_args, :success_args, :failure_args
+    # @return [InputAttributesModel, nil]
+    attr_reader :input_object
+
+    # @return [SuccessAttributesModel, nil]
+    attr_reader :success_object
+
+    # @return [FailureAttributesModel, nil]
+    attr_reader :failure_object
 
     # @param interaktor [Interaktor]
     # @param input [Hash, Interaction]
@@ -10,16 +19,36 @@ module Interaktor
       @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}"
+      @input_object = if defined?(interaktor.class::InputAttributesModel)
+        result = interaktor.class::InputAttributesModel.new
+
+        case input
+        when Hash
+          input.each do |k, v|
+            result.send("#{k}=", v)
+          rescue NoMethodError => e
+            if e.receiver == result
+              raise Interaktor::Error::UnknownAttributeError.new(interaktor, k)
+            else
+              raise e
+            end
+          end
+        when Interaction
+          (input.input_object&.attributes || {})
+            .merge(input.success_object&.attributes || {})
+            .slice(*result.attribute_names)
+            .each { |k, v| result.send("#{k}=", v) }
+        else
+          raise ArgumentError, "Invalid input type: #{input.class}"
+        end
+
+        if !result.valid?
+          raise Interaktor::Error::AttributeValidationError.new(@interaktor, result)
+        end
+
+        result
+      elsif input.is_a?(Hash) && !input.empty?
+        raise Interaktor::Error::UnknownAttributeError.new(interaktor, input.keys.first)
       end
     end
 
@@ -60,7 +89,23 @@ module Interaktor
 
       @executed = true
       @failed = true
-      @failure_args = args.transform_keys(&:to_sym)
+
+      if defined?(@interaktor.class::FailureAttributesModel)
+        @failure_object = @interaktor.class::FailureAttributesModel.new.tap do |obj|
+          args.each do |k, v|
+            obj.send("#{k}=", v)
+          rescue NoMethodError
+            raise Interaktor::Error::UnknownAttributeError.new(@interaktor, k)
+          end
+
+          if !obj.valid?
+            raise Interaktor::Error::AttributeValidationError.new(@interaktor, obj)
+          end
+        end
+      elsif args.any?
+        raise Interaktor::Error::UnknownAttributeError.new(@interaktor, args.keys.first)
+      end
+
       raise Interaktor::Failure, self
     end
 
@@ -74,16 +119,24 @@ module Interaktor
       end
 
       @executed = true
-      @success_args = args.transform_keys(&:to_sym)
-      early_return!
-    end
 
-    def allowable_success_attributes
-      @interaktor.class.success_attributes
-    end
+      if defined?(@interaktor.class::SuccessAttributesModel)
+        @success_object = @interaktor.class::SuccessAttributesModel.new.tap do |obj|
+          args.each do |k, v|
+            obj.send("#{k}=", v)
+          rescue NoMethodError
+            raise Interaktor::Error::UnknownAttributeError.new(@interaktor, k)
+          end
+
+          if !obj.valid?
+            raise Interaktor::Error::AttributeValidationError.new(@interaktor, obj)
+          end
+        end
+      elsif args.any?
+        raise Interaktor::Error::UnknownAttributeError.new(@interaktor, args.keys.first)
+      end
 
-    def allowable_failure_attributes
-      @interaktor.class.failure_attributes
+      early_return!
     end
 
     # Only allow access to arguments when appropriate. Input arguments should be
@@ -91,21 +144,22 @@ module Interaktor
     # 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]
+      method_string = method_name.to_s
+      if !@executed && input_object&.attribute_names&.include?(method_string)
+        input_object.send(method_string)
+      elsif @executed && success? && success_object&.attribute_names&.include?(method_string)
+        success_object.send(method_string)
+      elsif @executed && failure? && failure_object&.attribute_names&.include?(method_string)
+        failure_object.send(method_string)
       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) ||
+      input_object&.attribute_names&.include?(method_name) ||
+        success_object&.attribute_names&.include?(method_name) ||
+        failure_object&.attribute_names&.include?(method_name) ||
         super
     end
 

data/lib/interaktor/organizer.rb

@@ -39,8 +39,6 @@ module Interaktor::Organizer
     #
     # @return [void]
     def call
-      check_attribute_flow_valid
-
       latest_interaction = nil
 
       self.class.organized.each do |interaktor|
@@ -49,39 +47,13 @@ module Interaktor::Organizer
         end
       end
 
-      if latest_interaction
-        @interaction.instance_variable_set(:@success_args, latest_interaction.success_args)
-      end
-    end
-
-    private
-
-    # @return [void]
-    def check_attribute_flow_valid
-      interaktors = self.class.organized
-
-      # @type [Array<Symbol>]
-      success_attributes_so_far = []
-
-      success_attributes_so_far += self.class.required_input_attributes
-
-      # @param interaktor [Class]
-      interaktors.each do |interaktor|
-        interaktor.required_input_attributes.each do |required_attr|
-          unless success_attributes_so_far.include?(required_attr)
-            raise Interaktor::Error::OrganizerMissingPassedAttributeError.new(interaktor, required_attr)
-          end
-        end
-
-        success_attributes_so_far += interaktor.success_attributes
-
-        next unless interaktor == interaktors.last
-
-        self.class.success_attributes.each do |success_attr|
-          unless success_attributes_so_far.include?(success_attr)
-            raise Interaktor::Error::OrganizerSuccessAttributeMissingError.new(interaktor, success_attr)
-          end
-        end
+      if defined?(self.class::SuccessAttributesModel)
+        @interaction.success!(
+          latest_interaction
+            .success_object
+            &.attributes
+            &.slice(*self.class::SuccessAttributesModel.attribute_names) || {}
+        )
       end
     end
   end