activeinteractor 2.0.0.alpha.3.0.1 → 2.0.0.alpha.4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58a8598be9a7d0407430fcda338c3ad1b7a37c922561701abc928398a72d9b2b
-  data.tar.gz: f206517d7852204973b1a0155a542ae9b37b2b361df65a00a5af846a42512d21
+  metadata.gz: 1ec1233daeb01ec3145d13cef57caf6c7f69a8128c311e5a0414c594c9b36f5b
+  data.tar.gz: e76d9a078f540d5e8eaa953cb1f88726bde6f507222f5f6f8c807a4f771dd6e6
 SHA512:
-  metadata.gz: 456111cd323e168b19e73aa509a90cd39eca61500828ab3f3a8083a41386b82ed7082fedc4741fbdc702755454a048c20f89f92e8d38a2d557311d58ad89c4db
-  data.tar.gz: 2741a8657cbaff1139be07b09624668d220dd246a23edff71dcdf65ef26ea461c1d7a30cd252d84cf50121e4196f941dc7f391786de6ee30996918f29f7786a7
+  metadata.gz: 79f453fbfafecdf6cc59c1eebcb26229132818c18c5109977cf70efd40e94dbfb8ce7094b3e24cb9c39238a787bcf92b12f1c39716992402e7627e6c454defe1
+  data.tar.gz: a58f48730d1494e0a52608a8b76f07a11c53158d1f67966a4f5538965fc1e0495abd847613660f1be72cfbd9b21e720d4631a8d562c37bdd28567f1acc3e73fa

data/README.md

