dry-validation 0.9.5 → 0.10.0

data/lib/dry/validation/message_set.rb

@@ -1,20 +1,27 @@
-require 'dry/validation/constants'
+require 'dry/core/constants'
 
 module Dry
   module Validation
     class MessageSet
+      include Core::Constants
       include Enumerable
 
-      attr_reader :messages, :hints, :paths, :placeholders
+      HINT_EXCLUSION = %i(key? filled? none? bool? str? int? float? decimal? date? date_time? time? hash? array?).freeze
 
-      def self.[](messages)
-        new(messages.flatten)
+      attr_reader :messages, :failures, :hints, :paths, :placeholders, :options
+
+      def self.[](messages, options = EMPTY_HASH)
+        new(messages.flatten, options)
       end
 
-      def initialize(messages)
+      def initialize(messages, options = EMPTY_HASH)
         @messages = messages
-        @hints = {}
-        @paths = map(&:path).uniq
+        @hints = messages.select(&:hint?)
+        @failures = messages - hints
+        @paths = failures.map(&:path).uniq
+        @options = options
+
+        initialize_hints!
         initialize_placeholders!
       end
 
@@ -22,12 +29,16 @@ module Dry
         root? ? to_a : to_h
       end
 
+      def failures?
+        options[:failures].equal?(true)
+      end
+
       def empty?
         messages.empty?
       end
 
       def root?
-        !empty? && messages.all?(&:root?)
+        !empty? && failures.all?(&:root?)
       end
 
       def each(&block)
@@ -35,41 +46,59 @@ module Dry
         messages.each(&block)
       end
 
-      def with_hints!(hints)
-        @hints.update(hints.group_by(&:index_path))
-        self
-      end
-
       def to_h
         if root?
-          { nil => map(&:to_s) }
+          { nil => failures.map(&:to_s) }
         else
-          group_by(&:path).reduce(placeholders) do |hash, (path, msgs)|
-            node = path.reduce(hash) { |a, e| a[e] }
+          failures? ? messages_map : hints_map
+        end
+      end
+      alias_method :to_hash, :to_h
+
+      def to_a
+        to_h.values.flatten
+      end
+
+      private
 
-            msgs.each do |msg|
-              node << msg
-              msg_hints = hints[msg.index_path]
+      def messages_map
+        failures.group_by(&:path).reduce(placeholders) do |hash, (path, msgs)|
+          node = path.reduce(hash) { |a, e| a[e] }
 
-              if msg_hints
-                node.concat(msg_hints)
-                node.uniq!(&:signature)
-              end
-            end
+          msgs.each do |msg|
+            node << msg
 
-            node.map!(&:to_s)
+            msg_hints = hint_groups[msg.path]
+            node.concat(msg_hints) if msg_hints
+          end
+
+          node.map!(&:to_s)
+
+          hash
+        end
+      end
 
-            hash
+      def hints_map
+        hints.group_by(&:path).reduce(placeholders) do |hash, (path, msgs)|
+          node = path.reduce(hash) { |a, e| a[e] }
+
+          msgs.each do |msg|
+            node << msg
           end
+
+          node.map!(&:to_s)
+
+          hash
         end
       end
-      alias_method :to_hash, :to_h
 
-      def to_a
-        to_h.values.flatten
+      def hint_groups
+        @hint_groups ||= hints.group_by(&:path)
       end
 
-      private
+      def initialize_hints!
+        hints.reject! { |hint| HINT_EXCLUSION.include?(hint.predicate) }
+      end
 
       def initialize_placeholders!
         @placeholders = paths.reduce({}) do |hash, path|

data/lib/dry/validation/predicate_registry.rb

@@ -1,6 +1,11 @@
+require 'dry/core/constants'
+require 'dry/logic/rule/predicate'
+
 module Dry
   module Validation
     class PredicateRegistry
+      include Core::Constants
+
       attr_reader :predicates
       attr_reader :external
 
@@ -23,10 +28,7 @@ module Dry
         end
 
         def update(other)
-          unbound_predicates = other.each_with_object({}) { |(n, p), res|
-            res[n] = Logic::Predicate.new(n, fn: p)
-          }
-          predicates.update(unbound_predicates)
+          predicates.update(other)
           self
         end
       end
