axn 0.1.0.pre.alpha.2.5.3.1 → 0.1.0.pre.alpha.2.6.1

data/lib/action/core/context/internal.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "action/core/context/facade"
+
+module Action
+  # Inbound / Internal ContextFacade
+  class InternalContext < ContextFacade
+    # So can be referenced from within e.g. rescues callables
+    def default_error
+      [@context.error_prefix, determine_error_message(only_default: true)].compact.join(" ").squeeze(" ")
+    end
+
+    private
+
+    def context_data_source = @context.provided_data
+
+    def method_missing(method_name, ...) # rubocop:disable Style/MissingRespondToMissing (because we're not actually responding to anything additional)
+      if @context.__combined_data.key?(method_name.to_sym)
+        msg = <<~MSG
+          Method ##{method_name} is not available on Action::InternalContext!
+
+          #{action_name} may be missing a line like:
+            expects :#{method_name}
+        MSG
+
+        raise Action::ContractViolation::MethodNotAllowed, msg
+      end
+
+      super
+    end
+  end
+end

data/lib/action/core/contract.rb

@@ -4,267 +4,223 @@ require "active_support/core_ext/enumerable"
 require "active_support/core_ext/module/delegation"
 
 require "action/core/validation/fields"
-require "action/core/context_facade"
+require "action/result"
+require "action/core/context/internal"
 
 module Action
-  module Contract
-    def self.included(base)
-      base.class_eval do
-        class_attribute :internal_field_configs, :external_field_configs, default: []
-
-        extend ClassMethods
-        include InstanceMethods
-        include ValidationInstanceMethods
-
-        # Remove public context accessor
-        remove_method :context
-
-        around do |hooked|
-          _apply_inbound_preprocessing!
-          _apply_defaults!(:inbound)
-          _validate_contract!(:inbound)
-          hooked.call
-          _apply_defaults!(:outbound)
-          _validate_contract!(:outbound)
+  module Core
+    module Contract
+      def self.included(base)
+        base.class_eval do
+          class_attribute :internal_field_configs, :external_field_configs, default: []
+
+          extend ClassMethods
+          include InstanceMethods
         end
       end
-    end
 
-    FieldConfig = Data.define(:field, :validations, :default, :preprocess, :sensitive)
-
-    module ClassMethods
-      def expects(
-        *fields,
-        on: nil,
-        allow_blank: false,
-        allow_nil: false,
-        default: nil,
-        preprocess: nil,
-        sensitive: false,
-        **validations
-      )
-        return _expects_subfields(*fields, on:, allow_blank:, allow_nil:, default:, preprocess:, sensitive:, **validations) if on.present?
-
-        fields.each do |field|
-          raise ContractViolation::ReservedAttributeError, field if RESERVED_FIELD_NAMES_FOR_EXPECTATIONS.include?(field.to_s)
-        end
+      FieldConfig = Data.define(:field, :validations, :default, :preprocess, :sensitive)
 
-        _parse_field_configs(*fields, allow_blank:, allow_nil:, default:, preprocess:, sensitive:, **validations).tap do |configs|
-          duplicated = internal_field_configs.map(&:field) & configs.map(&:field)
-          raise Action::DuplicateFieldError, "Duplicate field(s) declared: #{duplicated.join(", ")}" if duplicated.any?
+      module ClassMethods
+        def expects(
+          *fields,
+          on: nil,
+          allow_blank: false,
+          allow_nil: false,
+          default: nil,
+          preprocess: nil,
+          sensitive: false,
+          **validations
+        )
+          return _expects_subfields(*fields, on:, allow_blank:, allow_nil:, default:, preprocess:, sensitive:, **validations) if on.present?
 
-          # NOTE: avoid <<, which would update value for parents and children
-          self.internal_field_configs += configs
-        end
-      end
-
-      def exposes(
-        *fields,
-        allow_blank: false,
-        allow_nil: false,
-        default: nil,
-        sensitive: false,
-        **validations
-      )
-        fields.each do |field|
-          raise ContractViolation::ReservedAttributeError, field if RESERVED_FIELD_NAMES_FOR_EXPOSURES.include?(field.to_s)
-        end
+          fields.each do |field|
+            raise ContractViolation::ReservedAttributeError, field if RESERVED_FIELD_NAMES_FOR_EXPECTATIONS.include?(field.to_s)
+          end
 
-        _parse_field_configs(*fields, allow_blank:, allow_nil:, default:, preprocess: nil, sensitive:, **validations).tap do |configs|
-          duplicated = external_field_configs.map(&:field) & configs.map(&:field)
-          raise Action::DuplicateFieldError, "Duplicate field(s) declared: #{duplicated.join(", ")}" if duplicated.any?
+          _parse_field_configs(*fields, allow_blank:, allow_nil:, default:, preprocess:, sensitive:, **validations).tap do |configs|
+            duplicated = internal_field_configs.map(&:field) & configs.map(&:field)
+            raise Action::DuplicateFieldError, "Duplicate field(s) declared: #{duplicated.join(", ")}" if duplicated.any?
 
-          # NOTE: avoid <<, which would update value for parents and children
-          self.external_field_configs += configs
+            # NOTE: avoid <<, which would update value for parents and children
+            self.internal_field_configs += configs
+          end
         end
-      end
 
-      private
-
-      RESERVED_FIELD_NAMES_FOR_EXPECTATIONS = %w[
-        called! fail! rollback! success? ok?
-        inspect default_error
-        each_pair
-      ].freeze
-
-      RESERVED_FIELD_NAMES_FOR_EXPOSURES = %w[
-        called! fail! rollback! success? ok?
-        inspect each_pair default_error
-        ok error success message
-      ].freeze
-
-      def _parse_field_configs(
-        *fields,
-        allow_blank: false,
-        allow_nil: false,
-        default: nil,
-        preprocess: nil,
-        sensitive: false,
-        **validations
-      )
-        _parse_field_validations(*fields, allow_nil:, allow_blank:, **validations).map do |field, parsed_validations|
-          _define_field_reader(field)
-          _define_model_reader(field, parsed_validations[:model]) if parsed_validations.key?(:model)
-          FieldConfig.new(field:, validations: parsed_validations, default:, preprocess:, sensitive:)
-        end
-      end
+        def exposes(
+          *fields,
+          allow_blank: false,
+          allow_nil: false,
+          default: nil,
+          sensitive: false,
+          **validations
+        )
+          fields.each do |field|
+            raise ContractViolation::ReservedAttributeError, field if RESERVED_FIELD_NAMES_FOR_EXPOSURES.include?(field.to_s)
+          end
 
-      def define_memoized_reader_method(field, &block)
-        define_method(field) do
-          ivar = :"@_memoized_reader_#{field}"
-          cached_val = instance_variable_get(ivar)
-          return cached_val if cached_val.present?
+          _parse_field_configs(*fields, allow_blank:, allow_nil:, default:, preprocess: nil, sensitive:, **validations).tap do |configs|
+            duplicated = external_field_configs.map(&:field) & configs.map(&:field)
+            raise Action::DuplicateFieldError, "Duplicate field(s) declared: #{duplicated.join(", ")}" if duplicated.any?
 
-          value = instance_exec(&block)
-          instance_variable_set(ivar, value)
+            # NOTE: avoid <<, which would update value for parents and children
+            self.external_field_configs += configs
+          end
         end
-      end
 
-      def _define_field_reader(field)
-        # Allow local access to explicitly-expected fields -- even externally-expected needs to be available locally
-        # (e.g. to allow success message callable to reference exposed fields)
-        define_method(field) { internal_context.public_send(field) }
-      end
-
-      def _define_model_reader(field, klass)
-        name = field.to_s.delete_suffix("_id")
-        raise ArgumentError, "Model validation expects to be given a field ending in _id (given: #{field})" unless field.to_s.end_with?("_id")
-        raise ArgumentError, "Failed to define model reader - #{name} is already defined" if method_defined?(name)
-
-        define_memoized_reader_method(name) do
-          Validators::ModelValidator.instance_for(field:, klass:, id: public_send(field))
+        private
+
+        RESERVED_FIELD_NAMES_FOR_EXPECTATIONS = %w[
+          fail! ok?
+          inspect default_error
+          each_pair
+        ].freeze
+
+        RESERVED_FIELD_NAMES_FOR_EXPOSURES = %w[
+          fail! ok?
+          inspect each_pair default_error
+          ok error success message
+        ].freeze
+
+        def _parse_field_configs(
+          *fields,
+          allow_blank: false,
+          allow_nil: false,
+          default: nil,
+          preprocess: nil,
+          sensitive: false,
+          **validations
+        )
+          _parse_field_validations(*fields, allow_nil:, allow_blank:, **validations).map do |field, parsed_validations|
+            _define_field_reader(field)
+            _define_model_reader(field, parsed_validations[:model]) if parsed_validations.key?(:model)
+            FieldConfig.new(field:, validations: parsed_validations, default:, preprocess:, sensitive:)
+          end
         end
