activeinteractor 2.0.0.alpha.2.0.0 → 2.0.0.alpha.2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a13c3091acf37b48e249f912e5551da92b039e17920e53c1082ebcc4b34f4c2
-  data.tar.gz: 8e1e80f06675574384eeae45835f6372bf04d7378cdf64f7f21323d36857a7e4
+  metadata.gz: e288a5c77ab45d9b0009db2a3d1a2997bd577207bb20f16386c8aa29be50f454
+  data.tar.gz: 6e045fd1af8f93d2f22aeed4d96ddb44ac93f83cce65ea9237da3e2de3d167db
 SHA512:
-  metadata.gz: 6b006f6e815419f58a6b6f063d37db8beae1e1ad239d98635545bb267d2c09df9307ec80528c1785035013aeaf07f27a73fcd1668dac44115e466109da675910
-  data.tar.gz: 3f0d5b6fd50726ec6539b691257d00d85254e1ca74c06727d84da7763e8545d033650c6ec7482f307e622e77bff2bc8fcae25e54c2f6a15208377258dac1d814
+  metadata.gz: e22e0efcf6e53c4c70cf1b30e7871b17de7ebf13933779b989b40119ce3628eab3ade0228f1f3bbf96e7976440661cb0d4b8ec8d09f7af64d56074bf15e47ed1
+  data.tar.gz: 7cef976acbe9bfd3ef6a9e7d24237587d4a51220b5c08b8595cdfa4522ae6e84aba8903c6ab5fadb97d1529529fb216a00eab92adc171cc3c997eb0f05c7cdda

data/lib/active_interactor/base.rb

@@ -3,8 +3,20 @@
 module ActiveInteractor
   class Base
     class << self
-      def argument(name, type, description = nil, **options)
-        attributes[:arguments][name.to_sym] = { name: name, type: type, description: description }.merge(options)
+      delegate :argument, :argument_names, :arguments, to: :input_context_class
+      delegate :returns, :field_names, :fields, to: :output_context_class
+
+      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
+
+      def output_context_class
+        @output_context_class ||= const_set(:OutputContext, Class.new(Context::Output))
       end
 
       def perform!(input_context = {})
@@ -19,25 +31,32 @@ module ActiveInteractor
         Result.failure(errors: e.message)
       end
 
-      def returns(name, type, description = nil, **options)
-        attributes[:fields][name.to_sym] = { name: name, type: type, description: description }.merge(options)
+      def returns_data_matching(set_output_context_class)
+        @output_context_class = set_output_context_class
       end
-
-      private
-
-      def attributes
-        @attributes ||= { arguments: {}, fields: {} }
+      alias output_context 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
     end
 
     def initialize(input = {})
-      @input = input.freeze
-      @context = parse_input!
+      @raw_input = input.dup
+      validate_input_and_generate_runtime_context!
     end
 
     def perform!
-      interact
-      Result.success(data: parse_output!)
+      with_notification(:perform) do |payload|
+        interact
+        generate_and_validate_output_context!
+        payload[:result] = Result.success(data: @output)
+      end
     end
 
     def perform
@@ -56,40 +75,36 @@ module ActiveInteractor
     attr_accessor :context
 
     def fail!(errors = {})
-      rollback
-      raise Error, Result.failure(data: context, errors: errors)
-    end
-
-    def parse_input!
-      errors = {}
-      context = self.class.send(:attributes)[:arguments].each_with_object({}) do |(name, options), hash|
-        errors = validate_attribute_value(@input[name], name, options, errors)
-        hash[name] = @input[name] || options[:default]
+      result = nil
+      with_notification(:rollback) do |payload|
+        rollback
+        result = Result.failure(data: parse_output!, errors: errors)
+        payload[:result] = result
       end
 
-      raise Error, Result.failure(errors: errors, status: Result::STATUS[:failed_on_input]) unless errors.empty?
-
-      context
+      raise Error, result
     end
 
-    def parse_output!
-      errors = {}
-      context = self.class.send(:attributes)[:fields].each_with_object({}) do |(name, options), hash|
-        errors = validate_attribute_value(self.context[name], name, options, errors)
-        hash[name] = self.context[name] || options[:default]
-      end
-
-      raise Error, Result.failure(errors: errors, status: Result::STATUS[:failed_on_output]) unless errors.empty?
+    def generate_and_validate_output_context!
+      @output = self.class.output_context_class.new(context.attributes)
+      @output.validate!
+      return @output if @output.errors.empty?
 
-      context
+      raise Error, Result.failure(errors: @output.errors, status: Result::STATUS[:failed_at_output])
     end
 
