dry-schema 1.3.4 → 1.5.0

data/lib/dry/schema/predicate_registry.rb

@@ -1,35 +1,14 @@
 # frozen_string_literal: true
 
-require 'dry/logic/predicates'
+require "dry/logic/predicates"
+require "dry/types/predicate_registry"
 
 module Dry
   module Schema
     # A registry with predicate objects from `Dry::Logic::Predicates`
     #
     # @api private
-    class PredicateRegistry
-      # @api private
-      attr_reader :predicates
-
-      # @api private
-      attr_reader :has_predicate
-
-      # @api private
-      def initialize(predicates = Dry::Logic::Predicates)
-        @predicates = predicates
-        @has_predicate = ::Kernel.instance_method(:respond_to?).bind(@predicates)
-      end
-
-      # @api private
-      def [](name)
-        predicates[name]
-      end
-
-      # @api private
-      def key?(name)
-        has_predicate.(name)
-      end
-
+    class PredicateRegistry < Dry::Types::PredicateRegistry
       # @api private
       def arg_list(name, *values)
         predicate = self[name]

data/lib/dry/schema/primitive_inferrer.rb

@@ -1,99 +1,16 @@
 # frozen_string_literal: true
 
-require 'dry/core/cache'
+require "dry/types/primitive_inferrer"
 
 module Dry
   module Schema
-    # PrimitiveInferrer is used internally by `Macros::Filled`
-    # for inferring a list of possible primitives that a given
-    # type can handle.
-    #
     # @api private
-    class PrimitiveInferrer
-      extend Dry::Core::Cache
+    class PrimitiveInferrer < ::Dry::Types::PrimitiveInferrer
+      Compiler = ::Class.new(superclass::Compiler)
 
-      # Compiler reduces type AST into a list of primitives
-      #
-      # @api private
-      class Compiler
-        # @api private
-        def visit(node)
-          meth, rest = node
-          public_send(:"visit_#{meth}", rest)
-        end
-
-        # @api private
-        def visit_nominal(node)
-          type, _ = node
-          type
-        end
-
-        # @api private
-        def visit_hash(_)
-          Hash
-        end
-        alias_method :visit_schema, :visit_hash
-
-        # @api private
-        def visit_array(_)
-          Array
-        end
-
-        # @api private
-        def visit_lax(node)
-          visit(node)
-        end
-
-        # @api private
-        def visit_constructor(node)
-          other, * = node
-          visit(other)
-        end
-
-        # @api private
-        def visit_enum(node)
-          other, * = node
-          visit(other)
-        end
-
-        # @api private
-        def visit_sum(node)
-          left, right = node
-
-          [visit(left), visit(right)].flatten(1)
-        end
-
-        # @api private
-        def visit_constrained(node)
-          other, * = node
-          visit(other)
-        end
-
-        # @api private
-        def visit_any(_)
-          Object
-        end
-      end
-
-      # @return [Compiler]
-      # @api private
-      attr_reader :compiler
-
-      # @api private
       def initialize
         @compiler = Compiler.new
       end
-
-      # Infer predicate identifier from the provided type
-      #
-      # @return [Symbol]
-      #
-      # @api private
-      def [](type)
-        self.class.fetch_or_store(type.hash) do
-          Array(compiler.visit(type.to_ast)).freeze
-        end
-      end
     end
   end
 end

data/lib/dry/schema/processor.rb

@@ -1,25 +1,22 @@
 # frozen_string_literal: true
 
-require 'dry/configurable'
-require 'dry/initializer'
+require "dry/configurable"
+require "dry/initializer"
+require "dry/logic/operators"
 
-require 'dry/schema/type_registry'
-require 'dry/schema/type_container'
-require 'dry/schema/rule_applier'
-require 'dry/schema/key_coercer'
-require 'dry/schema/value_coercer'
+require "dry/schema/type_registry"
+require "dry/schema/type_container"
+require "dry/schema/processor_steps"
+require "dry/schema/rule_applier"
+require "dry/schema/key_coercer"
+require "dry/schema/value_coercer"
 
 module Dry
   module Schema
     # Processes input data using objects configured within the DSL