-      end
 
-      def _parse_field_validations(
-        *fields,
-        allow_nil: false,
-        allow_blank: false,
-        **validations
-      )
-        if allow_blank
-          validations.transform_values! do |v|
-            v = { value: v } unless v.is_a?(Hash)
-            { allow_blank: true }.merge(v)
-          end
-        elsif allow_nil
-          validations.transform_values! do |v|
-            v = { value: v } unless v.is_a?(Hash)
-            { allow_nil: true }.merge(v)
+        def define_memoized_reader_method(field, &block)
+          define_method(field) do
+            ivar = :"@_memoized_reader_#{field}"
+            cached_val = instance_variable_get(ivar)
+            return cached_val if cached_val.present?
+
+            value = instance_exec(&block)
+            instance_variable_set(ivar, value)
           end
-        else
-          validations[:presence] = true unless validations.key?(:presence) || Array(validations[:type]).include?(:boolean)
         end
 
-        fields.map { |field| [field, validations] }
-      end
-    end
+        def _define_field_reader(field)
+          # Allow local access to explicitly-expected fields -- even externally-expected needs to be available locally
+          # (e.g. to allow success message callable to reference exposed fields)
+          define_method(field) { internal_context.public_send(field) }
+        end
 
-    module InstanceMethods
-      def internal_context = @internal_context ||= _build_context_facade(:inbound)
-      def external_context = @external_context ||= _build_context_facade(:outbound)
+        def _define_model_reader(field, klass, &id_extractor)
+          name = field.to_s.delete_suffix("_id")
+          raise ArgumentError, "Model validation expects to be given a field ending in _id (given: #{field})" unless field.to_s.end_with?("_id")
+          raise ArgumentError, "Failed to define model reader - #{name} is already defined" if method_defined?(name)
 
-      # NOTE: ideally no direct access from client code, but we need to expose this for internal Interactor methods
-      # (and passing through control methods to underlying context) in order to avoid rewriting internal methods.
-      def context = external_context
+          id_extractor ||= -> { public_send(field) }
 
-      # Accepts either two positional arguments (key, value) or a hash of key/value pairs
-      def expose(*args, **kwargs)
-        if args.any?
-          if args.size != 2
-            raise ArgumentError,
-                  "expose must be called with exactly two positional arguments (or a hash of key/value pairs)"
+          define_memoized_reader_method(name) do
+            Validators::ModelValidator.instance_for(field:, klass:, id: instance_exec(&id_extractor))
           end
-
-          kwargs.merge!(args.first => args.last)
         end
 
-        kwargs.each do |key, value|
-          raise Action::ContractViolation::UnknownExposure, key unless external_context.respond_to?(key)
+        def _parse_field_validations(
+          *fields,
+          allow_nil: false,
+          allow_blank: false,
+          **validations
+        )
+          if allow_blank
+            validations.transform_values! do |v|
+              v = { value: v } unless v.is_a?(Hash)
+              { allow_blank: true }.merge(v)
+            end
+          elsif allow_nil
+            validations.transform_values! do |v|
+              v = { value: v } unless v.is_a?(Hash)
+              { allow_nil: true }.merge(v)
+            end
+          else
+            validations[:presence] = true unless validations.key?(:presence) || Array(validations[:type]).include?(:boolean)
+          end
 
-          @context.public_send("#{key}=", value)
+          fields.map { |field| [field, validations] }
         end
       end
 
