activeinteractor 2.0.0.alpha.2.1.0 → 2.0.0.alpha.2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8353806528fdb9ad9625f469d16d400929d9ef3cae024490c85982354f4d9bad
-  data.tar.gz: af9cfad32cffe177d1b30fa7fb482f3305a6757152090d82482aef39f448a628
+  metadata.gz: c201330d4b6c13c9b409888776d669e0b1ea73fcae310f4869de55fc0bbcc500
+  data.tar.gz: 62be913b6bee629928ba114f82a7c2a526610cab1d9978459fc8e9f4f70869b3
 SHA512:
-  metadata.gz: 45a07cd05ee5ad9e27fb23f2ebe1a99c5bc01cdeeda5987e35a501b22230ecb56ea49ccc36c233348a838a6c25cd2fa8b6945326bef13839d1f4541a0d3ac043
-  data.tar.gz: c11cbf40fa73910ce12a43a60db15f13983ec6174006627eae29eecd068002be2fcbd50b7062d4cd0d955736594a246611f66c570db59b152e889053c9b5128d
+  metadata.gz: ef8f56b5ca0f79d60b9f45b3c8a1e9e394b15c15c89c98e7f747eaecf6621671020b624a0d5ba141d7948468eb83938ecd8bf62849038ad39e2f974a03bfce11
+  data.tar.gz: ed637132df8ef4ae80843e042d780b0423480e74f5d4cd9d12128118c10e3197467cb2e31f49d2d6a62cbadfd9c83ef4abad0beb123959ddb908d2f5f39fadc2

data/lib/active_interactor/base.rb

@@ -2,9 +2,23 @@
 
 module ActiveInteractor
   class Base
+    include Type::HasTypes
+
     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,26 +33,31 @@ 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!
       with_notification(:perform) do |payload|
         interact
-        payload[:result] = Result.success(data: parse_output!)
+        generate_and_validate_output_context!
+        payload[:result] = Result.success(data: @output)
       end
     end
 
@@ -68,36 +87,20 @@ module ActiveInteractor
       raise Error, result
     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]
-      end
-
-      raise Error, Result.failure(errors: errors, status: Result::STATUS[:failed_on_input]) unless errors.empty?
-
-      context
-    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?
 
-      errors[attribute_name] ||= []
-      errors[attribute_name] << :blank
-      errors
+      raise Error, Result.failure(errors: @input.errors, status: Result::STATUS[:failed_at_input])
     end
 
     def with_notification(action)

data/lib/active_interactor/context/attribute.rb

@@ -0,0 +1,72 @@
+# 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!
+        validate_presence! && validate_type!
+      end
+
+      def value
+        @user_provided_value || default_value
+      end
+
+      private
+
+      def type_is_a_active_interactor_type?
+        type.is_a?(ActiveInteractor::Type::Base) || type.superclass == ActiveInteractor::Type::Base
+      end
+
+      def validate_presence!
+        return true unless required? && value.nil?
+
+        error_messages << :blank
+      end
+
+      def validate_type!
+        return true if value.nil?
+        return true if %i[any untyped].include?(type)
+
+        if type_is_a_active_interactor_type?
+          return true if type.valid?(value)
+
+          error_messages << :invalid
+        elsif value.is_a?(type)
+          return true
+        end
+
+        error_messages << :invalid
+      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,31 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Context
+    class Base
+      include ActiveModel::Validations
+      include HasActiveModelErrors
+      include AttributeRegistration
+      include AttributeAssignment
+      include Type::HasTypes
+
+      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/type/base.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Type
+    class Base
+      def self.valid?(value); end
+    end
+  end
+end

data/lib/active_interactor/type/boolean.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Type
+    class Boolean < Base
+      TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE', 'on', 'ON', 'yes', 'YES'].freeze
+      FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF', 'no', 'NO'].freeze
+
+      def self.valid?(value)
+        (TRUE_VALUES + FALSE_VALUES).include?(value)
+      end
+    end
+  end
+end

