dry-schema 1.4.1 → 1.5.2

data/lib/dry/schema/predicate_registry.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'dry/logic/predicates'
-require 'dry/types/predicate_registry'
+require "dry/logic/predicates"
+require "dry/types/predicate_registry"
 
 module Dry
   module Schema

data/lib/dry/schema/primitive_inferrer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "dry/types/primitive_inferrer"
+
+module Dry
+  module Schema
+    # @api private
+    class PrimitiveInferrer < ::Dry::Types::PrimitiveInferrer
+      Compiler = ::Class.new(superclass::Compiler)
+
+      def initialize
+        @compiler = Compiler.new
+      end
+    end
+  end
+end

data/lib/dry/schema/processor.rb

@@ -1,14 +1,15 @@
 # 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/processor_steps'
-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
@@ -24,6 +25,8 @@ 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
@@ -62,13 +65,13 @@ 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
@@ -81,28 +84,36 @@ module Dry
       #
       # @api public
       def call(input)
-        Result.new(input, message_compiler: message_compiler) do |result|
+        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
-        steps[:key_coercer].key_map
+      def to_proc
+        ->(input) { call(input) }
       end
 
       # Return string represntation
@@ -116,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
-        steps[:value_coercer].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]
@@ -137,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
       #
@@ -159,14 +188,6 @@ module Dry
         rule_applier.rules
       end
 
-      # Return the rule applier
-      #
-      # @api private
-      def rule_applier
-        steps[:rule_applier]
-      end
-      alias_method :to_rule, :rule_applier
-
       # Check if there are filter rules
       #
       # @api private

data/lib/dry/schema/processor_steps.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
-require 'dry/initializer'
+require "dry/initializer"
+
+require "dry/schema/constants"
+require "dry/schema/step"
 
 module Dry
   module Schema
@@ -20,8 +23,6 @@ module Dry
     class ProcessorSteps
       extend Dry::Initializer
 
-      STEPS_IN_ORDER = %i[key_coercer filter_schema value_coercer rule_applier].freeze
-
       option :steps, default: -> { EMPTY_HASH.dup }
       option :before_steps, default: -> { EMPTY_HASH.dup }
       option :after_steps, default: -> { EMPTY_HASH.dup }
@@ -35,13 +36,29 @@ module Dry
       # @api public
       def call(result)
         STEPS_IN_ORDER.each do |name|
-          before_steps[name]&.each { |step| process_step(step, result) }
-          process_step(steps[name], result)
-          after_steps[name]&.each { |step| process_step(step, result) }
+          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
@@ -57,8 +74,7 @@ module Dry
       #
       # @api public
       def []=(name, value)
-        validate_step_name(name)
-        steps[name] = value
+        steps[name] = Step.new(type: :core, name: name, executor: value)
       end
 
       # Add passed block before mentioned step
@@ -69,9 +85,8 @@ module Dry
       #
       # @api public
       def after(name, &block)
-        validate_step_name(name)
         after_steps[name] ||= EMPTY_ARRAY.dup
-        after_steps[name] << block.to_proc
+        after_steps[name] << Step.new(type: :after, name: name, executor: block)
         self
       end
 
@@ -83,33 +98,41 @@ module Dry
       #
       # @api public
       def before(name, &block)
-        validate_step_name(name)
         before_steps[name] ||= EMPTY_ARRAY.dup
-        before_steps[name] << block.to_proc
+        before_steps[name] << Step.new(type: :before, name: name, executor: block)
         self
       end
 
-      # @api private
-      def process_step(step, result)
-        return unless step
-
-        output = step.(result)
-        result.replace(output) if output.is_a?(::Hash)
+      # 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 validate_step_name(name)
-        return if STEPS_IN_ORDER.include?(name)
-
-        raise ArgumentError, "Undefined step name #{name}. Available names: #{STEPS_IN_ORDER}"
+      def merge_callbacks(left, right)
+        left.merge(right) do |_key, oldval, newval|
+          oldval + newval
+        end
       end
 
       # @api private
-      def initialize_copy(source)
-        super
-        @steps = source.steps.dup
-        @before_steps = source.before_steps.dup
-        @after_steps = source.after_steps.dup
+      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

