axn 0.1.0.pre.alpha.2.5.3.1 → 0.1.0.pre.alpha.2.6

data/lib/action/core/contract.rb

@@ -7,264 +7,203 @@ require "action/core/validation/fields"
 require "action/core/context_facade"
 
 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
 
-        _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?
+      FieldConfig = Data.define(:field, :validations, :default, :preprocess, :sensitive)
 
-          # NOTE: avoid <<, which would update value for parents and children
-          self.internal_field_configs += configs
-        end
-      end
+      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?
 
-      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! success? ok?
+          inspect default_error
+          each_pair
+        ].freeze
+
+        RESERVED_FIELD_NAMES_FOR_EXPOSURES = %w[
+          fail! 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
-      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
-
-    module InstanceMethods
-      def internal_context = @internal_context ||= _build_context_facade(:inbound)
-      def external_context = @external_context ||= _build_context_facade(:outbound)
+        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
 
-      # 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
+        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)
 
-      # 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: public_send(field))
           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.public_send("#{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.to_h.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
+        private
 
-      def _apply_defaults!(direction)
-        raise ArgumentError, "Invalid direction: #{direction}" unless %i[inbound outbound].include?(direction)
+        def _build_context_facade(direction)
+          raise ArgumentError, "Invalid direction: #{direction}" unless %i[inbound outbound].include?(direction)
 
-        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
+          klass = direction == :inbound ? Action::InternalContext : Action::Result
+          implicitly_allowed_fields = direction == :inbound ? _declared_fields(:outbound) : []
 
-        defaults_mapping.each do |field, default_value_getter|
-          next if @context.public_send(field).present?
-
-          default_value = default_value_getter.respond_to?(:call) ? instance_exec(&default_value_getter) : default_value_getter
-
-          @context.public_send("#{field}=", default_value)
+          klass.new(action: self, context: @context, declared_fields: _declared_fields(direction), implicitly_allowed_fields:)
         end
-      end
-
-      def context_for_logging(direction = nil)
-        inspection_filter.filter(@context.to_h.slice(*_declared_fields(direction)))
-      end
-
-      protected
 
-      def inspection_filter
-        @inspection_filter ||= ActiveSupport::ParameterFilter.new(sensitive_fields)
-      end
+        def inspection_filter
+          @inspection_filter ||= ActiveSupport::ParameterFilter.new(sensitive_fields)
+        end
 
-      def sensitive_fields
-        (internal_field_configs + external_field_configs).select(&:sensitive).map(&:field)
-      end
+        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)
+        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]) 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

data/lib/action/core/contract_validation.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Action
+  module Core
+    module ContractValidation
+      private
+
+      def _apply_inbound_preprocessing!
+        internal_field_configs.each do |config|
+          next unless config.preprocess
+
+          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}"
+        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
+        end
+        context = direction == :inbound ? internal_context : result
+        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)
+
+        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
+
+        defaults_mapping.each do |field, default_value_getter|
+          next if @context.public_send(field).present?
+
+          default_value = default_value_getter.respond_to?(:call) ? instance_exec(&default_value_getter) : default_value_getter
+
+          @context.public_send("#{field}=", default_value)
+        end
+      end
+    end
+  end
+end