dry-schema 1.4.2 → 1.5.3

data/lib/dry/schema/macros.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'dry/schema/macros/array'
-require 'dry/schema/macros/each'
-require 'dry/schema/macros/filled'
-require 'dry/schema/macros/schema'
-require 'dry/schema/macros/hash'
-require 'dry/schema/macros/maybe'
-require 'dry/schema/macros/optional'
-require 'dry/schema/macros/required'
+require "dry/schema/macros/array"
+require "dry/schema/macros/each"
+require "dry/schema/macros/filled"
+require "dry/schema/macros/schema"
+require "dry/schema/macros/hash"
+require "dry/schema/macros/maybe"
+require "dry/schema/macros/optional"
+require "dry/schema/macros/required"

data/lib/dry/schema/macros/array.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/schema/macros/dsl'
+require "dry/schema/macros/dsl"
 
 module Dry
   module Schema
@@ -13,16 +13,29 @@ module Dry
         def value(*args, **opts, &block)
           type(:array)
 
-          extract_type_spec(*args, set_type: false) do |*predicates, type_spec:|
+          extract_type_spec(*args, set_type: false) do |*predicates, type_spec:, type_rule:|
             type(schema_dsl.array[type_spec]) if type_spec
 
             is_hash_block = type_spec.equal?(:hash)
 
             if predicates.any? || opts.any? || !is_hash_block
-              super(*predicates, type_spec: type_spec, **opts, &(is_hash_block ? nil : block))
+              super(
+                *predicates, type_spec: type_spec, type_rule: type_rule, **opts,
+                &(is_hash_block ? nil : block)
+              )
             end
 
-            hash(&block) if is_hash_block
+            is_op = args.size.equal?(2) && args[1].is_a?(Logic::Operations::Abstract)
+
+            if is_hash_block && !is_op
+              hash(&block)
+            elsif is_op
+              hash = Value.new(schema_dsl: schema_dsl.new, name: name).hash(args[1])
+
+              trace.captures.concat(hash.trace.captures)
+
+              type(schema_dsl.types[name].of(hash.schema_dsl.types[name]))
+            end
           end
 
           self

data/lib/dry/schema/macros/core.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'dry/initializer'
+require "dry/initializer"
 
-require 'dry/schema/constants'
-require 'dry/schema/compiler'
-require 'dry/schema/trace'
+require "dry/schema/constants"
+require "dry/schema/compiler"
+require "dry/schema/trace"
 
 module Dry
   module Schema
@@ -32,6 +32,11 @@ module Dry
           self.class.new(name: name, compiler: compiler, schema_dsl: schema_dsl, **options)
         end
 
+        # @api private
+        def path
+          schema_dsl.path
+        end
+
         # @api private
         def to_rule
           compiler.visit(to_ast)

data/lib/dry/schema/macros/dsl.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'dry/logic/operators'
-require 'dry/types/predicate_inferrer'
-require 'dry/types/primitive_inferrer'
+require "dry/logic/operators"
 
-require 'dry/schema/macros/core'
+require "dry/schema/macros/core"
+require "dry/schema/predicate_inferrer"
+require "dry/schema/primitive_inferrer"
 
 module Dry
   module Schema
@@ -28,13 +28,13 @@ module Dry
         #   PredicateInferrer is used to infer predicate type-check from a type spec
         #   @return [PredicateInferrer]
         #   @api private
-        option :predicate_inferrer, default: proc { ::Dry::Types::PredicateInferrer.new(compiler.predicates) }
+        option :predicate_inferrer, default: proc { PredicateInferrer.new(compiler.predicates) }
 
         # @!attribute [r] primitive_inferrer
         #   PrimitiveInferrer used to get a list of primitive classes from configured type
         #   @return [PrimitiveInferrer]
         #   @api private
-        option :primitive_inferrer, default: proc { ::Dry::Types::PrimitiveInferrer.new }
+        option :primitive_inferrer, default: proc { PrimitiveInferrer.new }
 
         # @overload value(*predicates, **predicate_opts)
         #   Set predicates without and with arguments