@@ -59,7 +61,7 @@ module Dry
 
       def [](name)
         predicates.fetch(name) do
-          if external.key?(name)
+          if external.public_methods.include?(name)
             external[name]
           else
             raise_unknown_predicate_error(name)
@@ -68,7 +70,16 @@ module Dry
       end
 
       def key?(name)
-        predicates.key?(name) || external.key?(name)
+        predicates.key?(name) || external.public_methods.include?(name)
+      end
+
+      def arg_list(name, *values)
+        predicate = self[name]
+
+        predicate
+          .parameters
+          .map(&:last)
+          .zip(values + Array.new(predicate.arity - values.size, Undefined))
       end
 
       def ensure_valid_predicate(name, args_or_arity, schema = nil)

data/lib/dry/validation/result.rb

@@ -1,25 +1,25 @@
-require 'dry/validation/constants'
+require 'dry/core/constants'
 
 module Dry
   module Validation
     class Result
-      include Dry::Equalizer(:output, :messages)
+      include Core::Constants
+      include Dry::Equalizer(:output, :errors)
       include Enumerable
 
       attr_reader :output
-      attr_reader :errors
-      attr_reader :error_compiler
-      attr_reader :hint_compiler
+      attr_reader :results
+      attr_reader :message_compiler
+      attr_reader :path
 
       alias_method :to_hash, :output
       alias_method :to_h, :output # for MRI 2.0, remove it when drop support
 
-      def initialize(output, errors, error_compiler, hint_compiler)
+      def initialize(output, results, message_compiler, path)
         @output = output
-        @errors = errors
-        @error_compiler = error_compiler
-        @hint_compiler = hint_compiler
-        @messages = EMPTY_HASH if success?
+        @results = results
+        @message_compiler = message_compiler
+        @path = path
       end
 
       def each(&block)
@@ -31,7 +31,7 @@ module Dry
       end
 
       def success?
-        errors.empty?
+        results.empty?
       end
 
       def failure?
@@ -42,20 +42,42 @@ module Dry
         message_set(options).dump
       end
 
+      def errors(options = EMPTY_HASH)
+        message_set(options.merge(hints: false)).dump
+      end
+
+      def hints(options = EMPTY_HASH)
+        message_set(options.merge(failures: false)).dump
+      end
+
       def message_set(options = EMPTY_HASH)
-        error_compiler
-          .with(options).(error_ast)
-          .with_hints!(hint_compiler.with(options).())
+        message_compiler.with(options).(result_ast)
       end
 
       def to_ast
-        [:set, error_ast]
+        if name
+          [type, [name, [:set, result_ast]]]
+        else
+          ast
+        end
+      end
+
+      def ast(*)
+        [:set, result_ast]
+      end
+
+      def name
+        Array(path).last
       end
 
       private
 
-      def error_ast
-        @error_ast ||= errors.map { |error| error.to_ast }
+      def type
+        success? ? :success : :failure
+      end
+
+      def result_ast
+        @result_ast ||= results.map(&:to_ast)
       end
     end
   end

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

@@ -13,7 +13,7 @@ module Dry
             schema.config.input_processor = other.class.config.input_processor
           end
 
-          hash?.and(create_rule([:check, [name, schema.to_ast], [path]]))
+          hash?.and(create_rule([:check, [[path], schema.to_ast]]))
         end
 
         private
@@ -21,12 +21,13 @@ module Dry
         def method_missing(meth, *meth_args)
           vals, args = meth_args.partition { |arg| arg.class < DSL }
 
-          keys = [name, *vals.map(&:name)]
+          keys = [path, vals.map(&:path)].reject(&:empty?)
 
           registry.ensure_valid_predicate(meth, args.size + keys.size, schema_class)
-          predicate = registry[meth].curry(*args)
+          predicate = predicate(meth, args)
+
+          rule = create_rule([:check, [keys.reverse, predicate]], name)
 
-          rule = create_rule([:check, [name, predicate.to_ast, keys]])
           add_rule(rule)
           rule
         end

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