data/lib/active_interactor/type/has_types.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Type
+    module HasTypes
+      extend ActiveSupport::Concern
+
+      Boolean = ActiveInteractor::Type::Boolean
+
+      module ClassMethods
+        def any
+          :any
+        end
+
+        def list(type)
+          List.new(type)
+        end
+        alias array list
+
+        def union(*types)
+          Union.new(*types)
+        end
+
+        def untyped
+          :untyped
+        end
+      end
+
+      included do
+        extend ClassMethods
+      end
+    end
+  end
+end

data/lib/active_interactor/type/list.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Type
+    class List < Base
+      def initialize(type) # rubocop:disable Lint/MissingSuper
+        @type = type
+      end
+
+      def valid?(value)
+        return false unless value.is_a?(Array)
+
+        value.all? do |element|
+          element.nil? || element.is_a?(@type) || (@type.is_a?(ActiveInteractor::Type::Base) && @type.valid?(element))
+        end
+      end
+
+      private
+
+      def value_is_a_valid_active_interactor_type?(_type, value)
+        unless @type.is_a?(ActiveInteractor::Type::Base) || @type.superclass == ActiveInteractor::Type::Base
+          return false
+        end
+
+        @type.valid?(value)
+      end
+    end
+  end
+end

data/lib/active_interactor/type/union.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Type
+    class Union < Base
+      def initialize(*types) # rubocop:disable Lint/MissingSuper
+        @valid_types = types
+      end
+
+      def valid?(value)
+        return true if value.nil?
+
+        @valid_types.any? do |type|
+          value_is_a_valid_active_interactor_type?(type, value) || value.is_a?(type)
+        end
+      end
+
+      private
+
+      def value_is_a_valid_active_interactor_type?(type, value)
+        return false unless type.is_a?(ActiveInteractor::Type::Base) || type.superclass == ActiveInteractor::Type::Base
+
+        type.valid?(value)
+      end
+    end
+  end
+end

data/lib/active_interactor/type.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveInteractor
+  module Type
+    extend ActiveSupport::Autoload
+
+    autoload :Base
+    autoload :Boolean
+    autoload :HasTypes
+    autoload :List
+    autoload :Union
+  end
+end

data/lib/active_interactor.rb

@@ -10,5 +10,8 @@ module ActiveInteractor
   extend ActiveSupport::Autoload
 
   autoload :Base
+  autoload :Context
+  autoload :HasActiveModelErrors
   autoload :Result
+  autoload :Type
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activeinteractor
 version: !ruby/object:Gem::Version
-  version: 2.0.0.alpha.2.1.0
+  version: 2.0.0.alpha.2.3.0
 platform: ruby
 authors:
 - Aaron Allen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-11 00:00:00.000000000 Z
+date: 2023-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -64,17 +64,33 @@ 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
+- lib/active_interactor/type.rb
+- lib/active_interactor/type/base.rb
+- lib/active_interactor/type/boolean.rb
+- lib/active_interactor/type/has_types.rb
+- lib/active_interactor/type/list.rb
+- lib/active_interactor/type/union.rb
 - sig/active_interactor.rbs
 homepage: https://github.com/activeinteractor/activeinteractor
 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.1.0/CHANGELOG.md
+  changelog_uri: https://github.com/activeinteractor/activeinteractor/blob/v2.0.0-alpha.2.3.0/CHANGELOG.md
   homepage_uri: https://github.com/activeinteractor/activeinteractor
-  source_code_uri: https://github.com/activeinteractor/activeinteractor/tree/v2.0.0-alpha.2.1.0
+  source_code_uri: https://github.com/activeinteractor/activeinteractor/tree/v2.0.0-alpha.2.3.0
   wiki_uri: https://github.com/activeinteractor/activeinteractor/wiki
   rubygems_mfa_required: 'true'
 post_install_message: