dry-validation 0.7.4 → 0.8.0

data/examples/nested.rb

@@ -1,14 +1,14 @@
 require 'dry-validation'
 
 schema = Dry::Validation.Schema do
-  key(:address).schema do
-    key(:city).required(min_size?: 3)
+  required(:address).schema do
+    required(:city).filled(min_size?: 3)
 
-    key(:street).required
+    required(:street).filled
 
-    key(:country).schema do
-      key(:name).required
-      key(:code).required
+    required(:country).schema do
+      required(:name).filled
+      required(:code).filled
     end
   end
 end

data/lib/dry/validation.rb

@@ -9,26 +9,45 @@ require 'dry/validation/schema/json'
 module Dry
   module Validation
     MissingMessageError = Class.new(StandardError)
+    InvalidSchemaError = Class.new(StandardError)
 
     def self.messages_paths
       Messages::Abstract.config.paths
     end
 
     def self.Schema(base = Schema, **options, &block)
+      schema_class = Class.new(base.is_a?(Schema) ? base.class : base)
+
       dsl_opts = {
-        schema_class: Class.new(base.is_a?(Schema) ? base.class : base),
+        schema_class: schema_class,
+        registry: schema_class.registry,
         parent: options[:parent]
       }
 
+      dsl_ext = schema_class.config.dsl_extensions
+
       dsl = Schema::Value.new(dsl_opts)
-      dsl.instance_exec(&block)
+      dsl_ext.__send__(:extend_object, dsl) if dsl_ext
+      dsl.predicates(options[:predicates]) if options.key?(:predicates)
+      dsl.instance_exec(&block) if block
 
       klass = dsl.schema_class
 
+      base_rules = klass.config.rules + (options.fetch(:rules, []) + dsl.rules)
+
+      rules =
+        if klass.config.input
+          input_rule = dsl.__send__(klass.config.input)
+          [input_rule.and(dsl.with(rules: base_rules))]
+        else
+          base_rules
+        end
+
       klass.configure do |config|
-        config.rules = config.rules + (options.fetch(:rules, []) + dsl.rules)
+        config.rules = rules
         config.checks = config.checks + dsl.checks
         config.path = dsl.path
+        config.type_map = klass.build_type_map(dsl.type_map) if config.type_specs
       end
 
       if options[:build] == false

data/lib/dry/validation/deprecations.rb

@@ -0,0 +1,23 @@
+require 'logger'
+
+module Dry
+  module Validation
+    module Deprecations
+      extend Dry::Configurable
+
+      setting :logger, Logger.new($stdout)
+
+      def self.format(msg, caller)
+        "#{msg} [#{caller[1].split(':')[0..1].join(' line ')}]"
+      end
+
+      def logger
+        @logger ||= Deprecations.config.logger
+      end
+
+      def warn(msg)
+        logger.warn(Deprecations.format(msg, ::Kernel.caller))
+      end
+    end
+  end
+end

data/lib/dry/validation/error_compiler.rb

@@ -10,7 +10,7 @@ module Dry
       def initialize(messages, options = {})
         @messages = messages
         @options = Hash[options]
-        @hints = @options.fetch(:hints, {})
+        @hints = @options.fetch(:hints, DEFAULT_RESULT)
         @full = options.fetch(:full, false)
       end
 
@@ -49,8 +49,12 @@ module Dry
 
           if result.is_a?(Array)
             merge(result)
-          else
+          elsif !schema
             merge_hints(result)
+          elsif schema
+            merge_hints(result, hints[schema] || DEFAULT_RESULT)
+          else
+            result
           end
         end
       end
@@ -84,18 +88,34 @@ module Dry
         visit(node)
       end
 
+      def dump_messages(hash)
+        hash.each_with_object({}) do |(key, val), res|
+          res[key] =
+            case val
+            when Hash then dump_messages(val)
+            when Array then val.map(&:to_s)
+            end
+        end
+      end
+
       private
 
-      def merge_hints(messages)
+      def merge_hints(messages, hints = self.hints)
         messages.each_with_object({}) do |(name, msgs), res|
-          if msgs.is_a?(Hash)
-            res[name] = merge_hints(msgs)
-          else
-            all_msgs = msgs + (hints[name] || EMPTY_HINTS)
-            all_msgs.uniq!
-
-            res[name] = all_msgs
-          end
+          res[name] =
+            if msgs.is_a?(Hash)
+              res[name] = merge_hints(msgs, hints)
+            else
+              all_hints = (hints[name] || EMPTY_HINTS)
+
+              if all_hints.is_a?(Array)
+                all_msgs = msgs + all_hints
+                all_msgs.uniq!(&:signature)
+                all_msgs
+              else
+                msgs
+              end
+            end
         end
       end
 

data/lib/dry/validation/error_compiler/input.rb

@@ -1,6 +1,24 @@
+require 'dry/validation/deprecations'
+
 module Dry
   module Validation
+    Message = Struct.new(:rule, :predicate, :text) do
+      def to_s
+        text
+      end
+
+      def signature
+        @signature ||= [rule, predicate].hash
+      end
+
+      def eql?(other)
+        other.is_a?(String) ? text == other : super
+      end
+    end
+
     class ErrorCompiler::Input < ErrorCompiler
+      include Deprecations
+
       attr_reader :name, :input, :rule, :val_type
 
       def initialize(messages, options)
@@ -15,7 +33,7 @@ module Dry
         node.map { |el| visit(el) }
       end
 
-      def visit_set(node)
+      def visit_set(node, *)
         result = node.map do |input|
           visit(input)
         end
@@ -24,8 +42,8 @@ module Dry
 
       def visit_el(node)
         idx, el = node
-        name = [*Array(name), idx]
-        visit(el, name)
+        path = [*Array(name), idx]
+        input_visitor(path, input[idx]).visit(el)
       end
 
       def visit_check(node)
@@ -37,7 +55,7 @@ module Dry
         predicate, args = node
 
         lookup_options = options.merge(
-          rule: rule, val_type: val_type, arg_type: args[0].class
+          rule: rule, val_type: val_type, arg_type: args.size > 0 && args[0][1].class
         )
 
         tokens = options_for(predicate, args)
@@ -54,87 +72,56 @@ module Dry
             rule
           end
 
-        message =
+        text =
           if full?
-            "#{rule_name} #{template % tokens}"
+            "#{rule_name || tokens[:name]} #{template % tokens}"
           else
             template % tokens
           end
 
+        *arg_vals, _ = args.map(&:last)
+        message = Message.new(rule, [predicate, arg_vals], text)
         path = [[message], *[tokens[:name], *Array(name).reverse].uniq]
 
         path.reduce { |a, e| { e => a } }
       end
 
-      def options_for_type?(*args)
-        { type: args[0][0] }
-      end
-
-      def options_for_key?(*args)
-        { name: args[0][0] }
-      end
-
-      def options_for_attr?(*args)
-        { name: args[0][0] }
-      end
-
-      def options_for_exclusion?(*args)
-        { list: args[0][0].join(', ') }
-      end
-
-      def options_for_inclusion?(*args)
-        { list: args[0][0].join(', ') }
-      end
-
-      def options_for_gt?(*args)
-        { num: args[0][0], value: input }
-      end
-
-      def options_for_gteq?(*args)
-        { num: args[0][0], value: input }
-      end
-
-      def options_for_lt?(*args)
-        { num: args[0][0], value: input }
-      end
-
-      def options_for_lteq?(*args)
-        { num: args[0][0], value: input }
-      end
-
-      def options_for_int?(*args)
-        { num: args[0][0], value: input }
+      def options_for_inclusion?(args)
+        warn 'inclusion is deprecated - use included_in instead.'
+        options_for_included_in?(args)
       end
 
-      def options_for_max_size?(*args)
-        { num: args[0][0], value: input }
+      def options_for_exclusion?(args)
+        warn 'exclusion is deprecated - use excluded_from instead.'
+        options_for_excluded_from?(args)
       end
 
-      def options_for_min_size?(*args)
-        { num: args[0][0], value: input }
+      def options_for_excluded_from?(args)
+        { list: args[:list].join(', ') }
       end
 
-      def options_for_eql?(*args)
-        { eql_value: args[0][0], value: input }
+      def options_for_included_in?(args)
+        { list: args[:list].join(', ') }
       end
 
-      def options_for_size?(*args)
-        num = args[0][0]
+      def options_for_size?(args)
+        size = args[:size]
 
-        if num.is_a?(Range)
-          { left: num.first, right: num.last, value: input }
+        if size.is_a?(Range)
+          { left: size.first, right: size.last }
         else