-    def validate_attribute_value(value, attribute_name, attribute_options, errors)
-      return errors unless value.blank? && attribute_options[:required] && !attribute_options[:default]
+    def validate_input_and_generate_runtime_context!
+      @input = self.class.input_context_class.new(@raw_input)
+      @input.validate!
+      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
 
-      errors[attribute_name] ||= []
-      errors[attribute_name] << :blank
-      errors
+    def with_notification(action)
+      ActiveSupport::Notifications.instrument("#{self.class.name}::#{action.to_s.classify}") do |payload|
+        yield payload if block_given?
+      end
     end
   end
 end

data/lib/active_interactor/context/attribute.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Context
+    class Attribute
+      NO_DEFAULT_VALUE = :__no_default_value__
+      attr_reader :description, :error_messages, :name
+
+      def initialize(owner, name, type, description = nil, **options)
+        @owner = owner
+        @name = name.to_sym
+        @type_expression = type
+        @description = description || options[:description]
+        @options = { required: false, default: NO_DEFAULT_VALUE }.merge(options)
+        @error_messages = []
+      end
+
+      def assign_value(value)
+        @user_provided_value = value
+      end
+
+      def default_value
+        return if @options[:default] == NO_DEFAULT_VALUE
+
+        @options[:default]
+      end
+
+      def required?
+        @options[:required]
+      end
+
+      def type
+        @type_expression
+      end
+
+      def validate!
+        return true unless required? && value.nil?
+
+        error_messages << :blank
+      end
+
+      def value
+        @user_provided_value || default_value
+      end
+    end
+  end
+end

data/lib/active_interactor/context/attribute_assignment.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Context
+    module AttributeAssignment
+      extend ActiveSupport::Concern
+
+      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, arguments.first)
+      end
+
+      def method_missing(method_id, *arguments)
+        return super unless respond_to_missing?(method_id)
+
+        method_name = method_id[/.*(?==\z)/m]
+        return assignment_method_missing(method_name, *arguments) if method_name
+
+        read_attribute_value(method_id)
+      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[/.*(?==\z)/m]&.to_sym)
+
+        super
+      end
+    end
+  end
+end

data/lib/active_interactor/context/attribute_registration.rb

@@ -0,0 +1,27 @@
+# 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/context/attribute_set.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Context
+    class AttributeSet
+      def initialize(owner, *attributes)
+        @owner = owner
+        @set = {}
+        attributes.each { |attribute| @set[attribute.name] = attribute }
+      end
+
+      def add(*attribute_args)
+        attribute_options = attribute_args.extract_options!
+        attribute = Attribute.new(@owner, *attribute_args, **attribute_options)
+        @set[attribute.name] = attribute
+      end
+
+      def attribute_names
+        @set.keys
+      end
+
+      def attributes
+        @set.values
+      end
+
+      def find(attribute_name)
+        @set[attribute_name.to_sym]
+      end
+
+      def merge(attributes)
+        attributes.each { |attribute| @set[attribute.name] = attribute }
+      end
+    end
+  end
+end

data/lib/active_interactor/context/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Context
+    class Base
+      include ActiveModel::Validations
+      include HasActiveModelErrors
+      include AttributeRegistration
+      include AttributeAssignment
+
+      attr_reader :errors
+
+      def initialize(attributes = {})
+        @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 validate!
+        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/input.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Context
+    class Input < Base
+      def self.argument(*attribute_args)
+        attribute_set.add(*attribute_args)
+      end
+
+      def self.argument_names
+        attribute_set.attribute_names
+      end
+
+      def self.arguments
+        attribute_set.attributes
+      end
+    end
+  end
+end

data/lib/active_interactor/context/output.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Context
+    class Output < Base
+      delegate :to_h, :to_hash, :to_json, to: :fields
+
+      def self.returns(*attribute_args)
+        attribute_set.add(*attribute_args)
+      end
+
+      def self.field_names
+        attribute_set.attribute_names
+      end
+
+      def self.fields
+        attribute_set.attributes
+      end
+
+      def fields
+        attribute_set.attributes.each_with_object({}) do |attribute, result|
+          result[attribute.name] = attribute.value
+        end
+      end
+    end
+  end
+end