-      private
-
-      def _build_context_facade(direction)
-        raise ArgumentError, "Invalid direction: #{direction}" unless %i[inbound outbound].include?(direction)
+      module InstanceMethods
+        def internal_context = @internal_context ||= _build_context_facade(:inbound)
+        def result = @result ||= _build_context_facade(:outbound)
 
-        klass = direction == :inbound ? Action::InternalContext : Action::Result
-        implicitly_allowed_fields = direction == :inbound ? _declared_fields(:outbound) : []
+        # Accepts either two positional arguments (key, value) or a hash of key/value pairs
+        def expose(*args, **kwargs)
+          if args.any?
+            if args.size != 2
+              raise ArgumentError,
+                    "expose must be called with exactly two positional arguments (or a hash of key/value pairs)"
+            end
 
-        klass.new(action: self, context: @context, declared_fields: _declared_fields(direction), implicitly_allowed_fields:)
-      end
-    end
+            kwargs.merge!(args.first => args.last)
+          end
 
-    module ValidationInstanceMethods
-      def _apply_inbound_preprocessing!
-        internal_field_configs.each do |config|
-          next unless config.preprocess
+          kwargs.each do |key, value|
+            raise Action::ContractViolation::UnknownExposure, key unless result.respond_to?(key)
 
-          initial_value = @context.public_send(config.field)
-          new_value = config.preprocess.call(initial_value)
-          @context.public_send("#{config.field}=", new_value)
-        rescue StandardError => e
-          raise Action::ContractViolation::PreprocessingError, "Error preprocessing field '#{config.field}': #{e.message}"
+            @__context.exposed_data[key] = value
+          end
         end
-      end
 
-      def _validate_contract!(direction)
-        raise ArgumentError, "Invalid direction: #{direction}" unless %i[inbound outbound].include?(direction)
-
-        configs = direction == :inbound ? internal_field_configs : external_field_configs
-        validations = configs.each_with_object({}) do |config, hash|
-          hash[config.field] = config.validations
+        def context_for_logging(direction = nil)
+          inspection_filter.filter(@__context.__combined_data.slice(*_declared_fields(direction)))
         end
-        context = direction == :inbound ? internal_context : external_context
-        exception_klass = direction == :inbound ? Action::InboundValidationError : Action::OutboundValidationError
-
-        Validation::Fields.validate!(validations:, context:, exception_klass:)
-      end
 
-      def _apply_defaults!(direction)
-        raise ArgumentError, "Invalid direction: #{direction}" unless %i[inbound outbound].include?(direction)
+        private
 
-        configs = direction == :inbound ? internal_field_configs : external_field_configs
-        defaults_mapping = configs.each_with_object({}) do |config, hash|
-          hash[config.field] = config.default
-        end.compact
+        def _with_contract
+          _apply_inbound_preprocessing!
+          _apply_defaults!(:inbound)
+          _validate_contract!(:inbound)
 
-        defaults_mapping.each do |field, default_value_getter|
-          next if @context.public_send(field).present?
+          yield
 
-          default_value = default_value_getter.respond_to?(:call) ? instance_exec(&default_value_getter) : default_value_getter
+          _apply_defaults!(:outbound)
+          _validate_contract!(:outbound)
 
-          @context.public_send("#{field}=", default_value)
+          # TODO: improve location of this triggering
+          _trigger_on_success if respond_to?(:_trigger_on_success)
         end
-      end
 
-      def context_for_logging(direction = nil)
-        inspection_filter.filter(@context.to_h.slice(*_declared_fields(direction)))
-      end
+        def _build_context_facade(direction)
+          raise ArgumentError, "Invalid direction: #{direction}" unless %i[inbound outbound].include?(direction)
 
-      protected
+          klass = direction == :inbound ? Action::InternalContext : Action::Result
+          implicitly_allowed_fields = direction == :inbound ? _declared_fields(:outbound) : []
 
-      def inspection_filter
-        @inspection_filter ||= ActiveSupport::ParameterFilter.new(sensitive_fields)
-      end
+          klass.new(action: self, context: @__context, declared_fields: _declared_fields(direction), implicitly_allowed_fields:)
+        end
 