-          { num: args[0][0], value: input }
+          args
         end
       end
 
       def options_for(predicate, args)
         meth = :"options_for_#{predicate}"
 
-        defaults = { name: rule, rule: rule, value: input }
+        args_map = Hash[args]
+        defaults = { name: rule, rule: rule, value: input }.update(args_map)
 
         if respond_to?(meth)
-          defaults.merge!(__send__(meth, args))
+          defaults.merge!(__send__(meth, args_map))
         end
 
         defaults

data/lib/dry/validation/hint_compiler.rb

@@ -5,7 +5,7 @@ module Dry
     class HintCompiler < ErrorCompiler::Input
       include Dry::Equalizer(:messages, :rules, :options)
 
-      attr_reader :rules, :excluded
+      attr_reader :rules, :excluded, :cache
 
       TYPES = {
         none?: NilClass,
@@ -23,25 +23,33 @@ module Dry
 
       EXCLUDED = [:none?, :filled?, :key?].freeze
 
+      DEFAULT_OPTIONS = { name: nil, input: nil, message_type: :hint }.freeze
+
+      EMPTY_MESSAGES = {}.freeze
+
       def self.cache
         @cache ||= Concurrent::Map.new
       end
 
       def initialize(messages, options = {})
-        super(messages, { name: nil, input: nil }.merge(options))
+        super(messages, DEFAULT_OPTIONS.merge(options))
         @rules = @options.delete(:rules)
         @excluded = @options.fetch(:excluded, EXCLUDED)
         @val_type = options[:val_type]
+        @cache = self.class.cache
+      end
+
+      def hash
+        @hash ||= [messages, rules, options].hash
       end
 
       def with(new_options)
+        return self if new_options.empty?
         super(new_options.merge(rules: rules))
       end
 
       def call
-        self.class.cache.fetch_or_store(hash) do
-          super(rules)
-        end
+        cache.fetch_or_store(hash) { super(rules) }
       end
 
       def visit_predicate(node)
@@ -50,7 +58,7 @@ module Dry
         val_type = TYPES[predicate]
 
         return with(val_type: val_type) if val_type
-        return {} if excluded.include?(predicate)
+        return EMPTY_MESSAGES if excluded.include?(predicate)
 
         super
       end
@@ -99,7 +107,7 @@ module Dry
       end
 
       def visit_schema(node)
-        DEFAULT_RESULT
+        merge(node.rule_ast.map(&method(:visit)))
       end
 
       def visit_check(node)

data/lib/dry/validation/input_processor_compiler.rb

@@ -27,13 +27,15 @@ module Dry
       def visit_type(type, *args)
         if type.is_a?(Types::Constructor)
           [:constructor, [type.primitive, type.fn]]
+        elsif type.respond_to?(:rule)
+          visit(type.rule.to_ast, *args)
         else
-          DEFAULT_TYPE_NODE
+          DEFAULT_TYPE_NODE.first
         end
       end
 
-      def visit_schema(node, *args)
-        hash_node(node.input_processor_ast(identifier))
+      def visit_schema(schema, *args)
+        hash_node(schema.input_processor_ast(identifier))
       end
 
       def visit_or(node, *args)
@@ -44,7 +46,12 @@ module Dry
       def visit_and(node, first = true)
         if first
           name, type = node.map { |n| visit(n, false) }.uniq
-          [:key, [name, type]]
+
+          if name.is_a?(Array)
+            type
+          else
+            [:key, [name, type]]
+          end
         else
           result = node.map { |n| visit(n, first) }.uniq
 
@@ -82,9 +89,9 @@ module Dry
         id, args = node
 
         if id == :key?
-          args[0]
+          args[0][1]
         else
-          type(id, args)
+          type(id, args.map(&:last))
         end
       end
 

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

@@ -5,6 +5,8 @@ module Dry
         default: 'string',
         none?: 'form.nil',
         bool?: 'form.bool',
+        true?: 'form.true',
+        false?: 'form.false',
         str?: 'string',
         int?: 'form.int',
         float?: 'form.float',

data/lib/dry/validation/input_processor_compiler/sanitizer.rb

@@ -37,7 +37,7 @@ module Dry
       end
 
       def hash_node(schema)
-        [:type, ['hash', [:schema, schema]]]
+        [:type, ['hash', [:weak, schema]]]
       end
 
       def array_node(members)