+    # Processing is split into steps represented by `ProcessorSteps`.
     #
-    # Processing is split into 4 main steps:
-    #
-    #   1. Prepare input hash using a key map
-    #   2. Apply pre-coercion filtering rules (optional step, used only when `filter` was used)
-    #   3. Apply value coercions based on type specifications
-    #   4. Apply rules
-    #
+    # @see ProcessorSteps
     # @see Params
     # @see JSON
     #
@@ -28,11 +25,13 @@ module Dry
       extend Dry::Initializer
       extend Dry::Configurable
 
+      include Dry::Logic::Operators
+
       setting :key_map_type
       setting :type_registry_namespace, :strict
       setting :filter_empty_string, false
 
-      option :steps, default: -> { EMPTY_ARRAY.dup }
+      option :steps, default: -> { ProcessorSteps.new }
 
       option :schema_dsl
 
@@ -66,27 +65,17 @@ module Dry
         # @api public
         def new(options = nil, &block)
           if options || block
-            processor = super
+            processor = super(**(options || EMPTY_HASH))
             yield(processor) if block
             processor
           elsif definition
             definition.call
           else
-            raise ArgumentError, 'Cannot create a schema without a definition'
+            raise ArgumentError, "Cannot create a schema without a definition"
           end
         end
       end
 
-      # Append a step
-      #
-      # @return [Processor]
-      #
-      # @api private
-      def <<(step)
-        steps << step
-        self
-      end
-
       # Apply processing steps to the provided input
       #
       # @param [Hash] input
@@ -95,31 +84,36 @@ module Dry
       #
       # @api public
       def call(input)
-        Result.new(input, message_compiler: message_compiler) do |result|
-          steps.each do |step|
-            output = step.(result)
-            result.replace(output) if output.is_a?(::Hash)
-          end
+        Result.new(input, input: input, message_compiler: message_compiler) do |result|
+          steps.call(result)
         end
       end
       alias_method :[], :call
 
-      # Return a proc that acts like a schema object
+      # @api public
+      def xor(other)
+        raise NotImplementedError, "composing schemas using `xor` operator is not supported yet"
+      end
+      alias_method :^, :xor
+
+      # Merge with another schema
       #
-      # @return [Proc]
+      # @param [Processor] other
+      #
+      # @return [Processor, Params, JSON]
       #
       # @api public
-      def to_proc
-        ->(input) { call(input) }
+      def merge(other)
+        schema_dsl.merge(other.schema_dsl).()
       end
 
-      # Return the key map
+      # Return a proc that acts like a schema object
       #
-      # @return [KeyMap]
+      # @return [Proc]
       #
       # @api public
-      def key_map
-        @key_map ||= steps.detect { |s| s.is_a?(KeyCoercer) }.key_map
+      def to_proc
+        ->(input) { call(input) }
       end
 
       # Return string represntation
@@ -133,15 +127,32 @@ module Dry
         STR
       end
 
+      # Return the key map
+      #
+      # @return [KeyMap]
+      #
+      # @api public
+      def key_map
+        steps.key_map
+      end
+
       # Return the type schema
       #
       # @return [Dry::Types::Safe]
       #
       # @api private
       def type_schema
-        @type_schema ||= steps.detect { |s| s.is_a?(ValueCoercer) }.type_schema
+        steps.type_schema
       end
 
+      # Return the rule applier
+      #
+      # @api private
+      def rule_applier
+        steps.rule_applier
+      end
+      alias_method :to_rule, :rule_applier
+
       # Return the rules config
       #
       # @return [Dry::Types::Config]
@@ -154,9 +165,10 @@ module Dry
       # Return AST representation of the rules
       #
       # @api private
-      def to_ast
+      def to_ast(*)
         rule_applier.to_ast
       end
+      alias_method :ast, :to_ast
 
       # Return the message compiler
       #
@@ -176,14 +188,6 @@ module Dry
         rule_applier.rules
       end
 