@@ -48,7 +48,9 @@ module Dry
         target = dsl.schema_class
 
         if config.input
-          config.input_rule = dsl.infer_predicates(Array(target.config.input))
+          config.input_rule = -> predicates {
+            Schema::Value.new(registry: predicates).infer_predicates(Array(target.config.input)).to_ast
+          }
         end
 
         rules = target.config.rules + (options.fetch(:rules, []) + dsl.rules)
@@ -85,10 +87,6 @@ module Dry
         klass =
           if other.is_a?(self)
             Class.new(other.class)
-          elsif other.is_a?(Class) && other < Types::Struct
-            Validation.Schema(parent: target, build: false) do
-              other.schema.each { |attr, type| required(attr).filled(type) }
-            end
           elsif other.respond_to?(:schema) && other.schema.is_a?(self)
             Class.new(other.schema.class)
           else
@@ -151,12 +149,8 @@ module Dry
         end
       end
 
-      def self.error_compiler
-        @error_compiler ||= ErrorCompiler.new(messages)
-      end
-
-      def self.hint_compiler
-        @hint_compiler ||= HintCompiler.new(messages, rules: rule_ast)
+      def self.message_compiler
+        @message_compiler ||= MessageCompiler.new(messages)
       end
 
       def self.rule_ast
@@ -165,8 +159,7 @@ module Dry
 
       def self.default_options
         @default_options ||= { predicate_registry: registry,
-          error_compiler: error_compiler,
-          hint_compiler: hint_compiler,
+          message_compiler: message_compiler,
           input_processor: input_processor,
           checks: config.checks }
       end

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

@@ -6,6 +6,7 @@ module Dry
     class Schema
       class DSL < BasicObject
         include ::Dry::Validation::Deprecations
+        include ::Dry::Core::Constants
 
         attr_reader :name, :registry, :rules, :checks, :parent, :options
 
@@ -15,6 +16,7 @@ module Dry
 
         def initialize(options = {})
           @name = options[:name]
+          @path = options.fetch(:path, name)
           @parent = options[:parent]
           @registry = options.fetch(:registry)
           @rules = options.fetch(:rules, [])
@@ -49,7 +51,7 @@ module Dry
         end
 
         def add_check(check)
-          checks << check
+          checks << check.to_rule
           self
         end
 
@@ -67,7 +69,7 @@ module Dry
         end
 
         def path
-          items = [parent && parent.path, name].flatten.compact.uniq
+          items = [parent && parent.path, *@path].flatten.compact.uniq
           items.size == 1 ? items[0] : items
         end
 
@@ -75,6 +77,10 @@ module Dry
           self.class.new(options.merge(new_options))
         end
 
+        def predicate(name, args = EMPTY_ARRAY)
+          [:predicate, [name, registry.arg_list(name, *args)]]
+        end
+
         def predicate?(meth)
           registry.key?(meth)
         end
@@ -104,7 +110,7 @@ module Dry
           end
         end
 
-        def create_rule(node)
+        def create_rule(node, name = self.name)
           Schema::Rule.new(node, name: name, target: self)
         end
       end

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

@@ -3,10 +3,19 @@ require 'dry/validation/schema'
 module Dry
   module Validation
     class Schema::Form < Schema
-      configure do |config|
-        config.input_processor = :form
-        config.hash_type = :symbolized
+      def self.configure(klass = nil, &block)
+        if klass
+          klass.configure do |config|
+            config.input_processor = :form
+            config.hash_type = :symbolized
+          end
+          klass
+        else
+          super(&block)
+        end
       end
+
+      configure(self)
     end
   end
 end

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

@@ -3,10 +3,19 @@ require 'dry/validation/schema'
 module Dry
   module Validation
     class Schema::JSON < Schema
-      configure do |config|
-        config.input_processor = :json
-        config.hash_type = :symbolized
+      def self.configure(klass = nil, &block)
+        if klass
+          klass.configure do |config|
+            config.input_processor = :json
+            config.hash_type = :symbolized
+          end
+          klass
+        else
+          super(&block)
+        end
       end
+
+      configure(self)
     end
   end
 end