dry-validation 0.7.4 → 0.8.0

data/lib/dry/validation/schema/form.rb

@@ -5,6 +5,7 @@ module Dry
     class Schema::Form < Schema
       configure do |config|
         config.input_processor = :form
+        config.hash_type = :symbolized
       end
     end
   end

data/lib/dry/validation/schema/json.rb

@@ -5,6 +5,7 @@ module Dry
     class Schema::JSON < Schema
       configure do |config|
         config.input_processor = :json
+        config.hash_type = :symbolized
       end
     end
   end

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

@@ -22,28 +22,41 @@ module Dry
           [type, [name, super]]
         end
 
+        def each(*predicates, &block)
+          create_rule([type, [name, value.each(*predicates, &block).to_ast]])
+        end
+
         def hash?(&block)
-          val = Value[name]
-          val.instance_eval(&block)
+          predicate = registry[:hash?]
 
-          rule = create_rule([:val, [:predicate, [:hash?, []]]])
-            .and(create_rule([type, [name, [:set, val.rules.map(&:to_ast)]]]))
+          if block
+            val = value.instance_eval(&block)
 
-          add_rule(rule)
+            rule = create_rule([:val, predicate.to_ast])
+              .and(create_rule([type, [name, val.to_ast]]))
+
+            add_rule(rule)
+            rule
+          else
+            add_rule(create_rule([:val, predicate.to_ast]))
+          end
+        end
 
-          rule
+        def value
+          Value[name, registry: registry]
         end
 
         private
 
         def method_missing(meth, *args, &block)
-          predicate = [:predicate, [meth, args]]
+          registry.ensure_valid_predicate(meth, args)
+          predicate = registry[meth].curry(*args)
 
           if block
-            val = Value[name].instance_eval(&block)
-            add_rule(create_rule([:and, [[:val, predicate], val.to_ast]]))
+            val = value.instance_eval(&block)
+            add_rule(create_rule([:and, [[:val, predicate.to_ast], val.to_ast]]))
           else
-            rule = create_rule([type, [name, predicate]])
+            rule = create_rule([type, [name, predicate.to_ast]])
             add_rule(rule)
             rule
           end

data/lib/dry/validation/schema/rule.rb

@@ -1,7 +1,17 @@
+require 'dry/validation/deprecations'
+
 module Dry
   module Validation
     class Schema
       class Rule < BasicObject
+        include ::Dry::Validation::Deprecations
+
+        INVALID_PREDICATES = {
+          value: [],
+          maybe: [:empty?, :none?],
+          filled: [:empty?, :filled?],
+        }.freeze
+
         attr_reader :name, :node, :type, :target, :deps, :options
 
         def initialize(node, options = {})
@@ -20,27 +30,76 @@ module Dry
 
         def schema(other = nil, &block)
           schema = Schema.create_class(target, other, &block)
+
+          if schema.config.type_specs
+            target.type_map[name] = schema.type_map
+          end
+
           rule = __send__(type, key(:hash?).and(key(schema)))
           add_rule(rule)
         end
 
+        def schema?
+          target.schema?
+        end
+
+        def registry
+          target.registry
+        end
+
+        def type_map
+          target.type_map
+        end
+
+        def type_map?
+          target.type_map?
+        end
+
         def required(*predicates)
-          rule = ([key(:filled?)] + infer_predicates(predicates)).reduce(:and)
+          warn 'required is deprecated - use filled instead.'
 
-          add_rule(__send__(type, rule))
+          filled(*predicates)
         end
 
-        def maybe(*predicates)
+        def filled(*predicates, &block)
+          left = ([key(:filled?)] + infer_predicates(predicates, :filled)).reduce(:and)
+
           rule =
-            if predicates.size > 0
-              key(:none?).or(infer_predicates(predicates).reduce(:and))
+            if block
+              left.and(Key[name, registry: registry].instance_eval(&block))
             else
-              key(:none?).or(key(:filled?))
+              left
             end
 
           add_rule(__send__(type, rule))
         end
 
