dry-schema 1.4.3 → 1.5.4

data/lib/dry/schema/params.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/schema/processor'
+require "dry/schema/processor"
 
 module Dry
   module Schema

data/lib/dry/schema/path.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/schema/constants'
+require "dry/schema/constants"
 
 module Dry
   module Schema
@@ -8,6 +8,7 @@ module Dry
     #
     # @api private
     class Path
+      include Dry.Equalizer(:keys)
       include Comparable
       include Enumerable
 
@@ -23,7 +24,7 @@ module Dry
       # @return [Path]
       #
       # @api private
-      def self.[](spec)
+      def self.call(spec)
         case spec
         when Symbol, Array
           new(Array[*spec])
@@ -34,10 +35,15 @@ module Dry
         when Path
           spec
         else
-          raise ArgumentError, '+spec+ must be either a Symbol, Array, Hash or a Path'
+          raise ArgumentError, "+spec+ must be either a Symbol, Array, Hash or a Path"
         end
       end
 
+      # @api private
+      def self.[](spec)
+        call(spec)
+      end
+
       # Extract a list of keys from a hash
       #
       # @api private
@@ -52,6 +58,28 @@ module Dry
         @keys = keys
       end
 
+      # @api private
+      def to_h(value = EMPTY_ARRAY.dup)
+        curr_idx = 0
+        last_idx = keys.size - 1
+        hash = EMPTY_HASH.dup
+        node = hash
+
+        while curr_idx <= last_idx
+          node =
+            node[keys[curr_idx]] =
+              if curr_idx == last_idx
+                value.is_a?(Array) ? value : [value]
+              else
+                EMPTY_HASH.dup
+              end
+
+          curr_idx += 1
+        end
+
+        hash
+      end
+
       # @api private
       def each(&block)
         keys.each(&block)
@@ -83,8 +111,19 @@ module Dry
       end
 
       # @api private
-      def key_matches(other)
-        map { |key| (idx = other.index(key)) && keys[idx].equal?(key) }
+      def &(other)
+        unless same_root?(other)
+          raise ArgumentError, "#{other.inspect} doesn't have the same root #{inspect}"
+        end
+
+        self.class.new(
+          key_matches(other, :select).compact.reject { |value| value.equal?(false) }
+        )
+      end
+
+      # @api private
+      def key_matches(other, meth = :map)
+        public_send(meth) { |key| (idx = other.index(key)) && keys[idx].equal?(key) }
       end
 
       # @api private

data/lib/dry/schema/predicate.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'dry/equalizer'
-require 'dry/logic/operators'
+require "dry/equalizer"
+require "dry/logic/operators"
 
 module Dry
   module Schema
@@ -13,6 +13,8 @@ module Dry
       #
       # @api private
       class Negation
+        include Dry::Logic::Operators
+
         # @api private
         attr_reader :predicate
 

data/lib/dry/schema/predicate_inferrer.rb

@@ -1,196 +1,16 @@
 # frozen_string_literal: true
 
-require 'dry/core/cache'
+require "dry/types/predicate_inferrer"
 
 module Dry
   module Schema
-    # PredicateInferrer is used internally by `Macros::Value`
-    # for inferring type-check predicates from type specs.
-    #
     # @api private
-    class PredicateInferrer
-      extend Dry::Core::Cache
+    class PredicateInferrer < ::Dry::Types::PredicateInferrer
+      Compiler = ::Class.new(superclass::Compiler)
 
-      TYPE_TO_PREDICATE = {
-        DateTime => :date_time?,
-        FalseClass => :false?,
-        Integer => :int?,
-        NilClass => :nil?,
-        String => :str?,
-        TrueClass => :true?,
-        BigDecimal => :decimal?
-      }.freeze
-
-      REDUCED_TYPES = {
-        [[[:true?], [:false?]]] => %i[bool?]
-      }.freeze
-
-      HASH = %i[hash?].freeze
-
-      ARRAY = %i[array?].freeze
-
-      NIL = %i[nil?].freeze
-
-      # Compiler reduces type AST into a list of predicates
-      #
-      # @api private
-      class Compiler
-        # @return [PredicateRegistry]
-        # @api private
-        attr_reader :registry
-
-        # @api private
-        def initialize(registry)
-          @registry = registry
-        end
-
-        # @api private
-        def infer_predicate(type)
-          [TYPE_TO_PREDICATE.fetch(type) { :"#{type.name.split('::').last.downcase}?" }]
-        end
-
-        # @api private
-        def visit(node)
-          meth, rest = node
-          public_send(:"visit_#{meth}", rest)
-        end
-
-        # @api private
-        def visit_nominal(node)
-          type = node[0]
-          predicate = infer_predicate(type)
-
-          if registry.key?(predicate[0])
-            predicate
-          else
-            [type?: type]
-          end
-        end
-
-        # @api private
-        def visit_hash(_)
-          HASH
-        end
-
-        # @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_node, right_node, = node
-          left = visit(left_node)
-          right = visit(right_node)
-
-          if left.eql?(NIL)
-            right
-          else
-            [[left, right]]
-          end
-        end
-
-        # @api private
-        def visit_constrained(node)
-          other, rules = node
-          predicates = visit(rules)
-
-          if predicates.empty?
-            visit(other)
-          else
-            [*visit(other), *merge_predicates(predicates)]
-          end
-        end
-
-        # @api private
-        def visit_any(_)
-          EMPTY_ARRAY
-        end
-
-        # @api private
-        def visit_and(node)
-          left, right = node
-          visit(left) + visit(right)
-        end
-
-        # @api private
-        def visit_predicate(node)
-          pred, args = node
-
-          if pred.equal?(:type?)
-            EMPTY_ARRAY
-          elsif registry.key?(pred)
-            *curried, _ = args
-            values = curried.map { |_, v| v }
-
-            if values.empty?
-              [pred]
-            else
-              [pred => values[0]]
-            end
-          else
-            EMPTY_ARRAY
-          end
-        end
-
-        private
-
-        # @api private
-        def merge_predicates(nodes)
-          preds, merged = nodes.each_with_object([[], {}]) do |predicate, (ps, h)|
-            if predicate.is_a?(::Hash)
-              h.update(predicate)
-            else
-              ps << predicate
-            end
-          end
-
-          merged.empty? ? preds : [*preds, merged]
-        end
-      end
-
-      # @return [Compiler]
-      # @api private
-      attr_reader :compiler
-
-      # @api private
-      def initialize(registry)
+      def initialize(registry = PredicateRegistry.new)
         @compiler = Compiler.new(registry)
       end
-
-      # Infer predicate identifier from the provided type
-      #
-      # @return [Symbol]
-      #
-      # @api private
-      def [](type)
-        self.class.fetch_or_store(type.hash) do
-          predicates = compiler.visit(type.to_ast)
-
-          if predicates.is_a?(Hash)
-            predicates
-          else
-            REDUCED_TYPES[predicates] || predicates
-          end
-        end
-      end
     end
   end
 end

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
@@ -68,7 +71,7 @@ module Dry
           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