data/lib/dry/schema/result.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'dry/initializer'
-require 'dry/equalizer'
+require "dry/initializer"
+require "dry/equalizer"
 
-require 'dry/schema/path'
+require "dry/schema/path"
 
 module Dry
   module Schema
@@ -32,12 +32,43 @@ module Dry
       option :message_compiler
 
       # @api private
-      def self.new(*args)
+      option :parent, default: -> { nil }
+
+      # @api private
+      def self.new(*, **)
         result = super
-        yield(result)
+        yield(result) if block_given?
         result.freeze
       end
 
+      # Return a new result scoped to a specific path
+      #
+      # @param path [Symbol, Array, Path]
+      #
+      # @return [Result]
+      #
+      # @api private
+      def at(path, &block)
+        new(Path[path].reduce(output) { |a, e| a[e] }, parent: self, &block)
+      end
+
+      # @api private
+      def new(output, **opts, &block)
+        self.class.new(
+          output,
+          message_compiler: message_compiler,
+          results: results,
+          **opts,
+          &block
+        )
+      end
+
+      # @api private
+      def update(hash)
+        output.update(hash)
+        self
+      end
+
       # @api private
       def replace(hash)
         @output = hash
@@ -90,7 +121,7 @@ module Dry
       #
       # @api public
       def success?
-        results.empty?
+        result_ast.empty?
       end
 
       # Check if the result is not successful
@@ -136,6 +167,22 @@ module Dry
         "#<#{self.class}#{to_h.inspect} errors=#{errors.to_h.inspect}>"
       end
 
+      if RUBY_VERSION >= "2.7"
+        # Pattern matching support
+        #
+        # @api private
+        def deconstruct_keys(_)
+          output
+        end
+      end
+
+      # Add a new error AST node
+      #
+      # @api private
+      def add_error(node)
+        result_ast << node
+      end
+
       private
 
       # A list of failure ASTs produced by rule result objects

data/lib/dry/schema/rule_applier.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'dry/initializer'
+require "dry/initializer"
 
-require 'dry/schema/constants'
-require 'dry/schema/config'
-require 'dry/schema/result'
-require 'dry/schema/messages'
-require 'dry/schema/message_compiler'
+require "dry/schema/constants"
+require "dry/schema/config"
+require "dry/schema/result"
+require "dry/schema/messages"
+require "dry/schema/message_compiler"
 
 module Dry
   module Schema
@@ -20,7 +20,7 @@ module Dry
       param :rules
 
       # @api private
-      option :config, default: -> { Config.new }
+      option :config, default: -> { Schema.config.dup }
 
       # @api private
       option :message_compiler, default: -> { MessageCompiler.new(Messages.setup(config.messages)) }

data/lib/dry/schema/step.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "dry/schema/constants"
+require "dry/schema/path"
+
+module Dry
+  module Schema
+    # @api private
+    class Step
+      # @api private
+      attr_reader :name
+
+      # @api private
+      attr_reader :type
+
+      # @api private
+      attr_reader :executor
+
+      # @api private
+      class Scoped
+        # @api private
+        attr_reader :path
+
+        # @api private
+        attr_reader :step
+
+        # @api private
+        def initialize(path, step)
+          @path = Path[path]
+          @step = step
+        end
+
+        # @api private
+        def scoped(new_path)
+          self.class.new(Path[[*new_path, *path]], step)
+        end
+
+        # @api private
+        def call(result)
+          result.at(path) do |scoped_result|
+            output = step.(scoped_result).to_h
+            target = Array(path)[0..-2].reduce(result) { |a, e| a[e] }
+
+            target.update(path.last => output)
+          end
+        end
+      end
+
+      # @api private
+      def initialize(type:, name:, executor:)
+        @type = type
+        @name = name
+        @executor = executor
+        validate_name(name)
+      end
+
+      # @api private
+      def call(result)
+        output = executor.(result)
+        result.replace(output) if output.is_a?(Hash)
+        output
+      end
+
+      # @api private
+      def scoped(path)
+        Scoped.new(path, self)
+      end
+
+      private
+
+      # @api private
+      def validate_name(name)
+        return if STEPS_IN_ORDER.include?(name)
+
+        raise ArgumentError, "Undefined step name #{name}. Available names: #{STEPS_IN_ORDER}"
+      end
+    end
+  end
+end