+        def value(*predicates, &block)
+          if predicates.empty? && !block
+            ::Kernel.raise ::ArgumentError, "wrong number of arguments (given 0, expected at least 1)"
+          end
+
+          from_predicates = infer_predicates(predicates, :value).reduce(:and)
+          from_block = block ? Key[name, registry: registry].instance_eval(&block) : nil
+
+          rule = [from_predicates, from_block].compact.reduce(:and)
+
+          add_rule(__send__(type, rule))
+        end
+
+        def maybe(*predicates, &block)
+          left = key(:none?)
+
+          from_predicates = infer_predicates(predicates, :maybe).reduce(:and)
+          from_block = block ? Key[name, registry: registry].instance_eval(&block) : nil
+
+          right = [from_predicates, from_block].compact.reduce(:and) || key(:filled?)
+
+          rule = left.or(right)
+
+          add_rule(__send__(type, rule))
+        end
+
         def each(*predicates, &block)
           rule = target.each(*predicates, &block)
           add_rule(__send__(type, new([target.type, [name, rule.to_ast]])))
@@ -98,10 +157,15 @@ module Dry
         end
         alias_method :>, :then
 
-        def infer_predicates(predicates)
+        def infer_predicates(predicates, macro = nil)
           predicates.map do |predicate|
             name, *args = ::Kernel.Array(predicate).first
-            key(name, args)
+
+            if macro && INVALID_PREDICATES[macro].include?(name)
+              ::Kernel.raise InvalidSchemaError, "you can't use #{name} predicate with #{macro} macro"
+            else
+              key(name, args)
+            end
           end
         end
 
@@ -111,19 +175,16 @@ module Dry
 
         private
 
-        def key(predicate, args = [])
-          node =
-            if predicate.is_a?(::Symbol)
-              [target.type, [name, [:predicate, [predicate, args]]]]
-            elsif predicate.respond_to?(:rule)
-              [target.type, [name, [:type, predicate]]]
-            elsif predicate.is_a?(::Class) && predicate < ::Dry::Types::Struct
-              [target.type, [name, [:schema, Schema.create_class(target, predicate)]]]
-            else
-              [target.type, [name, predicate.to_ast]]
-            end
+        def method_missing(meth, *args, &block)
+          if target.predicate?(meth)
+            target.__send__(meth, *args, &block)
+          else
+            super
+          end
+        end
 
-          new(node)
+        def key(predicate, args = [])
+          new(target.node(predicate, *args))
         end
 
         def new(node)

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

@@ -4,31 +4,45 @@ module Dry
   module Validation
     class Schema
       class Value < DSL
-        attr_reader :type, :schema_class
+        attr_reader :type, :schema_class, :schema, :type_map
 
         def initialize(options = {})
           super
           @type = options.fetch(:type, :key)
           @schema_class = options.fetch(:schema_class, ::Class.new(Schema))
+          @options = options.merge(type: @type, schema_class: @schema_class)
+          @type_map = parent && parent.root? ? parent.type_map : {}
         end
 
-        def configure(&block)
-          klass = ::Class.new(schema_class, &block)
-          @schema_class = klass
+        def predicates(mod)
+          @registry = options[:registry] = schema_class.predicates(mod)
+        end
+
+        def input(type)
+          schema_class.config.input = type
           self
         end
 
-        def root?
-          name.nil?
+        def key(name, &block)
+          warn 'key is deprecated - use required instead.'
+
+          required(name, &block)
         end
 
-        def class
-          Value
+        def required(name, type_spec = nil, &block)
+          rule = define(name, Key, &block)
+
+          if type_spec
+            type_map[name] = type_spec
+          end
+
+          rule
         end
 
         def schema(other = nil, &block)
-          schema = Schema.create_class(self, other, &block)
-          hash?.and(schema)
+          @schema = Schema.create_class(self, other, &block)
+          type_map.update(@schema.type_map)
+          hash?.and(@schema)
         end
 
         def each(*predicates, &block)
@@ -36,14 +50,21 @@ module Dry
 
           right =
             if predicates.size > 0
-              inferred = predicates
-                .reduce(Value.new) { |a, e| a.__send__(*::Kernel.Array(e)) }
-
-              create_rule([:each, inferred.to_ast])
+              create_rule([:each, infer_predicates(predicates, new).to_ast])
             else
-              val = Value[name].instance_eval(&block)
-
-              create_rule([:each, [:set, val.rule_ast]])
+              val = Value[
+                name, registry: registry, schema_class: schema_class.clone
+              ].instance_eval(&block)
+
+              if val.type_map?
+                if root?
+                  @type_map = [val.type_map]
+                else
+                  type_map[name] = [val.type_map]
+                end
+              end
+
+              create_rule([:each, val.to_ast])
             end
 
           rule = left.and(right)