data/lib/active_interactor/context/runtime.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Context
+    class Runtime < Base
+      def initialize(attributes = {})
+        super
+        @table = {}
+      end
+
+      def attributes
+        clean = attribute_set.attributes.each_with_object({}) do |attribute, result|
+          result[attribute.name] = attribute.value
+        end
+        @table.merge(clean)
+      end
+
+      private
+
+      def assign_attribute_value(attribute_name, value)
+        attribute = attribute_set.find(attribute_name)
+        return super if attribute
+
+        assign_dirty_attribute_value(attribute_name, value)
+      end
+
+      def assign_dirty_attribute_value(attribute_name, value)
+        @table[attribute_name.to_sym] = value
+      end
+
+      def method_missing(method_id, *arguments)
+        method_name = method_id[/.*(?==\z)/m]
+        return assignment_method_missing(method_name, *arguments) if method_name
+
+        read_attribute_value(method_id)
+      end
+
+      def read_attribute_value(attribute_name)
+        attribute = attribute_set.find(attribute_name)
+        return super if attribute
+
+        read_dirty_attribute_value(attribute_name)
+      end
+
+      def read_dirty_attribute_value(attribute_name)
+        @table[attribute_name.to_sym]
+      end
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        true
+      end
+    end
+  end
+end

data/lib/active_interactor/context.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Context
+    extend ActiveSupport::Autoload
+
+    autoload :Attribute
+    autoload :AttributeRegistration
+    autoload :AttributeSet
+    autoload :AttributeAssignment
+    autoload :Base
+    autoload :Input
+    autoload :Output
+    autoload :Runtime
+  end
+end

data/lib/active_interactor/has_active_model_errors.rb

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

data/lib/active_interactor/result.rb

@@ -2,7 +2,9 @@
 
 module ActiveInteractor
   class Result
-    extend ActiveModel::Naming
+    include HasActiveModelErrors
+
+    delegate :to_json, to: :to_hash
 
     STATUS = {
       success: 0,
@@ -26,14 +28,6 @@ module ActiveInteractor
         result
       end
 
-      def human_attribute_name(attribute, _options = {})
-        attribute.respond_to?(:to_s) ? attribute.to_s.humanize : attribute
-      end
-
-      def lookup_ancestors
-        [self]
-      end
-
       private
 
       def parse_errors(errors)
@@ -62,12 +56,21 @@ module ActiveInteractor
     alias failed? failure?
 
     def read_attribute_for_validation(attribute_name)
-      data[attribute_name]
+      data.send(attribute_name.to_sym)
     end
 
     def success?
       @status == STATUS[:success]
     end
     alias successful? success?
+
+    def to_hash
+      {
+        success: success?,
+        errors: errors.to_hash,
+        data: data.to_hash
+      }
+    end
+    alias to_h to_hash
   end
 end

data/lib/active_interactor.rb

@@ -2,6 +2,7 @@
 
 require 'active_model'
 require 'active_support'
+require 'active_support/core_ext'
 
 require_relative 'active_interactor/errors'
 
@@ -9,5 +10,7 @@ module ActiveInteractor
   extend ActiveSupport::Autoload
 
   autoload :Base
+  autoload :Context
+  autoload :HasActiveModelErrors
   autoload :Result
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activeinteractor
 version: !ruby/object:Gem::Version
-  version: 2.0.0.alpha.2.0.0
+  version: 2.0.0.alpha.2.2.0
 platform: ruby
 authors:
 - Aaron Allen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-10 00:00:00.000000000 Z
+date: 2023-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -64,7 +64,17 @@ files:
 - README.md
 - lib/active_interactor.rb
 - lib/active_interactor/base.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/base.rb
+- lib/active_interactor/context/input.rb
+- lib/active_interactor/context/output.rb
+- lib/active_interactor/context/runtime.rb
 - lib/active_interactor/errors.rb
+- lib/active_interactor/has_active_model_errors.rb
 - lib/active_interactor/result.rb
 - sig/active_interactor.rbs
 homepage: https://github.com/activeinteractor/activeinteractor
@@ -72,9 +82,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/activeinteractor/activeinteractor/issues
-  changelog_uri: https://github.com/activeinteractor/activeinteractor/blob/v2.0.0-alpha.2.0.0/CHANGELOG.md
+  changelog_uri: https://github.com/activeinteractor/activeinteractor/blob/v2.0.0-alpha.2.2.0/CHANGELOG.md
   homepage_uri: https://github.com/activeinteractor/activeinteractor
-  source_code_uri: https://github.com/activeinteractor/activeinteractor/tree/v2.0.0-alpha.2.0.0
+  source_code_uri: https://github.com/activeinteractor/activeinteractor/tree/v2.0.0-alpha.2.2.0
   wiki_uri: https://github.com/activeinteractor/activeinteractor/wiki
   rubygems_mfa_required: 'true'
 post_install_message: