dry-schema 0.1.0 → 1.0.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/logic/operators'
 
 require 'dry/schema/macros/core'
@@ -14,10 +16,37 @@ module Dry
         undef :eql?
         undef :nil?
 
-        # @api private
+        # @!attribute [r] chain
+        #   Indicate if the macro should append its rules to the provided trace
+        #   @return [Boolean]
+        #   @api private
         option :chain, default: -> { true }
 
-        # Specify predicates that should be applied to a value
+        # @!attribute [r] predicate_inferrer
+        #   PredicateInferrer is used to infer predicate type-check from a type spec
+        #   @return [PredicateInferrer]
+        #   @api private
+        option :predicate_inferrer, default: proc { PredicateInferrer.new(compiler.predicates) }
+
+        # @overload value(*predicates, **predicate_opts)
+        #   Set predicates without and with arguments
+        #
+        #   @param [Array<Symbol>] predicates
+        #   @param [Hash] predicate_opts
+        #
+        #   @example with a predicate
+        #     required(:name).value(:filled?)
+        #
+        #   @example with a predicate with arguments
+        #     required(:name).value(min_size?: 2)
+        #
+        #   @example with a predicate with and without arguments
+        #     required(:name).value(:filled?, min_size?: 2)
+        #
+        #   @example with a block
+        #     required(:name).value { filled? & min_size?(2) }
+        #
+        # @return [Macros::Core]
         #
         # @api public
         def value(*predicates, **opts, &block)
@@ -28,6 +57,14 @@ module Dry
 
         # Prepends `:filled?` predicate
         #
+        # @example with a type spec
+        #   required(:name).filled(:string)
+        #
+        # @example with a type spec and a predicate
+        #   required(:name).filled(:string, format?: /\w+/)
+        #
+        # @return [Macros::Core]
+        #
         # @api public
         def filled(*args, &block)
           append_macro(Macros::Filled) do |macro|
@@ -35,10 +72,35 @@ module Dry
           end
         end
 
-        # Specify a nested schema
+        # Specify a nested hash without enforced `hash?` type-check
+        #
+        # This is a simpler building block than `hash` macro, use it
+        # when you want to provide `hash?` type-check with other rules
+        # manually.
+        #
+        # @example
+        #   required(:tags).value(:hash, min_size?: 1).schema do
+        #     required(:name).value(:string)
+        #   end
+        #
+        # @return [Macros::Core]
         #
         # @api public
         def schema(*args, &block)
+          append_macro(Macros::Schema) do |macro|
+            macro.call(*args, &block)
+          end
+        end
+
+        # Specify a nested hash with enforced `hash?` type-check
+        #
+        # @example
+        #   required(:tags).hash do
+        #     required(:name).value(:string)
+        #   end
+        #
+        # @api public
+        def hash(*args, &block)
           append_macro(Macros::Hash) do |macro|
             macro.call(*args, &block)
           end
@@ -46,6 +108,20 @@ module Dry
 
         # Specify predicates that should be applied to each element of an array
         #
+        # This is a simpler building block than `array` macro, use it
+        # when you want to provide `array?` type-check with other rules
+        # manually.
+        #
+        # @example a list of strings
+        #   required(:tags).value(:array, min_size?: 2).each(:str?)
+        #
+        # @example a list of hashes
+        #   required(:tags).value(:array, min_size?: 2).each(:hash) do
+        #     required(:name).filled(:string)
+        #   end
+        #
+        # @return [Macros::Core]
+        #
         # @api public
         def each(*args, &block)
           append_macro(Macros::Each) do |macro|
@@ -53,10 +129,44 @@ module Dry
           end
         end
 
+        # Like `each` but sets `array?` type-check
+        #
+        # @example a list of strings
+        #   required(:tags).array(:str?)
+        #
+        # @example a list of hashes
+        #   required(:tags).array(:hash) do
+        #     required(:name).filled(:string)
+        #   end
+        #
+        # @return [Macros::Core]
+        #
+        # @api public
+        def array(*args, &block)
+          append_macro(Macros::Array) do |macro|
+            macro.value(*args, &block)
+          end
+        end
+
+        # Set type spec
+        #
+        # @example
+        #   required(:name).type(:string).value(min_size?: 2)
+        #
+        # @param [Symbol, Array, Dry::Types::Type] spec
+        #
+        # @return [Macros::Key]
+        #
+        # @api public
+        def type(spec)
+          schema_dsl.set_type(name, spec)
+          self
+        end
+
         private
 
         # @api private
-        def append_macro(macro_type, &block)
+        def append_macro(macro_type)
           macro = macro_type.new(schema_dsl: schema_dsl, name: name)
 
           yield(macro)
@@ -68,6 +178,41 @@ module Dry
             macro
           end
         end
+
+        # @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
+
+          predicates = Array(type_spec ? args[1..-1] : args)
+
+          if type_spec
+            resolved_type = schema_dsl.resolve_type(
+              nullable && !type_spec.is_a?(::Array) ? [:nil, type_spec] : type_spec
+            )
+
+            type(resolved_type) if set_type
+
+            type_predicates = predicate_inferrer[resolved_type]
+
+            unless type_predicates.empty? || predicates.include?(type_predicates)
+              if type_predicates.is_a?(::Array) && type_predicates.size.equal?(1)
+                predicates.unshift(type_predicates[0])
+              else
+                predicates.unshift(type_predicates)
+              end
+            end
+
+            return self if predicates.empty?
+          end
+
+          yield(*predicates, type_spec: type_spec)
+        end
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/schema/macros/dsl'
 
 module Dry
@@ -5,8 +7,17 @@ module Dry
     module Macros
       # Macro used to specify predicates for each element of an array
       #
-      # @api public
+      # @api private
       class Each < DSL
+        # @api private
+        def value(*args, **opts)
+          extract_type_spec(*args, set_type: false) do |*predicates, type_spec:|
+            type(schema_dsl.array[type_spec]) if type_spec
+
+            super(*predicates, type_spec: type_spec, **opts)
+          end
+        end
+
         # @api private
         def to_ast(*)
           [:each, trace.to_ast]

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/schema/macros/value'
 
 module Dry
@@ -5,18 +7,23 @@ module Dry
     module Macros
       # Macro used to prepend `:filled?` predicate
       #
-      # @api public
+      # @api private
       class Filled < Value
-        def call(*args, &block)
-          if args.include?(:empty?)
-            raise ::Dry::Schema::InvalidSchemaError, "Using filled with empty? predicate is invalid"
+        # @api private
+        def call(*predicates, **opts, &block)
+          if predicates.include?(:empty?)
+            raise ::Dry::Schema::InvalidSchemaError, 'Using filled with empty? predicate is invalid'
           end
 
-          if args.include?(:filled?)
-            raise ::Dry::Schema::InvalidSchemaError, "Using filled with filled? is redundant"
+          if predicates.include?(:filled?)
+            raise ::Dry::Schema::InvalidSchemaError, 'Using filled with filled? is redundant'
           end
 
-          value(:filled?, *args, &block)
+          if opts[:type_spec]
+            value(predicates[0], :filled?, *predicates[1..predicates.size - 1], **opts, &block)
+          else
+            value(:filled?, *predicates, **opts, &block)
+          end
         end
       end
     end

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

@@ -1,44 +1,18 @@
-require 'dry/schema/macros/value'
+# frozen_string_literal: true
+
+require 'dry/schema/macros/schema'
 
 module Dry
   module Schema
     module Macros
       # Macro used to specify a nested schema
       #
-      # @api public
-      class Hash < Value
+      # @api private
+      class Hash < Schema
         # @api private
         def call(*args, &block)
           trace << hash?
-
-          super(*args) unless args.empty?
-
-          if block
-            definition = schema_dsl.new(&block)
-
-            parent_type = schema_dsl.types[name]
-            definition_schema = definition.type_schema
-
-            schema_type =
-              if parent_type.respond_to?(:of)
-                parent_type.of(definition_schema)
-              else
-                definition_schema
-              end
-
-            final_type =
-              if schema_dsl.maybe?(parent_type)
-                schema_type.optional
-              else
-                schema_type
-              end
-
-            schema_dsl.set_type(name, final_type)
-
-            trace << definition.to_rule
-          end
-
-          self
+          super(*args, &block)
         end
       end
     end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/schema/predicate_inferrer'
 require 'dry/schema/processor'
 require 'dry/schema/macros/dsl'