-      def sensitive_fields
-        (internal_field_configs + external_field_configs).select(&:sensitive).map(&:field)
-      end
+        def inspection_filter
+          @inspection_filter ||= ActiveSupport::ParameterFilter.new(sensitive_fields)
+        end
 
-      def _declared_fields(direction)
-        raise ArgumentError, "Invalid direction: #{direction}" unless direction.nil? || %i[inbound outbound].include?(direction)
+        def sensitive_fields
+          (internal_field_configs + external_field_configs).select(&:sensitive).map(&:field)
+        end
+
+        def _declared_fields(direction)
+          raise ArgumentError, "Invalid direction: #{direction}" unless direction.nil? || %i[inbound outbound].include?(direction)
 
-        configs = case direction
-                  when :inbound then internal_field_configs
-                  when :outbound then external_field_configs
-                  else (internal_field_configs + external_field_configs)
-                  end
+          configs = case direction
+                    when :inbound then internal_field_configs
+                    when :outbound then external_field_configs
+                    else (internal_field_configs + external_field_configs)
+                    end
 
-        configs.map(&:field)
+          configs.map(&:field)
+        end
       end
     end
   end

data/lib/action/core/contract_for_subfields.rb

@@ -3,103 +3,105 @@
 require "action/core/validation/subfields"
 
 module Action
-  module ContractForSubfields
-    # TODO: add default, preprocess, sensitive options for subfields?
-    # SubfieldConfig = Data.define(:field, :validations, :default, :preprocess, :sensitive)
-    SubfieldConfig = Data.define(:field, :validations, :on)
+  module Core
+    module ContractForSubfields
+      # TODO: add default, preprocess, sensitive options for subfields?
+      # SubfieldConfig = Data.define(:field, :validations, :default, :preprocess, :sensitive)
+      SubfieldConfig = Data.define(:field, :validations, :on)
 
-    def self.included(base)
-      base.class_eval do
-        class_attribute :subfield_configs, default: []
+      def self.included(base)
+        base.class_eval do
+          class_attribute :subfield_configs, default: []
 
-        extend ClassMethods
-        include InstanceMethods
+          extend ClassMethods
+          include InstanceMethods
 
-        before { _validate_subfields_contract! }
+          before { _validate_subfields_contract! }
+        end
       end
-    end
 
-    module ClassMethods
-      def _expects_subfields(
-        *fields,
-        on:,
-        readers: true,
-        allow_blank: false,
-        allow_nil: false,
-
-        # TODO: add support for these three options for subfields
-        default: nil,
-        preprocess: nil,
-        sensitive: false,
-
-        **validations
-      )
-        # TODO: add support for these three options for subfields
-        raise ArgumentError, "expects does not support :default key when also given :on" if default.present?
-        raise ArgumentError, "expects does not support :preprocess key when also given :on" if preprocess.present?
-        raise ArgumentError, "expects does not support :sensitive key when also given :on" if sensitive.present?
-
-        unless internal_field_configs.map(&:field).include?(on) || subfield_configs.map(&:field).include?(on)
-          raise ArgumentError,
-                "expects called with `on: #{on}`, but no such method exists (are you sure you've declared `expects :#{on}`?)"
+      module ClassMethods
+        def _expects_subfields(
+          *fields,
+          on:,
+          readers: true,
+          allow_blank: false,
+          allow_nil: false,
+
+          # TODO: add support for these three options for subfields
+          default: nil,
+          preprocess: nil,
+          sensitive: false,
+
+          **validations
+        )
+          # TODO: add support for these three options for subfields
+          raise ArgumentError, "expects does not support :default key when also given :on" if default.present?
+          raise ArgumentError, "expects does not support :preprocess key when also given :on" if preprocess.present?
+          raise ArgumentError, "expects does not support :sensitive key when also given :on" if sensitive.present?
+
+          unless internal_field_configs.map(&:field).include?(on) || subfield_configs.map(&:field).include?(on)
+            raise ArgumentError,
+                  "expects called with `on: #{on}`, but no such method exists (are you sure you've declared `expects :#{on}`?)"
+          end
+
+          raise ArgumentError, "expects does not support expecting fields on nested attributes (i.e. `on` cannot contain periods)" if on.to_s.include?(".")
+
+          # TODO: consider adding support for default, preprocess, sensitive options for subfields?
+          _parse_subfield_configs(*fields, on:, readers:, allow_blank:, allow_nil:, **validations).tap do |configs|
+            duplicated = subfield_configs.map(&:field) & configs.map(&:field)
+            raise Action::DuplicateFieldError, "Duplicate field(s) declared: #{duplicated.join(", ")}" if duplicated.any?
+
+            # NOTE: avoid <<, which would update value for parents and children
+            self.subfield_configs += configs
+          end
         end
 