-      # Return the rule applier
-      #
-      # @api private
-      def rule_applier
-        @rule_applier ||= steps.last
-      end
-      alias_method :to_rule, :rule_applier
-
       # Check if there are filter rules
       #
       # @api private

data/lib/dry/schema/processor_steps.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "dry/initializer"
+
+require "dry/schema/constants"
+require "dry/schema/step"
+
+module Dry
+  module Schema
+    # Steps for the Dry::Schema::Processor
+    #
+    # There are 4 main steps:
+    #
+    #   1. `key_coercer` - Prepare input hash using a key map
+    #   2. `filter_schema` - Apply pre-coercion filtering rules
+    #      (optional step, used only when `filter` was used)
+    #   3. `value_coercer` - Apply value coercions based on type specifications
+    #   4. `rule_applier` - Apply rules
+    #
+    # @see Processor
+    #
+    # @api public
+    class ProcessorSteps
+      extend Dry::Initializer
+
+      option :steps, default: -> { EMPTY_HASH.dup }
+      option :before_steps, default: -> { EMPTY_HASH.dup }
+      option :after_steps, default: -> { EMPTY_HASH.dup }
+
+      # Executes steps and callbacks in order
+      #
+      # @param [Result] result
+      #
+      # @return [Result]
+      #
+      # @api public
+      def call(result)
+        STEPS_IN_ORDER.each do |name|
+          before_steps[name]&.each { |step| step&.(result) }
+          steps[name]&.(result)
+          after_steps[name]&.each { |step| step&.(result) }
+        end
+
+        result
+      end
+
+      # @api private
+      def rule_applier
+        @rule_applier ||= steps[:rule_applier].executor
+      end
+
+      # @api private
+      def key_map
+        @key_map ||= self[:key_coercer].executor.key_map
+      end
+
+      # @api private
+      def type_schema
+        @type_schema ||= steps[:value_coercer].executor.type_schema
+      end
+
+      # Returns step by name
+      #
+      # @param [Symbol] name The step name
+      #
+      # @api public
+      def [](name)
+        steps[name]
+      end
+
+      # Sets step by name
+      #
+      # @param [Symbol] name The step name
+      #
+      # @api public
+      def []=(name, value)
+        steps[name] = Step.new(type: :core, name: name, executor: value)
+      end
+
+      # Add passed block before mentioned step
+      #
+      # @param [Symbol] name The step name
+      #
+      # @return [ProcessorSteps]
+      #
+      # @api public
+      def after(name, &block)
+        after_steps[name] ||= EMPTY_ARRAY.dup
+        after_steps[name] << Step.new(type: :after, name: name, executor: block)
+        self
+      end
+
+      # Add passed block before mentioned step
+      #
+      # @param [Symbol] name The step name
+      #
+      # @return [ProcessorSteps]
+      #
+      # @api public
+      def before(name, &block)
+        before_steps[name] ||= EMPTY_ARRAY.dup
+        before_steps[name] << Step.new(type: :before, name: name, executor: block)
+        self
+      end
+
+      # Stacks callback steps and returns new ProcessorSteps instance
+      #
+      # @param [ProcessorSteps] other
+      #
+      # @return [ProcessorSteps]
+      #
+      # @api public
+      def merge(other)
+        ProcessorSteps.new(
+          before_steps: merge_callbacks(before_steps, other.before_steps),
+          after_steps: merge_callbacks(after_steps, other.after_steps)
+        )
+      end
+
+      # @api private
+      def merge_callbacks(left, right)
+        left.merge(right) do |_key, oldval, newval|
+          oldval + newval
+        end
+      end
+
+      # @api private
+      def import_callbacks(path, other)
+        other.before_steps.each do |name, steps|
+          (before_steps[name] ||= []).concat(steps.map { |step| step.scoped(path) })
+        end
+
+        other.after_steps.each do |name, steps|
+          (after_steps[name] ||= []).concat(steps.map { |step| step.scoped(path) })
+        end
+      end
+    end
+  end
+end