@@ -177,6 +177,11 @@ module Dry
           self
         end
 
+        # @api private
+        def custom_type?
+          schema_dsl.custom_type?(name)
+        end
+
         private
 
         # @api private
@@ -195,29 +200,32 @@ module Dry
 
         # @api private
         def extract_type_spec(*args, nullable: false, set_type: true)
-          type_spec = args[0]
-
-          is_type_spec = type_spec.is_a?(Dry::Schema::Processor) ||
-                         type_spec.is_a?(Symbol) &&
-                         type_spec.to_s.end_with?(QUESTION_MARK)
-
-          type_spec = nil if is_type_spec
+          type_spec = args[0] unless schema_or_predicate?(args[0])
 
           predicates = Array(type_spec ? args[1..-1] : args)
+          type_rule = nil
 
           if type_spec
             resolved_type = resolve_type(type_spec, nullable)
 
-            type(resolved_type) if set_type
-
-            type_predicates = predicate_inferrer[resolved_type]
+            if type_spec.is_a?(::Array)
+              type_rule = type_spec.map { |ts| new(chain: false).value(ts) }.reduce(:|)
+            else
+              type_predicates = predicate_inferrer[resolved_type]
 
-            predicates.replace(type_predicates + predicates) unless type_predicates.empty?
+              predicates.replace(type_predicates + predicates) unless type_predicates.empty?
 
-            return self if predicates.empty?
+              return self if predicates.empty?
+            end
           end
 
-          yield(*predicates, type_spec: type_spec)
+          type(resolved_type) if set_type && resolved_type
+
+          if type_rule
+            yield(*predicates, type_spec: nil, type_rule: type_rule)
+          else
+            yield(*predicates, type_spec: type_spec, type_rule: nil)
+          end
         end
 
         # @api private
@@ -230,6 +238,13 @@ module Dry
             schema_dsl.resolve_type([:nil, resolved])
           end
         end
+
+        # @api private
+        def schema_or_predicate?(arg)
+          arg.is_a?(Dry::Schema::Processor) ||
+            arg.is_a?(Symbol) &&
+              arg.to_s.end_with?(QUESTION_MARK)
+        end
       end
     end
   end

data/lib/dry/schema/macros/each.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'dry/types/type'
-require 'dry/schema/macros/dsl'
+require "dry/types/type"
+require "dry/schema/macros/dsl"
 
 module Dry
   module Schema
@@ -12,12 +12,12 @@ module Dry
       class Each < DSL
         # @api private
         def value(*args, **opts)
-          extract_type_spec(*args, set_type: false) do |*predicates, type_spec:|
+          extract_type_spec(*args, set_type: false) do |*predicates, type_spec:, type_rule:|
             if type_spec && !type_spec.is_a?(Dry::Types::Type)
               type(schema_dsl.array[type_spec])
             end
 
-            super(*predicates, type_spec: type_spec, **opts)
+            super(*predicates, type_spec: type_spec, type_rule: type_rule, **opts)
           end
         end
 

data/lib/dry/schema/macros/filled.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/schema/macros/value'
+require "dry/schema/macros/value"
 
 module Dry
   module Schema
@@ -15,23 +15,23 @@ module Dry
 
           if opts[:type_spec] && !filter_empty_string?
             value(predicates[0], :filled?, *predicates[1..predicates.size - 1], **opts, &block)
+          elsif opts[:type_rule]
+            value(:filled?).value(*predicates, **opts, &block)
           else
             value(:filled?, *predicates, **opts, &block)
           end
         end
 
         # @api private
-        # rubocop:disable Style/GuardClause
         def ensure_valid_predicates(predicates)
           if predicates.include?(:empty?)
-            raise ::Dry::Schema::InvalidSchemaError, 'Using filled with empty? predicate is invalid'
+            raise ::Dry::Schema::InvalidSchemaError, "Using filled with empty? predicate is invalid"
           end
 
           if predicates.include?(:filled?)
-            raise ::Dry::Schema::InvalidSchemaError, 'Using filled with filled? is redundant'
+            raise ::Dry::Schema::InvalidSchemaError, "Using filled with filled? is redundant"
           end
         end
-        # rubocop:enable Style/GuardClause
 
         # @api private
         def filter_empty_string?

data/lib/dry/schema/macros/hash.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/schema/macros/schema'
+require "dry/schema/macros/schema"
 
 module Dry
   module Schema
@@ -11,8 +11,26 @@ module Dry
       class Hash < Schema
         # @api private
         def call(*args, &block)
-          trace << hash?
-          super(*args, &block)
+          if args.size >= 1 && args[0].respond_to?(:keys)
+            hash_type = args[0]
+            type_predicates = predicate_inferrer[hash_type]
+            all_predicats = type_predicates + args.drop(1)
+
+            super(*all_predicats) do
+              hash_type.each do |key|
+                if key.required?
+                  required(key.name).value(key.type)
+                else
+                  optional(key.name).value(key.type)
+                end
+                instance_exec(&block) if block
+              end
+            end
+          else
+            trace << hash?
+
+            super(*args, &block)
+          end
         end
       end
     end

data/lib/dry/schema/macros/key.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'dry/schema/processor'
-require 'dry/schema/macros/dsl'
-require 'dry/schema/constants'
+require "dry/schema/processor"
+require "dry/schema/macros/dsl"
+require "dry/schema/constants"
 
 module Dry
   module Schema
@@ -54,8 +54,8 @@ module Dry
         #
         # @api public
         def value(*args, **opts, &block)
-          extract_type_spec(*args) do |*predicates, type_spec:|
-            super(*predicates, type_spec: type_spec, **opts, &block)
+          extract_type_spec(*args) do |*predicates, type_spec:, type_rule:|
+            super(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
           end
         end
 
@@ -70,8 +70,8 @@ module Dry
         #
         # @api public
         def filled(*args, **opts, &block)
-          extract_type_spec(*args) do |*predicates, type_spec:|
-            super(*predicates, type_spec: type_spec, **opts, &block)
+          extract_type_spec(*args) do |*predicates, type_spec:, type_rule:|
+            super(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
           end
         end
 
@@ -86,9 +86,9 @@ module Dry
         #
         # @api public
         def maybe(*args, **opts, &block)
-          extract_type_spec(*args, nullable: true) do |*predicates, type_spec:|
+          extract_type_spec(*args, nullable: true) do |*predicates, type_spec:, type_rule:|
             append_macro(Macros::Maybe) do |macro|
-              macro.call(*predicates, type_spec: type_spec, **opts, &block)
+              macro.call(*predicates, type_spec: type_spec, type_rule: type_rule, **opts, &block)
             end
           end
         end

data/lib/dry/schema/macros/maybe.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/schema/macros/dsl'
+require "dry/schema/macros/dsl"
 
 module Dry
   module Schema
@@ -12,11 +12,11 @@ module Dry
         # @api private
         def call(*args, **opts, &block)
           if args.include?(:empty?)
-            raise ::Dry::Schema::InvalidSchemaError, 'Using maybe with empty? predicate is invalid'
+            raise ::Dry::Schema::InvalidSchemaError, "Using maybe with empty? predicate is invalid"
           end
 
           if args.include?(:nil?)
-            raise ::Dry::Schema::InvalidSchemaError, 'Using maybe with nil? predicate is redundant'
+            raise ::Dry::Schema::InvalidSchemaError, "Using maybe with nil? predicate is redundant"
           end
 
           value(*args, **opts, &block)
@@ -30,8 +30,7 @@ module Dry
            [
              [:not, [:predicate, [:nil?, [[:input, Undefined]]]]],
              trace.to_rule.to_ast
-           ]
-          ]
+           ]]
         end
       end
     end

data/lib/dry/schema/macros/optional.rb

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

data/lib/dry/schema/macros/required.rb

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

data/lib/dry/schema/macros/schema.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/schema/macros/value'
+require "dry/schema/macros/value"
 
 module Dry
   module Schema