@@ -54,10 +75,9 @@ module Dry
         end
 
         def when(*predicates, &block)
-          left = predicates
-            .reduce(Check[path, type: type]) { |a, e| a.__send__(*::Kernel.Array(e)) }
+          left = infer_predicates(predicates, Check[path, type: type, registry: registry])
 
-          right = Value.new(type: type)
+          right = Value.new(type: type, registry: registry)
           right.instance_eval(&block)
 
           add_check(left.then(create_rule(right.to_ast)))
@@ -67,11 +87,11 @@ module Dry
 
         def rule(id = nil, **options, &block)
           if id
-            val = Value[id]
+            val = Value[id, registry: registry]
             res = val.instance_exec(&block)
           else
             id, deps = options.to_a.first
-            val = Value[id]
+            val = Value[id, registry: registry]
             res = val.instance_exec(*deps.map { |name| val.value(name) }, &block)
           end
 
@@ -87,20 +107,85 @@ module Dry
         end
 
         def value(name)
-          check(name, rules: rules)
+          check(name, registry: registry, rules: rules)
         end
 
         def check(name, options = {})
           Check[name, options.merge(type: type)]
         end
 
+        def configure(&block)
+          klass = ::Class.new(schema_class, &block)
+          @schema_class = klass
+          @registry = klass.registry
+          self
+        end
+
+        def root?
+          name.nil?
+        end
+
+        def type_map?
+          ! type_map.empty?
+        end
+
+        def schema?
+          ! @schema.nil?
+        end
+
+        def class
+          Value
+        end
+
+        def new
+          self.class.new(registry: registry, schema_class: schema_class.clone)
+        end
+
+        def key?(name)
+          create_rule([:val, registry[:key?].curry(name).to_ast])
+        end
+
+        def predicate(name, *args)
+          registry.ensure_valid_predicate(name, args)
+          registry[name].curry(*args)
+        end
+
+        def node(input, *args)
+          if input.is_a?(::Symbol)
+            [type, [name, predicate(input, *args).to_ast]]
+          elsif input.respond_to?(:rule)
+            [type, [name, [:type, input]]]
+          elsif input.is_a?(::Class) && input < ::Dry::Types::Struct
+            [type, [name, [:schema, Schema.create_class(self, input)]]]
+          elsif input.is_a?(Schema)
+            [type, [name, schema(input).to_ast]]
+          else
+            [type, [name, input.to_ast]]
+          end
+        end
+
         private
 
+        def infer_predicates(predicates, infer_on)
+          predicates.map { |predicate|
+            name, *args = ::Kernel.Array(predicate).first
+
+            if name.is_a?(Schema)
+              infer_on.schema(name)
+            else
+              infer_on.__send__(name, *args)
+            end
+          }.reduce(:and)
+        end
+
         def method_missing(meth, *args, &block)
-          val_rule = create_rule([:val, [:predicate, [meth, args]]])
+          val_rule = create_rule([:val, predicate(meth, *args).to_ast])
 
           if block
-            val = Value.new.instance_eval(&block)
+            val = new.instance_eval(&block)
+
+            type_map.update(val.type_map) if val.type_map?
+
             new_rule = create_rule([:and, [val_rule.to_ast, val.to_ast]])
 
             add_rule(new_rule)

data/lib/dry/validation/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Validation
-    VERSION = '0.7.4'.freeze
+    VERSION = '0.8.0'.freeze
   end
 end

data/spec/fixtures/locales/en.yml

@@ -3,3 +3,4 @@ en:
     rules:
       email:
         filled?: "Please provide your email"
+    email?: "must be an email"

data/spec/fixtures/locales/pl.yml

@@ -3,7 +3,7 @@ pl:
     filled?: "nie może być pusty"
     size?:
       arg:
-        default: "wielkość musi być równa %{num}"
+        default: "wielkość musi być równa %{size}"
         range: "wielkość musi być między %{left} a %{right}"
     rules:
       email:

data/spec/integration/custom_error_messages_spec.rb

@@ -18,7 +18,7 @@ RSpec.describe Dry::Validation do
           config.messages_file = SPEC_ROOT.join('fixtures/locales/en.yml')
         end
 
-        key(:email, &:filled?)
+        required(:email, &:filled?)
       end
     end
 
@@ -38,7 +38,7 @@ RSpec.describe Dry::Validation do
             config.messages = :i18n
           end
 
-          key(:email, &:filled?)
+          required(:email, &:filled?)
         end
       end