@@ -6,18 +8,20 @@ require 'dry/schema/constants'
 module Dry
   module Schema
     module Macros
-      # Base macro for specifying rules applied to a value found under the key
-      #
-      # @see DSL#key
+      # Base macro for specifying rules applied to a value found under a key
       #
       # @api public
       class Key < DSL
+        # @return [Schema::DSL]
+        # @api private
         option :filter_schema, optional: true, default: proc { schema_dsl&.new }
 
-        # Specify predicates that should be used to filter out values
-        # before coercion is applied
+        # Specify predicates that should be applied before coercion
         #
-        # @see Macros::DSL#value
+        # @example check format before coercing to a date
+        #   required(:publish_date).filter(format?: /\d{4}-\d{2}-\d{2}).value(:date)
+        #
+        # @see Macros::Key#value
         #
         # @return [Macros::Key]
         #
@@ -27,59 +31,67 @@ module Dry
           self
         end
 
-        # Set type specification and predicates
+        # @overload value(type_spec, *predicates, **predicate_opts)
+        #   Set type specification and predicates
         #
-        # @see Macros::DSL#value
+        #   @param [Symbol,Types::Type,Array] type_spec
+        #   @param [Array<Symbol>] predicates
+        #   @param [Hash] predicate_opts
+        #
+        #   @example with a predicate
+        #     required(:name).value(:string, :filled?)
+        #
+        #   @example with a predicate with arguments
+        #     required(:name).value(:string, min_size?: 2)
+        #
+        #   @example with a block
+        #     required(:name).value(:string) { filled? & min_size?(2) }
         #
         # @return [Macros::Key]
         #
+        # @see Macros::DSL#value
+        #
         # @api public
         def value(*args, **opts, &block)
-          extract_type_spec(*args) do |*predicates|
+          extract_type_spec(*args) do |*predicates, type_spec:|
             super(*predicates, **opts, &block)
           end
         end
 
         # Set type specification and predicates for a filled value
         #
-        # @see Macros::DSL#value
+        # @example
+        #   required(:name).filled(:string)
+        #
+        # @see Macros::Key#value
         #
         # @return [Macros::Key]
         #
         # @api public
         def filled(*args, **opts, &block)
-          extract_type_spec(*args) do |*predicates|
-            super(*predicates, **opts, &block)
+          extract_type_spec(*args) do |*predicates, type_spec:|
+            super(*predicates, type_spec: type_spec, **opts, &block)
           end
         end
 
         # Set type specification and predicates for a maybe value
         #
-        # @see Macros::DSL#value
+        # @example
+        #   required(:name).maybe(:string)
+        #
+        # @see Macros::Key#value
         #
         # @return [Macros::Key]
         #
         # @api public
         def maybe(*args, **opts, &block)
-          extract_type_spec(*args, nullable: true) do |*predicates|
+          extract_type_spec(*args, nullable: true) do |*predicates, type_spec:|
             append_macro(Macros::Maybe) do |macro|
               macro.call(*predicates, **opts, &block)
             end
           end
         end
 
-        # Set type spec
-        #
-        # @param [Symbol, Array, Dry::Types::Type]
-        #
-        # @return [Macros::Key]
-        #
-        # @api public
-        def type(spec)
-          schema_dsl.set_type(name, spec)
-          self
-        end
-
         # Coerce macro to a rule
         #
         # @return [Dry::Logic::Rule]
@@ -97,40 +109,6 @@ module Dry
         def to_ast
           [:predicate, [:key?, [[:name, name], [:input, Undefined]]]]
         end
-
-        private
-
-        # @api private
-        def extract_type_spec(*args, nullable: false)
-          type_spec = args[0]
-
-          if type_spec.kind_of?(Schema::Processor) || type_spec.is_a?(Symbol) && type_spec.to_s.end_with?(QUESTION_MARK)
-            type_spec = nil
-          end
-
-          predicates = Array(type_spec ? args[1..-1] : args)
-
-          if type_spec
-            type(nullable && !type_spec.is_a?(::Array) ? [:nil, type_spec] : type_spec)
-            type_predicates = PredicateInferrer[schema_dsl.types[name]]
-
-            unless predicates.include?(type_predicates)
-              type_predicates.each do |pred|
-                unless compiler.supports?(pred)
-                  raise ArgumentError, "Predicate +#{pred.inspect}+ inferred from #{type_spec.inspect} type spec is not supported"
-                end
-              end
-
-              if type_predicates.size.equal?(1)
-                predicates.unshift(type_predicates[0])
-              else
-                predicates.unshift(type_predicates)
-              end
-            end
-          end
-
-          yield(*predicates)
-        end
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/schema/macros/dsl'
 
 module Dry
@@ -5,16 +7,16 @@ module Dry
     module Macros
       # Macro used to specify predicates for a value that can be `nil`
       #
-      # @api public
+      # @api private
       class Maybe < DSL
         # @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)

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/schema/macros/key'
 
 module Dry
@@ -5,12 +7,17 @@ module Dry
     module Macros
       # A Key specialization used for keys that can be skipped
       #
-      # @api public
+      # @api private
       class Optional < Key
         # @api private
         def operation
           :then
         end
+
+        # @api private
+        def to_rule
+          super unless trace.captures.empty?
+        end
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/schema/macros/key'
 
 module Dry
@@ -5,7 +7,7 @@ module Dry
     module Macros
       # A Key specialization used for keys that must be present
       #
-      # @api public
+      # @api private
       class Required < Key
         # @api private
         def operation

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'dry/schema/macros/value'
+
+module Dry
+  module Schema
+    module Macros
+      # Macro used to specify a nested schema
+      #
+      # @api private
+      class Schema < Value
+        # @api private
+        def call(*args, &block)
+          super(*args) unless args.empty?
+
+          if block
+            definition = schema_dsl.new(&block)
+
+            parent_type = schema_dsl.types[name]
+            definition_schema = definition.type_schema
+
+            schema_type =
+              if parent_type.respond_to?(:of)
+                parent_type.of(definition_schema)
+              else
+                definition_schema
+              end
+
+            final_type =
+              if parent_type.optional?
+                schema_type.optional
+              else
+                schema_type
+              end
+
+            schema_dsl.set_type(name, final_type)
+
+            trace << definition.to_rule
+          end
+
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/schema/macros/dsl'
 
 module Dry
@@ -5,12 +7,26 @@ module Dry
     module Macros
       # A macro used for specifying predicates to be applied to values from a hash
       #
-      # @api public
+      # @api private
       class Value < DSL
         # @api private
         def call(*predicates, **opts, &block)
-          trace.evaluate(*predicates, **opts, &block)
+          schema = predicates.detect { |predicate| predicate.is_a?(Processor) }
+
+          if schema
+            current_type = schema_dsl.types[name]
+
+            updated_type =
+              if current_type.respond_to?(:of)
+                current_type.of(schema.type_schema)
+              else
+                schema.type_schema
+              end
+
+            schema_dsl.set_type(name, updated_type)
+          end
 
+          trace.evaluate(*predicates, **opts)
           trace.append(new(chain: false).instance_exec(&block)) if block
 
           if trace.captures.empty?

data/lib/dry/schema/macros.rb

@@ -1,5 +1,9 @@
+# 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'

data/lib/dry/schema/message/or.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'dry/equalizer'
+
+module Dry
+  module Schema
+    # Message objects used by message sets
+    #
+    # @api public
+    class Message
+      # A message sub-type used by OR operations
+      #
+      # @api public
+      class Or
+        # @api private
+        attr_reader :left
+
+        # @api private
+        attr_reader :right
+
+        # @api private
+        attr_reader :path
+
+        # @api private
+        attr_reader :messages
+
+        # @api private
+        def initialize(left, right, messages)
+          @left = left
+          @right = right
+          @messages = messages
+          @path = left.path
+        end
+
+        # Dump a message into a string
+        #
+        # @see Message#dump
+        #
+        # @return [String]
+        #
+        # @api public
+        def dump
+          to_a.map(&:dump).join(" #{messages[:or][:text]} ")
+        end
+        alias to_s dump
+
+        # @api private
+        def to_a
+          [left, right]
+        end
+      end
+    end
+  end
+end