@@ -13,8 +13,13 @@ module Dry
         def call(*args, &block)
           super(*args, &nil) unless args.empty?
 
+          if args.size.equal?(1) && (op = args.first).is_a?(Dry::Logic::Operations::Abstract)
+            process_operation(op)
+          end
+
           if block
             schema = define(*args, &block)
+            import_steps(schema)
             trace << schema.to_rule
           end
 
@@ -23,9 +28,25 @@ module Dry
 
         private
 
+        # @api private
+        def process_operation(op)
+          schemas = op.rules.select { |rule| rule.is_a?(Processor) }
+
+          hash_schema = hash_type.schema(
+            schemas.map(&:schema_dsl).map(&:types).reduce(:merge)
+          )
+
+          type(hash_schema)
+        end
+
+        # @api private
+        def hash_type
+          schema_dsl.resolve_type(:hash)
+        end
+
         # @api private
         def define(*args, &block)
-          definition = schema_dsl.new(&block)
+          definition = schema_dsl.new(path: schema_dsl.path, &block)
           schema = definition.call
           type_schema =
             if array_type?(parent_type)

data/lib/dry/schema/macros/value.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'dry/schema/macros/dsl'
+require "dry/schema/path"
+require "dry/schema/macros/dsl"
 
 module Dry
   module Schema
@@ -13,6 +14,8 @@ module Dry
         def call(*predicates, **opts, &block)
           schema = predicates.detect { |predicate| predicate.is_a?(Processor) }
 
+          type_spec = opts[:type_spec]
+
           if schema
             current_type = schema_dsl.types[name]
 
@@ -23,17 +26,32 @@ module Dry
                 schema.type_schema
               end
 
-            schema_dsl.set_type(name, updated_type)
+            import_steps(schema)
+
+            type(updated_type) unless custom_type? && !current_type.respond_to?(:of)
           end
 
-          trace.evaluate(*predicates, **opts)
-          trace.append(new(chain: false).instance_exec(&block)) if block
+          trace_opts = opts.reject { |key, _| key == :type_spec || key == :type_rule }
+
+          if (type_rule = opts[:type_rule])
+            trace.append(type_rule).evaluate(*predicates, **trace_opts)
+            trace.append(new(chain: false).instance_exec(&block)) if block
+          else
+            trace.evaluate(*predicates, **trace_opts)
+
+            if block && type_spec.equal?(:hash)
+              hash(&block)
+            elsif type_spec.is_a?(::Dry::Types::Type) && hash_type?(type_spec)
+              hash(type_spec)
+            elsif block
+              trace.append(new(chain: false).instance_exec(&block))
+            end
+          end
 
           if trace.captures.empty?
-            raise ArgumentError, 'wrong number of arguments (given 0, expected at least 1)'
+            raise ArgumentError, "wrong number of arguments (given 0, expected at least 1)"
           end
 
-          type_spec = opts[:type_spec]
           each(type_spec.type.member) if type_spec.respond_to?(:member)
 
           self
@@ -44,12 +62,16 @@ module Dry
           primitive_inferrer[type].eql?([::Array])
         end
 
+        def hash_type?(type)
+          primitive_inferrer[type].eql?([::Hash])
+        end
+
         # @api private
         def build_array_type(array_type, member)
           if array_type.respond_to?(:of)
             array_type.of(member)
           else
-            raise ArgumentError, <<~ERROR.split("\n").join(' ')
+            raise ArgumentError, <<~ERROR.split("\n").join(" ")
               Cannot define schema for a nominal array type.
               Array types must be instances of Dry::Types::Array,
               usually constructed with Types::Constructor(Array) { ... } or
@@ -58,6 +80,11 @@ module Dry
           end
         end
 
+        # @api private
+        def import_steps(schema)
+          schema_dsl.steps.import_callbacks(Path[[*path, name]], schema.steps)
+        end
+
         # @api private
         def respond_to_missing?(meth, include_private = false)
           super || meth.to_s.end_with?(QUESTION_MARK)