@@ -2,6 +2,7 @@
 
 [![Version](https://img.shields.io/gem/v/activeinteractor.svg?logo=ruby)](https://rubygems.org/gems/activeinteractor)
 [![Build](https://github.com/activeinteractor/activeinteractor/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/activeinteractor/activeinteractor/actions/workflows/build.yml)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/9a44100fb77f785dac8a/test_coverage)](https://codeclimate.com/github/activeinteractor/activeinteractor/test_coverage)
 [![Docs](https://img.shields.io/badge/docs-blue)](https://activeinteractor.org/)
 [![License](https://img.shields.io/github/license/activeinteractor/activeinteractor.svg?maxAge=300)](https://github.com/activeinteractor/activeinteractor/blob/main/LICENSE)
 

data/lib/active_interactor/context/attribute.rb

@@ -34,7 +34,8 @@ module ActiveInteractor
       end
 
       def validate!
-        validate_presence! && validate_type!
+        validate_presence!
+        validate_type!
       end
 
       def value

data/lib/active_interactor/context/attribute_validation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Context
+    module AttributeValidation
+      extend ActiveSupport::Concern
+
+      included do
+        validate :validate_attributes!
+      end
+
+      protected
+
+      def validate_attributes!
+        attribute_set.attributes.each do |attribute|
+          attribute.validate!
+          attribute.error_messages.each { |message| errors.add(attribute.name, message) }
+        end
+      end
+    end
+  end
+end

data/lib/active_interactor/context/base.rb

@@ -2,27 +2,81 @@
 
 module ActiveInteractor
   module Context
+    # The base class for all context objects
     class Base
+      extend Type::DeclerationMethods::ClassMethods
       include ActiveModel::Validations
-      include ActiveModelErrorMethods
-      include AttributeRegistration
-      include AttributeAssignment
       include Type::DeclerationMethods
 
-      validate :validate_attributes!
+      class << self
+        def method_defined?(method_name)
+          attribute_set.attribute_names.include?(method_name.to_s.delete('=').to_sym) || super
+        end
+
+        protected
+
+        def attribute_set
+          @attribute_set ||= AttributeSet.new(self)
+        end
+      end
 
       def initialize(attributes = {})
-        super
-        @errors = ActiveModel::Errors.new(self)
+        attribute_set.attributes.each do |attribute|
+          next unless attributes.with_indifferent_access.key?(attribute.name)
+
+          assign_attribute_value(attribute.name, attributes.with_indifferent_access[attribute.name])
+        end
+      end
+
+      def [](attribute_name)
+        read_attribute_value(attribute_name)
+      end
+
+      def []=(attribute_name, value)
+        assign_attribute_value(attribute_name, value)
       end
 
       protected
 
-      def validate_attributes!
-        attribute_set.attributes.each do |attribute|
-          attribute.validate!
-          attribute.error_messages.each { |message| errors.add(attribute.name, message) }
+      def assign_attribute_value(attribute_name, value)
+        attribute = attribute_set.find(attribute_name)
+        raise NoMethodError, "unknown attribute '#{attribute_name}' for #{self.class.name}" unless attribute
+
+        attribute.assign_value(value)
+      end
+
+      def assignment_method_missing(method_name, *arguments)
+        if arguments.length != 1
+          raise ArgumentError,
+                "wrong number of arguments (given #{arguments.length}, expected 1)"
         end
+
+        assign_attribute_value(method_name.to_s.delete('=').to_sym, arguments.first)
+      end
+
+      def attribute_set
+        @attribute_set ||= AttributeSet.new(self, *self.class.send(:attribute_set).attributes.map(&:dup))
+      end
+
+      def method_missing(method_name, *arguments)
+        return super unless respond_to_missing?(method_name)
+        return assignment_method_missing(method_name, *arguments) if method_name.to_s.end_with?('=')
+
+        read_attribute_value(method_name)
+      end
+
+      def read_attribute_value(attribute_name)
+        attribute = attribute_set.find(attribute_name)
+        raise NoMethodError, "unknown attribute '#{attribute_name}' for #{self.class.name}" unless attribute
+
+        attribute.value
+      end
+
+      def respond_to_missing?(method_name, _include_private = false)
+        return true if attribute_set.attribute_names.include?(method_name.to_sym)
+        return true if attribute_set.attribute_names.include?(method_name.to_s.delete('=').to_sym)
+
+        super
       end
     end
   end

data/lib/active_interactor/context/input.rb

@@ -3,6 +3,11 @@
 module ActiveInteractor
   module Context
     class Input < Base
+      delegate :as_json, to: :arguments
+      delegate :to_h, to: :arguments
+      delegate :to_hash, to: :arguments
+      delegate :to_json, to: :arguments
+
       def self.argument(*attribute_args)
         attribute_set.add(*attribute_args)
       end
@@ -14,6 +19,12 @@ module ActiveInteractor
       def self.arguments
         attribute_set.attributes
       end
+
+      def arguments
+        attribute_set.attributes.each_with_object({}) do |attribute, result|
+          result[attribute.name] = attribute.value
+        end
+      end
     end
   end
 end

data/lib/active_interactor/context/output.rb

@@ -2,8 +2,12 @@
 
 module ActiveInteractor
   module Context
+    # The base class for all output context objects
     class Output < Base
-      delegate :to_h, :to_hash, :to_json, to: :fields
+      delegate :as_json, to: :fields
+      delegate :to_h, to: :fields
+      delegate :to_hash, to: :fields
+      delegate :to_json, to: :fields
 
       def self.returns(*attribute_args)
         attribute_set.add(*attribute_args)

data/lib/active_interactor/context/result.rb

@@ -3,7 +3,9 @@
 module ActiveInteractor
   module Context
     class Result
-      delegate :[], :as_json, :to_json, to: :to_hash
+      delegate :[], to: :to_hash
+      delegate :as_json, to: :to_hash
+      delegate :to_json, to: :to_hash
 
       def self.register_owner(owner)
         owner.const_set(:ResultContext, Class.new(self))
@@ -11,7 +13,7 @@ module ActiveInteractor
 
       def self.for_output_context(owner, context)
         context.fields.each_key { |field| owner::ResultContext.send(:attr_reader, field) }
-        owner::ResultContext.new(context.fields)
+        owner::ResultContext.new(context.fields.deep_dup)
       end
 
       def initialize(attributes = {})

data/lib/active_interactor/context/runtime.rb

@@ -2,6 +2,7 @@
 
 module ActiveInteractor
   module Context
+    # The base class for all runtime context objects
     class Runtime < Base
       def initialize(attributes = {})
         super

data/lib/active_interactor/context.rb

@@ -6,9 +6,7 @@ module ActiveInteractor
     extend ActiveSupport::Autoload
 
     autoload :Attribute
-    autoload :AttributeRegistration
     autoload :AttributeSet
-    autoload :AttributeAssignment
     autoload :Base
     autoload :Input
     autoload :Output

data/lib/active_interactor/errors.rb

@@ -1,22 +1,13 @@
 # frozen_string_literal: true
 
 module ActiveInteractor
-  # Raised when an interactor fails
+  # Raised on interactor failure
   #
   # @!attribute [r] result
-  #  @return [ActiveInteractor::Result] An instance of {ActiveInteractor::Result} for the
-  #    {ActiveInteractor::Interactor::Base interactor} that failed
+  #  @return [ActiveInteractor::Result] the result of the interactor that failed
   class Error < StandardError
     attr_reader :result
 
-    # Create a new instance of {ActiveInteractor::Error}
-    #
-    # @param result [ActiveInteractor::Result] An instance of {ActiveInteractor::Result} for the
-    #   {ActiveInteractor::Interactor::Base interactor} that failed
-    # @param message [String] The error message
-    #
-    # @private
-    # @return [ActiveInteractor::Error]
     def initialize(result, message = nil)
       @result = result
       super(message)

data/lib/active_interactor/interactor/base.rb

@@ -2,37 +2,295 @@
 
 module ActiveInteractor
   module Interactor
+    # The Base Class inherited by all Interactors
     class Base
-      include ContextMethods
-      include InteractionMethods
+      include ActiveSupport::Callbacks
+      extend Type::DeclerationMethods::ClassMethods
       include Type::DeclerationMethods
 
-      def initialize(input = {})
-        @raw_input = input.dup
-        validate_input_and_generate_runtime_context!
+      define_callbacks :fail, :input_context_create, :input_context_validation, :output_context_create,
+                       :output_context_validation, :perform, :rollback, :runtime_context_create
+
+      class << self
+        delegate :argument, :argument_names, :arguments, to: :input_context_class
+        delegate :returns, :field_names, :fields, to: :output_context_class
+        delegate(*ActiveModel::Validations::ClassMethods.instance_methods, to: :input_context_class, prefix: :input)
+        delegate(*ActiveModel::Validations::HelperMethods.instance_methods, to: :input_context_class, prefix: :input)
+        delegate(*ActiveModel::Validations::ClassMethods.instance_methods, to: :output_context_class, prefix: :output)
+        delegate(*ActiveModel::Validations::HelperMethods.instance_methods, to: :output_context_class, prefix: :output)
+
+        def accepts_arguments_matching(set_input_context_class)
+          @input_context_class = set_input_context_class
+        end
+        alias input_context accepts_arguments_matching
+        alias input_type accepts_arguments_matching
+
+        def after_fail(...)
+          set_callback(:fail, :after, ...)
+        end
+
+        def after_input_context_create(...)
+          set_callback(:input_context_create, :after, ...)
+        end
+
+        def after_input_context_validation(...)
+          set_callback(:input_context_validation, :after, ...)
+        end
+
+        def after_output_context_create(...)
+          set_callback(:output_context_create, :after, ...)
+        end
+
+        def after_output_context_validation(...)
+          set_callback(:output_context_validation, :after, ...)
+        end
+
+        def after_perform(...)
+          set_callback(:perform, :after, ...)
+        end
+
+        def after_rollback(...)
+          set_callback(:rollback, :after, ...)
+        end
+
+        def after_runtime_context_create(...)
+          set_callback(:runtime_context_create, :after, ...)
+        end
+
+        def around_fail(...)
+          set_callback(:fail, :around, ...)
+        end
+
+        def around_input_context_create(...)
+          set_callback(:input_context_create, :around, ...)
+        end
+
+        def around_input_context_validation(...)
+          set_callback(:input_context_validation, :around, ...)
+        end
+
+        def around_output_context_create(...)
+          set_callback(:output_context_create, :around, ...)
+        end
+
+        def around_output_context_validation(...)
+          set_callback(:output_context_validation, :around, ...)
+        end
+
+        def around_perform(...)
+          set_callback(:perform, :around, ...)
+        end
+
+        def around_rollback(...)
+          set_callback(:rollback, :around, ...)
+        end
+
+        def around_runtime_context_create(...)
+          set_callback(:runtime_context_create, :around, ...)
+        end
+
+        def before_fail(...)
+          set_callback(:fail, :before, ...)
+        end
+
+        def before_input_context_create(...)
+          set_callback(:input_context_create, :before, ...)
+        end
+
+        def before_input_context_validation(...)
+          set_callback(:input_context_validation, :before, ...)
+        end
+
+        def before_output_context_create(...)
+          set_callback(:output_context_create, :before, ...)
+        end
+
+        def before_output_context_validation(...)
+          set_callback(:output_context_validation, :before, ...)
+        end
+
+        def before_perform(...)
+          set_callback(:perform, :before, ...)
+        end
+
+        def before_rollback(...)
+          set_callback(:rollback, :before, ...)
+        end
+
+        def before_runtime_context_create(...)
+          set_callback(:runtime_context_create, :before, ...)
+        end
+
+        def input_context_class
+          @input_context_class ||= const_set(:InputContext, Class.new(Context::Input))
+        end
+
+        def output_context_class
+          @output_context_class ||= const_set(:OutputContext, Class.new(Context::Output))
+        end
+
+        def perform!(input_context = {}, options = {})
+          new(options).perform!(input_context)
+        end
+
+        def perform(input_context = {}, options = {})
+          perform!(input_context, options)
+        rescue Error => e
+          e.result
+        rescue StandardError => e
+          Result.failure(errors: e.message)
+        end
+
+        def returns_data_matching(set_output_context_class)
+          @output_context_class = set_output_context_class
+        end
+        alias output_context returns_data_matching
+        alias output_type returns_data_matching
+
+        def runtime_context_class
+          @runtime_context_class ||= begin
+            context_class = const_set(:RuntimeContext, Class.new(Context::Runtime))
+            context_class.send(:attribute_set).merge(input_context_class.send(:attribute_set).attributes)
+            context_class.send(:attribute_set).merge(output_context_class.send(:attribute_set).attributes)
+            context_class
+          end
+        end
+
+        def with_options(options)
+          new(options)
+        end
+
+        protected
+
+        def result_context
+          @result_context ||= Context::Result.register_owner(self)
+        end
+      end
+
+      def initialize(options = {})
+        @options = Options.new(options.deep_dup)
       end
 
-      def perform!
+      def interact; end
+
+      def perform!(input_context = {})
+        @raw_input = input_context.deep_dup
+        create_input_context
+        validate_input_context!
+        create_runtime_context
+        return execute_perform_with_callbacks unless @options.skip_perform_callbacks
+
+        execute_perform
+      end
+
+      def perform(input_context = {})
+        perform!(input_context)
+      rescue Error => e
+        e.result
+      rescue StandardError => e
+        Result.failure(errors: e.message)
+      end
+
+      def rollback; end
+
+      def with_options(options)
+        @options = Options.new(options.deep_dup)
+        self
+      end
+
+      protected
+
+      attr_reader :context
+
+      def create_input_context
+        run_callbacks :input_context_create do
+          @input_context = self.class.input_context_class.new(@raw_input.deep_dup)
+        end
+      end
+
+      def create_output_context
+        run_callbacks :output_context_create do
+          @output_context = self.class.output_context_class.new(@context.attributes.deep_dup)
+        end
+      end
+
+      def create_runtime_context
+        run_callbacks :runtime_context_create do
+          @context = self.class.runtime_context_class.new(@input_context.to_h.deep_dup)
+        end
+      end
+
+      def execute_perform
         with_notification(:perform) do |payload|
           interact
-          generate_and_validate_output_context!
+          create_output_context
+          validate_output_context!
           payload[:result] = Result.success(data: output_to_result_context!)
         end
       end
 
-      protected
+      def execute_perform_with_callbacks
+        run_callbacks :perform do
+          execute_perform
+        end
+      end
 
-      def fail!(errors = {})
-        result = nil
-        with_notification(:rollback) do |payload|
+      def execute_rollback_with_callbacks
+        run_callbacks :rollback do
           rollback
-          result = Result.failure(data: @output, errors: errors)
-          payload[:result] = result
+        end
+      end
+
+      def fail!(errors = {})
+        run_callbacks :fail do
+          result = nil
+          with_notification(:rollback) do |payload|
+            perform_rollback unless @options.skip_rollback
+            result = Result.failure(data: @output, errors: errors)
+            payload[:result] = result
+          end
         end
 
         raise Error, result
       end
 
+      def output_to_result_context!
+        self.class.send(:result_context).for_output_context(self.class, @output_context)
+      end
+
+      def perform_rollback
+        return execute_rollback_with_callbacks unless @options.skip_rollback_callbacks
+
+        rollback
+      end
+
+      def validate_input_context!
+        return unless @options.validate && @options.validate_input_context
+
+        run_callbacks :input_context_validation do
+          @input_context.valid?
+        end
+        return if @input_context.errors.empty?
+
+        raise Error,
+              Result.failure(errors: @input_context.errors,
+                             status: Result::STATUS[:failed_at_input])
+      end
+
+      def validate_output_context!
+        return unless @options.validate && @options.validate_output_context
+
+        run_callbacks :output_context_validation do
+          @output_context.valid?
+        end
+
+        return if @output_context.errors.empty?
+
+        raise Error,
+              Result.failure(errors: @output_context.errors,
+                             status: Result::STATUS[:failed_at_output])
+      end
+
       def with_notification(action)
         ActiveSupport::Notifications.instrument("#{self.class.name}::#{action.to_s.classify}") do |payload|
           yield payload if block_given?

data/lib/active_interactor/interactor/options.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Interactor
+    class Options
+      DEFAULTS = {
+        skip_perform_callbacks: false,
+        skip_rollback: false,
+        skip_rollback_callbacks: false,
+        validate: true,
+        validate_input_context: true,
+        validate_output_context: true
+      }.freeze
+
+      attr_reader(*DEFAULTS.keys)
+
+      def initialize(options = {})
+        prepared_options = DEFAULTS.merge(options.deep_dup)
+        prepared_options.each_pair { |key, value| instance_variable_set(:"@#{key}", value) }
+      end
+    end
+  end
+end

data/lib/active_interactor/interactor.rb

@@ -6,7 +6,6 @@ module ActiveInteractor
     extend ActiveSupport::Autoload
 
     autoload :Base
-    autoload :ContextMethods
-    autoload :InteractionMethods
+    autoload :Options
   end
 end

data/lib/active_interactor/result.rb

@@ -1,64 +1,38 @@
 # frozen_string_literal: true
 
 module ActiveInteractor
-  # The object returned by an {ActiveInteractor::Interactor::Base interactor}
+  # An interactor result
   #
   # @!attribute [r] data
+  #  @return [ActiveInteractor::Context::Result, Object, nil] the data returned by the interactor
   #
-  #  @example Given an {ActiveInteractor::Interactor::Base interactor} that creates an ActiveRecord User
-  #   class CreateUser < ActiveInteractor::Interactor::Base
-  #     argument :login, String, 'The login for the User', required: true
-  #     argument :password, String, 'The password for the User', required: true
-  #     argument :password_confirmation, String, 'The password confirmation for the user', required: true
-  #
-  #     returns :user, User, 'The created User', required: true
-  #
-  #     def interact
-  #       context.user = User.new(context)
-  #       fail!(context.user.errors) unless context.user.save
-  #     end
-  #   end
-  #
-  #   result = CreateUser.perform(login: 'johndoe', password: 'password', password_confirmation: 'password')
+  #  @example
+  #   result = CreateUser.perform(email: 'hello@aaronmallen.me', password: 'password')
   #   result.data.user
-  #
-  #   #=> <# User @login='johndoe'>
-  #
-  #  @return [ActiveInteractor::Context::Result] the data returned by the
-  #   {ActiveInteractor::Interactor::Base interactor}
+  #   #=> <#User @email="hello@aaronmallen.me">
   #
   # @!attribute [r] errors
-  #  @return [ActiveModel::Errors] the errors returned by the
-  #   {ActiveInteractor::Interactor::Base interactor}
-  #  @see https://github.com/rails/rails/blob/main/activemodel/lib/active_model/errors.rb ActiveModel::Errors
+  #  @return [ActiveModel::Errors] the errors from the interactor
+  #
+  #  @example
+  #   result = CreateUser.perform(
+  #     email: 'hello@aaronmallen',
+  #     password: 'password',
+  #     password_confirmation: 'not password'
+  #   )
+  #   result.errors.full_messages
+  #   #=> ["Password confirmation doesn't match Password"]
   class Result
-    include ActiveModelErrorMethods
+    extend ActiveModel::Naming
 
-    # @!method to_json
-    # The {ActiveInteractor::Interactor::Base result} as a Hash
-    #
-    # @example When an {ActiveInteractor::Interactor::Base interactor} succeeds
-    #  result = CreateUser.perform(login: 'johndoe', password: 'password', password_confirmation: 'password')
-    #  result.to_hash
-    #
-    #  #=> { :success => true, :errors => {}, :data => { :login => 'johndoe' } }
-    #
-    # @example When an {ActiveInteractor::Interactor::Base interactor} fails
-    #  result = CreateUser.perform(login: 'johndoe', password: 'password', password_confirmation: 'notpassword')
-    #  result.to_hash
-    #
-    #  #=> {
-    #  #=>   :success => false,
-    #  #=>   :errors => { :password_confirmation => ["doesn't match Password"] },
-    #  #=>   :data => { :login => 'johndoe' }
-    #  #=> }
-    #
-    # @deprecated will be removed in version 2.0.0-alpha.3.0.0
-    #  use {#to_hash} instead
-    # @return [Hash {Symbol => Boolean, Hash}]
+    attr_reader :data, :errors
+
+    # Return a result as a JSON string
     delegate :to_json, to: :to_hash
 
-    # @private
+    # Status codes for interactor results
+    #
+    # @visibility private
     STATUS = {
       success: 0,
       failed_at_input: 1,
@@ -66,15 +40,16 @@ module ActiveInteractor
       failed_at_output: 3
     }.freeze
 
-    attr_reader :data
-
     class << self
-      # @private
-      def success(data: {})
-        new(status: STATUS[:success], data: data)
-      end
-
-      # @private
+      # Return a failed result
+      #
+      # @visibility private
+      #
+      # @param data [ActiveInteractor::Context::Result, Object, nil] the data returned by the interactor
+      # @param errors [ActiveModel::Errors, Hash, String] the errors from the interactor
+      # @param status [Integer] the status code for the result
+      #
+      # @return [ActiveInteractor::Result] the failed result
       def failure(data: {}, errors: {}, status: STATUS[:failed_at_runtime])
         result = new(status: status, data: data)
         parse_errors(errors).each_pair do |attribute, messages|
@@ -83,6 +58,31 @@ module ActiveInteractor
         result
       end
 
+      # Needed for ActiveModel::Errors
+      #
+      # @visibility private
+      def human_attribute_name(attribute, _options = {})
+        attribute.respond_to?(:to_s) ? attribute.to_s.humanize : attribute
+      end
+
+      # Needed for ActiveModel::Errors
+      #
+      # @visibility private
+      def lookup_ancestors
+        [self]
+      end
+
+      # Return a successful result
+      #
+      # @visibility private
+      #
+      # @param data [ActiveInteractor::Context::Result, Object, nil] the data returned by the interactor
+      #
+      # @return [ActiveInteractor::Result] the successful result
+      def success(data: {})
+        new(status: STATUS[:success], data: data)
+      end
+
       private
 
       def parse_errors(errors)
@@ -98,68 +98,90 @@ module ActiveInteractor
     end
 
     private_class_method :new
-    # @private
+
+    # Create a new instance of {ActiveInteractor::Result}
+    #
+    # @visibility private
+    #
+    # @param status [Integer] the status code for the result
+    # @param data [ActiveInteractor::Context::Result, Object, nil] the data returned by the interactor
+    #
+    # @return [ActiveInteractor::Result] the result
     def initialize(status:, data: {})
       @status = status
       @data = data
       @errors = ActiveModel::Errors.new(self)
     end
 
-    # Whether or not the {ActiveInteractor::Interactor::Base result} is a failure
-    #
-    # @example When an {ActiveInteractor::Interactor::Base interactor} fails
-    #  result = CreateUser.perform(login: 'johndoe', password: 'password', password_confirmation: 'notpassword')
+    # Whether or not the result is a failure
+    #
+    # @example When the result is a success
+    #  result = CreateUser.perform(
+    #    email: 'hello@aaronmallen',
+    #    password: 'password',
+    #    password_confirmation: 'password'
+    #  )
     #  result.failure?
+    #  #=> false
     #
-    #  #=> true
-    #
-    # @example When an {ActiveInteractor::Interactor::Base interactor} succeeds
-    #  result = CreateUser.perform(login: 'johndoe', password: 'password', password_confirmation: 'password')
+    # @example When the result is a failure
+    #  result = CreateUser.perform(
+    #    email: 'hello@aaronmallen',
+    #    password: 'password',
+    #    password_confirmation: 'not password'
+    #  )
     #  result.failure?
+    #  #=> true
     #
-    #  #=> false
-    #
-    # @return [Boolean]
+    # @return [Boolean] whether or not the result is a failure
     def failure?
       !success?
     end
     alias failed? failure?
 
-    # @private
+    # Needed for ActiveModel::Errors
+    #
+    # @visibility private
     def read_attribute_for_validation(attribute_name)
       data&.send(attribute_name.to_sym)
     end
 
-    # Whether or not the {ActiveInteractor::Interactor::Base result} is a success
+    # Whether or not the result is a success
+    #
+    # @example When the result is a success
+    #  result = CreateUser.perform(
+    #    email: 'hello@aaronmallen',
+    #    password: 'password',
+    #    password_confirmation: 'password'
+    #  )
+    #  result.success?
+    #  #=> true
+    #
+    # @example When the result is a failure
+    #  result = CreateUser.perform(
+    #    email: 'hello@aaronmallen',
+    #    password: 'password',
+    #    password_confirmation: 'not password'
+    #  )
+    #  result.success?
+    #  #=> false
     #
-    # @return [Boolean]
+    # @return [Boolean] whether or not the result is a failure
     def success?
       @status == STATUS[:success]
     end
     alias successful? success?
 
-    # The {ActiveInteractor::Interactor::Base result} as a Hash
-    #
-    # @example When an {ActiveInteractor::Interactor::Base interactor} succeeds
-    #  result = CreateUser.perform(login: 'johndoe', password: 'password', password_confirmation: 'password')
-    #  result.to_hash
+    # Return the result as a hash
     #
-    #  #=> { :success => true, :errors => {}, :data => { :login => 'johndoe' } }
-    #
-    # @example When an {ActiveInteractor::Interactor::Base interactor} fails
-    #  result = CreateUser.perform(login: 'johndoe', password: 'password', password_confirmation: 'notpassword')
+    # @example
+    #  result = CreateUser.perform(email: 'hello@aaronmallen', password: 'password')
     #  result.to_hash
-    #
-    #  #=> {
-    #  #=>   :success => false,
-    #  #=>   :errors => { :password_confirmation => ["doesn't match Password"] },
-    #  #=>   :data => { :login => 'johndoe' }
-    #  #=> }
-    #
-    # @return [Hash {Symbol => Boolean, Hash}]
+    #  #=> { success: true, status: 0, errors: {}, data: { user: <#User> } }
     def to_hash
       {
         success: success?,
+        status: @status,
         errors: errors.to_hash,
         data: data.to_json
       }

data/lib/active_interactor/type/decleration_methods.rb

@@ -25,10 +25,6 @@ module ActiveInteractor
           :untyped
         end
       end
-
-      included do
-        extend ClassMethods
-      end
     end
   end
 end

data/lib/active_interactor/type.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveInteractor
-  # @private
+  # The Type namespace
   module Type
     extend ActiveSupport::Autoload
 

data/lib/active_interactor.rb

@@ -33,6 +33,8 @@ require_relative 'active_interactor/errors'
 # It has features like rich support for attributes, callbacks, and validations, and
 # thread safe performance methods.
 #
+# {https://activeinteractor.org/docs/getting-started Getting Started}
+#
 # {file:CHANGELOG.md Changelog}
 #
 # {file:HUMANS.md Acknowledgements}
@@ -44,7 +46,6 @@ require_relative 'active_interactor/errors'
 module ActiveInteractor
   extend ActiveSupport::Autoload
 
-  autoload :ActiveModelErrorMethods
   autoload :Context
   autoload :Interactor
   autoload :Result

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activeinteractor
 version: !ruby/object:Gem::Version
-  version: 2.0.0.alpha.3.0.1
+  version: 2.0.0.alpha.4.0.0
 platform: ruby
 authors:
 - Aaron Allen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-03 00:00:00.000000000 Z
+date: 2024-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -63,12 +63,10 @@ files:
 - LICENSE
 - README.md
 - lib/active_interactor.rb
-- lib/active_interactor/active_model_error_methods.rb
 - lib/active_interactor/context.rb
 - lib/active_interactor/context/attribute.rb
-- lib/active_interactor/context/attribute_assignment.rb
-- lib/active_interactor/context/attribute_registration.rb
 - lib/active_interactor/context/attribute_set.rb
+- lib/active_interactor/context/attribute_validation.rb
 - lib/active_interactor/context/base.rb
 - lib/active_interactor/context/input.rb
 - lib/active_interactor/context/output.rb
@@ -77,8 +75,7 @@ files:
 - lib/active_interactor/errors.rb
 - lib/active_interactor/interactor.rb
 - lib/active_interactor/interactor/base.rb
-- lib/active_interactor/interactor/context_methods.rb
-- lib/active_interactor/interactor/interaction_methods.rb
+- lib/active_interactor/interactor/options.rb
 - lib/active_interactor/result.rb
 - lib/active_interactor/type.rb
 - lib/active_interactor/type/base.rb
@@ -92,10 +89,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/activeinteractor/activeinteractor/issues
-  changelog_uri: https://github.com/activeinteractor/activeinteractor/blob/v2.0.0-alpha.3.0.1/CHANGELOG.md
+  changelog_uri: https://github.com/activeinteractor/activeinteractor/blob/v2.0.0-alpha.4.0.0/CHANGELOG.md
   homepage_uri: https://activeinteractor.org
-  source_code_uri: https://github.com/activeinteractor/activeinteractor/tree/v2.0.0-alpha.3.0.1
-  documentation_uri: https://activeinteractor.org/api/activeinteractor/v2.0.0-alpha.3.0.1
+  source_code_uri: https://github.com/activeinteractor/activeinteractor/tree/v2.0.0-alpha.4.0.0
+  documentation_uri: https://activeinteractor.org/api/activeinteractor/v2.0.0-alpha.4.0.0
   wiki_uri: https://github.com/activeinteractor/activeinteractor/wiki
   rubygems_mfa_required: 'true'
 post_install_message:
@@ -113,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
 summary: Ruby interactors with ActiveModel::Validations

data/lib/active_interactor/active_model_error_methods.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveInteractor
-  # @private
-  module ActiveModelErrorMethods
-    extend ActiveSupport::Concern
-
-    attr_reader :errors
-
-    # @private
-    module ClassMethods
-      def human_attribute_name(attribute, _options = {})
-        attribute.respond_to?(:to_s) ? attribute.to_s.humanize : attribute
-      end
-
-      def lookup_ancestors
-        [self]
-      end
-    end
-
-    included do
-      extend ActiveModel::Naming
-      extend ClassMethods
-    end
-
-    def read_attribute_for_validation(attribute_name)
-      send(attribute_name.to_sym)
-    end
-  end
-end

data/lib/active_interactor/context/attribute_assignment.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveInteractor
-  module Context
-    module AttributeAssignment
-      extend ActiveSupport::Concern
-
-      def initialize(attributes = {})
-        attribute_set.attributes.each do |attribute|
-          next unless attributes.with_indifferent_access.key?(attribute.name)
-
-          assign_attribute_value(attribute.name, attributes.with_indifferent_access[attribute.name])
-        end
-      end
-
-      def [](attribute_name)
-        read_attribute_value(attribute_name)
-      end
-
-      def []=(attribute_name, value)
-        assign_attribute_value(attribute_name, value)
-      end
-
-      protected
-
-      def assign_attribute_value(attribute_name, value)
-        attribute = attribute_set.find(attribute_name)
-        raise NoMethodError, "unknown attribute '#{attribute_name}' for #{self.class.name}" unless attribute
-
-        attribute.assign_value(value)
-      end
-
-      def assignment_method_missing(method_name, *arguments)
-        if arguments.length != 1
-          raise ArgumentError,
-                "wrong number of arguments (given #{arguments.length}, expected 1)"
-        end
-
-        assign_attribute_value(method_name.to_s.delete('=').to_sym, arguments.first)
-      end
-
-      def method_missing(method_name, *arguments)
-        return super unless respond_to_missing?(method_name)
-        return assignment_method_missing(method_name, *arguments) if method_name.to_s.end_with?('=')
-
-        read_attribute_value(method_name)
-      end
-
-      def read_attribute_value(attribute_name)
-        attribute = attribute_set.find(attribute_name)
-        raise NoMethodError, "unknown attribute '#{attribute_name}' for #{self.class.name}" unless attribute
-
-        attribute.value
-      end
-
-      def respond_to_missing?(method_name, _include_private = false)
-        return true if attribute_set.attribute_names.include?(method_name.to_sym)
-        return true if attribute_set.attribute_names.include?(method_name.to_s.delete('=').to_sym)
-
-        super
-      end
-    end
-  end
-end

data/lib/active_interactor/context/attribute_registration.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveInteractor
-  module Context
-    module AttributeRegistration
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        protected
-
-        def attribute_set
-          @attribute_set ||= AttributeSet.new(self)
-        end
-      end
-
-      included do
-        extend ClassMethods
-      end
-
-      protected
-
-      def attribute_set
-        @attribute_set ||= AttributeSet.new(self, *self.class.send(:attribute_set).attributes.map(&:dup))
-      end
-    end
-  end
-end

data/lib/active_interactor/interactor/context_methods.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveInteractor
-  module Interactor
-    module ContextMethods
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        delegate :argument, :argument_names, :arguments, to: :input_context_class
-        delegate :returns, :field_names, :fields, to: :output_context_class
-        delegate(*ActiveModel::Validations::ClassMethods.instance_methods, to: :input_context_class, prefix: :input)
-        delegate(*ActiveModel::Validations::HelperMethods.instance_methods, to: :input_context_class, prefix: :input)
-        delegate(*ActiveModel::Validations::ClassMethods.instance_methods, to: :output_context_class, prefix: :output)
-        delegate(*ActiveModel::Validations::HelperMethods.instance_methods, to: :output_context_class, prefix: :output)
-
-        def input_context_class
-          @input_context_class ||= const_set(:InputContext, Class.new(Context::Input))
-        end
-
-        def accepts_arguments_matching(set_input_context_class)
-          @input_context_class = set_input_context_class
-        end
-        alias input_context accepts_arguments_matching
-        alias input_type accepts_arguments_matching
-
-        def output_context_class
-          @output_context_class ||= const_set(:OutputContext, Class.new(Context::Output))
-        end
-
-        def returns_data_matching(set_output_context_class)
-          @output_context_class = set_output_context_class
-        end
-        alias output_context returns_data_matching
-        alias output_type returns_data_matching
-
-        def runtime_context_class
-          @runtime_context_class ||= begin
-            context_class = const_set(:RuntimeContext, Class.new(Context::Runtime))
-            context_class.send(:attribute_set).merge(input_context_class.send(:attribute_set).attributes)
-            context_class.send(:attribute_set).merge(output_context_class.send(:attribute_set).attributes)
-            context_class
-          end
-        end
-
-        protected
-
-        def result_context
-          @result_context ||= Context::Result.register_owner(self)
-        end
-      end
-
-      included do
-        extend ClassMethods
-
-        protected
-
-        attr_reader :context
-      end
-
-      protected # rubocop:disable Lint/UselessAccessModifier
-
-      def generate_and_validate_output_context!
-        @output = self.class.output_context_class.new(context.attributes)
-        @output.valid?
-        return if @output.errors.empty?
-
-        raise Error, Result.failure(errors: @output.errors, status: Result::STATUS[:failed_at_output])
-      end
-
-      def output_to_result_context!
-        self.class.send(:result_context).for_output_context(self.class, @output)
-      end
-
-      def validate_input_and_generate_runtime_context!
-        @input = self.class.input_context_class.new(@raw_input)
-        @input.valid?
-        return (@context = self.class.runtime_context_class.new(@raw_input)) if @input.errors.empty?
-
-        raise Error, Result.failure(errors: @input.errors, status: Result::STATUS[:failed_at_input])
-      end
-    end
-  end
-end

data/lib/active_interactor/interactor/interaction_methods.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveInteractor
-  module Interactor
-    module InteractionMethods
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        def perform!(input_context = {})
-          new(input_context).perform!
-        end
-
-        def perform(input_context = {})
-          perform!(input_context)
-        rescue Error => e
-          e.result
-        rescue StandardError => e
-          Result.failure(errors: e.message)
-        end
-      end
-
-      included do
-        extend ClassMethods
-      end
-
-      def perform
-        perform!
-      rescue Error => e
-        e.result
-      rescue StandardError => e
-        Result.failure(errors: e.message)
-      end
-
-      def interact; end
-      def rollback; end
-    end
-  end
-end