-        raise ArgumentError, "expects does not support expecting fields on nested attributes (i.e. `on` cannot contain periods)" if on.to_s.include?(".")
-
-        # TODO: consider adding support for default, preprocess, sensitive options for subfields?
-        _parse_subfield_configs(*fields, on:, readers:, allow_blank:, allow_nil:, **validations).tap do |configs|
-          duplicated = subfield_configs.map(&:field) & configs.map(&:field)
-          raise Action::DuplicateFieldError, "Duplicate field(s) declared: #{duplicated.join(", ")}" if duplicated.any?
-
-          # NOTE: avoid <<, which would update value for parents and children
-          self.subfield_configs += configs
+        private
+
+        def _parse_subfield_configs(
+          *fields,
+          on:,
+          readers:,
+          allow_blank: false,
+          allow_nil: false,
+          # default: nil,
+          # preprocess: nil,
+          # sensitive: false,
+          **validations
+        )
+          _parse_field_validations(*fields, allow_nil:, allow_blank:, **validations).map do |field, parsed_validations|
+            _define_subfield_reader(field, on:, validations: parsed_validations) if readers
+            SubfieldConfig.new(field:, validations: parsed_validations, on:)
+          end
         end
-      end
 
-      private
-
-      def _parse_subfield_configs(
-        *fields,
-        on:,
-        readers:,
-        allow_blank: false,
-        allow_nil: false,
-        # default: nil,
-        # preprocess: nil,
-        # sensitive: false,
-        **validations
-      )
-        _parse_field_validations(*fields, allow_nil:, allow_blank:, **validations).map do |field, parsed_validations|
-          _define_subfield_reader(field, on:, validations: parsed_validations) if readers
-          SubfieldConfig.new(field:, validations: parsed_validations, on:)
-        end
-      end
+        def _define_subfield_reader(field, on:, validations:)
+          # Don't create top-level readers for nested fields
+          return if field.to_s.include?(".")
 
-      def _define_subfield_reader(field, on:, validations:)
-        # Don't create top-level readers for nested fields
-        return if field.to_s.include?(".")
+          raise ArgumentError, "expects does not support duplicate sub-keys (i.e. `#{field}` is already defined)" if method_defined?(field)
 
-        raise ArgumentError, "expects does not support duplicate sub-keys (i.e. `#{field}` is already defined)" if method_defined?(field)
+          define_memoized_reader_method(field) do
+            Action::Validation::Subfields.extract(field, public_send(on))
+          end
 
-        define_memoized_reader_method(field) do
-          Action::Validation::Subfields.extract(field, public_send(on))
+          _define_model_reader(field, validations[:model]) { Action::Validation::Subfields.extract(field, public_send(on)) } if validations.key?(:model)
         end
-
-        _define_model_reader(field, validations[:model]) if validations.key?(:model)
       end
-    end
 
-    module InstanceMethods
-      def _validate_subfields_contract!
-        return if subfield_configs.blank?
-
-        subfield_configs.each do |config|
-          Validation::Subfields.validate!(
-            field: config.field,
-            validations: config.validations,
-            source: public_send(config.on),
-            exception_klass: Action::InboundValidationError,
-          )
+      module InstanceMethods
+        def _validate_subfields_contract!
+          return if subfield_configs.blank?
+
+          subfield_configs.each do |config|
+            Validation::Subfields.validate!(
+              field: config.field,
+              validations: config.validations,
+              source: public_send(config.on),
+              exception_klass: Action::InboundValidationError,
+            )
+          end
         end
       end
     end