dry-validation 0.7.4 → 0.8.0

data/lib/dry/validation/messages/abstract.rb

@@ -17,6 +17,9 @@ module Dry
         setting :lookup_paths, %w(
           %{root}.rules.%{rule}.%{predicate}.arg.%{arg_type}
           %{root}.rules.%{rule}.%{predicate}
+          %{root}.%{predicate}.%{message_type}
+          %{root}.%{predicate}.value.%{rule}.arg.%{arg_type}
+          %{root}.%{predicate}.value.%{rule}
           %{root}.%{predicate}.value.%{val_type}.arg.%{arg_type}
           %{root}.%{predicate}.value.%{val_type}
           %{root}.%{predicate}.arg.%{arg_type}
@@ -45,6 +48,10 @@ module Dry
           @config = self.class.config
         end
 
+        def hash
+          @hash ||= config.hash
+        end
+
         def rule(name, options = {})
           path = "%{locale}.rules.#{name}"
           get(path, options) if key?(path, options)
@@ -63,7 +70,8 @@ module Dry
             root: root,
             predicate: predicate,
             arg_type: config.arg_types[options[:arg_type]],
-            val_type: config.val_types[options[:val_type]]
+            val_type: config.val_types[options[:val_type]],
+            message_type: options[:message_type] || :failure
           )
 
           tokens[:rule] = predicate unless tokens.key?(:rule)

data/lib/dry/validation/predicate_registry.rb

@@ -0,0 +1,101 @@
+module Dry
+  module Validation
+    class PredicateRegistry
+      attr_reader :predicates
+      attr_reader :external
+
+      class Bound < PredicateRegistry
+        def initialize(*args)
+          super
+          freeze
+        end
+      end
+
+      class Unbound < PredicateRegistry
+        def bind(schema)
+          bound_predicates = predicates.each_with_object({}) do |(n, p), res|
+            res[n] = p.bind(schema)
+          end
+          Bound.new(external, bound_predicates)
+        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)
+          self
+        end
+      end
+
+      def self.[](klass, predicates)
+        Unbound.new(predicates).tap do |registry|
+          klass.class_eval do
+            def self.method_added(name)
+              super
+              if name.to_s.end_with?('?')
+                registry.update(name => instance_method(name))
+              end
+            end
+          end
+        end
+      end
+
+      def initialize(external, predicates = {})
+        @external = external
+        @predicates = predicates
+      end
+
+      def new(klass)
+        new_predicates = predicates
+          .keys
+          .each_with_object({}) { |key, res| res[key] = klass.instance_method(key) }
+
+        self.class.new(external).update(new_predicates)
+      end
+
+      def [](name)
+        predicates.fetch(name) do
+          if external.key?(name)
+            external[name]
+          else
+            raise_unknown_predicate_error(name)
+          end
+        end
+      end
+
+      def key?(name)
+        predicates.key?(name) || external.key?(name)
+      end
+
+      def ensure_valid_predicate(name, args_or_arity)
+        if name == :key?
+          raise InvalidSchemaError, "#{name} is a reserved predicate name"
+        end
+
+        if key?(name)
+          arity = self[name].arity
+
+          case args_or_arity
+          when Array
+            raise_invalid_arity_error(name) if ![0, args_or_arity.size + 1].include?(arity)
+          when Fixnum
+            raise_invalid_arity_error(name) if args_or_arity != arity
+          end
+        else
+          raise_unknown_predicate_error(name)
+        end
+      end
+
+      private
+
+      def raise_unknown_predicate_error(name)
+        raise ArgumentError, "+#{name}+ is not a valid predicate name"
+      end
+
+      def raise_invalid_arity_error(name)
+        raise ArgumentError, "#{name} predicate arity is invalid"
+      end
+    end
+  end
+end

data/lib/dry/validation/result.rb

@@ -45,7 +45,14 @@ module Dry
             hints = hint_compiler.with(options).call
             comp = error_compiler.with(options.merge(hints: hints))
 
-            comp.(error_ast)
+            messages = comp.(error_ast)
+            msg_hash = comp.dump_messages(messages)
+
+            if msg_hash.key?(nil)
+              msg_hash.values.flatten
+            else
+              msg_hash
+            end
           end
       end
 

data/lib/dry/validation/schema.rb

@@ -1,8 +1,9 @@
+require 'dry/logic/predicates'
 require 'dry/types/constraints'
 
+require 'dry/validation/predicate_registry'
 require 'dry/validation/schema_compiler'
 require 'dry/validation/schema/key'
-require 'dry/validation/schema/attr'
 require 'dry/validation/schema/value'
 require 'dry/validation/schema/check'
 
@@ -12,7 +13,7 @@ require 'dry/validation/messages'
 require 'dry/validation/error_compiler'
 require 'dry/validation/hint_compiler'
 
-require 'dry/validation/input_processor_compiler'
+require 'dry/validation/schema/deprecated'
 
 module Dry
   module Validation
@@ -22,24 +23,109 @@ module Dry
       NOOP_INPUT_PROCESSOR = -> input { input }
 
       setting :path
-      setting :predicates, Types::Predicates
+      setting :predicates, Logic::Predicates
+      setting :registry
       setting :messages, :yaml
       setting :messages_file
       setting :namespace
       setting :rules, []
       setting :checks, []
+      setting :options, {}
+      setting :type_map, {}
+      setting :hash_type, :weak
+      setting :input, nil
+      setting :dsl_extensions, nil
 
       setting :input_processor, :noop
-
       setting :input_processor_map, {
         sanitizer: InputProcessorCompiler::Sanitizer.new,
         json: InputProcessorCompiler::JSON.new,
         form: InputProcessorCompiler::Form.new,
       }.freeze
 
+      setting :type_specs, false
+
       def self.inherited(klass)
         super
-        klass.setting :options, {}
+        klass.config.options = klass.config.options.dup
+
+        if registry && self != Schema
+          klass.config.registry = registry.new(self)
+        else
+          klass.set_registry!
+        end
+      end
+
+      def self.clone
+        klass = Class.new(self)
+        klass.config.rules = []
+        klass.config.registry = registry
+        klass
+      end
+
+      def self.set_registry!
+        config.registry = PredicateRegistry[self, config.predicates]
+      end
+
+      def self.registry
+        config.registry
+      end
+
+      def self.build_array_type(spec, category)
+        member_schema = build_type_map(spec, category)
+        member_type = lookup_type("hash", category)
+          .public_send(config.hash_type, member_schema)
+
+        lookup_type("array", category).member(member_type)
+      end
+
+      def self.build_type_map(type_specs, category = config.input_processor)
+        if type_specs.is_a?(Array)
+          build_array_type(type_specs[0], category)
+        else
+          type_specs.each_with_object({}) do |(name, spec), result|
+            result[name] =
+              case spec
+              when Hash
+                lookup_type("hash", category).public_send(config.hash_type, spec)
+              when Array
+                if spec.size == 1
+                  if spec[0].is_a?(Hash)
+                    build_array_type(spec[0], category)
+                  else
+                    lookup_type("array", category).member(lookup_type(spec[0], category))
+                  end
+                else
+                  spec
+                    .map { |id| id.is_a?(Symbol) ? lookup_type(id, category) : id }
+                    .reduce(:|)
+                end
+              when Symbol
+                lookup_type(spec, category)
+              else
+                spec
+              end
+          end
+        end
+      end
+
+      def self.lookup_type(name, category)
+        id = "#{category}.#{name}"
+        Types.type_keys.include?(id) ? Types[id] : Types[name.to_s]
+      end
+
+
+      def self.type_map
+        config.type_map
+      end
+
+      def self.predicates(predicate_set = nil)
+        if predicate_set
+          config.predicates = predicate_set
+          set_registry!
+        else
+          config.predicates
+        end
       end
 
       def self.new(rules = config.rules, **options)
@@ -52,8 +138,10 @@ module Dry
             Class.new(other.class)
           elsif other.is_a?(Class) && other < Types::Struct
             Validation.Schema(parent: target, build: false) do
-              other.schema.each { |attr, type| key(attr).required(type) }
+              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
             Validation.Schema(target.schema_class, parent: target, build: false, &block)
           end
@@ -77,10 +165,6 @@ module Dry
         config.rules
       end
 
-      def self.predicates
-        config.predicates
-      end
-
       def self.options
         config.options
       end
@@ -116,31 +200,12 @@ module Dry
         @hint_compiler ||= HintCompiler.new(messages, rules: rule_ast)
       end
 
-      def self.input_processor
-        @input_processor ||=
-          begin
-            if input_processor_compiler
-              input_processor_compiler.(rule_ast)
-            else
-              NOOP_INPUT_PROCESSOR
-            end
-          end
-      end
-
-      def self.input_processor_ast(type)
-        config.input_processor_map.fetch(type).schema_ast(rule_ast)
-      end
-
-      def self.input_processor_compiler
-        @input_processor_comp ||= config.input_processor_map[config.input_processor]
-      end
-
       def self.rule_ast
-        @rule_ast ||= config.rules.flat_map(&:rules).map(&:to_ast)
+        @rule_ast ||= config.rules.map(&:to_ast)
       end
 
       def self.default_options
-        { predicates: predicates,
+        { predicate_registry: registry,
           error_compiler: error_compiler,
           hint_compiler: hint_compiler,
           input_processor: input_processor,
@@ -163,11 +228,14 @@ module Dry
 
       attr_reader :options
 
+      attr_reader :type_map
+
       def initialize(rules, options)
-        @rule_compiler = SchemaCompiler.new(self)
+        @type_map = self.class.type_map
+        @predicates = options.fetch(:predicate_registry).bind(self)
+        @rule_compiler = SchemaCompiler.new(predicates)
         @error_compiler = options.fetch(:error_compiler)
         @hint_compiler = options.fetch(:hint_compiler)
-        @predicates = options.fetch(:predicates)
         @input_processor = options.fetch(:input_processor, NOOP_INPUT_PROCESSOR)
 
         initialize_options(options)
@@ -186,22 +254,20 @@ module Dry
         Result.new(processed_input, apply(processed_input), error_compiler, hint_compiler)
       end
 
-      def [](name)
-        if predicates.key?(name)
-          predicates[name]
-        elsif respond_to?(name)
-          Logic::Predicate.new(name, &method(name))
-        else
-          raise ArgumentError, "+#{name}+ is not a valid predicate name"
-        end
-      end
-
       def curry(*args)
         to_proc.curry.(*args)
       end
 
       def to_proc
-        -> input { self.call(input) }
+        -> input { call(input) }
+      end
+
+      def arity
+        1
+      end
+
+      def to_ast
+        self.class.to_ast
       end
 
       private

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

@@ -22,9 +22,11 @@ module Dry
           vals, args = meth_args.partition { |arg| arg.class < DSL }
 
           keys = [name, *vals.map(&:name)]
-          predicate = [:predicate, [meth, args]]
 
-          rule = create_rule([:check, [name, predicate, keys]])
+          registry.ensure_valid_predicate(meth, args.size + keys.size)
+          predicate = registry[meth].curry(*args)
+
+          rule = create_rule([:check, [name, predicate.to_ast, keys]])
           add_rule(rule)
           rule
         end

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

@@ -0,0 +1,31 @@
+require 'dry/validation/input_processor_compiler'
+
+module Dry
+  module Validation
+    class Schema
+      def self.input_processor
+        @input_processor ||=
+          begin
+            if type_map.is_a?(Dry::Types::Safe) && config.input_processor != :noop
+              type_map
+            elsif type_map.size > 0 && config.input_processor != :noop
+              lookup_type("hash", config.input_processor)
+                .public_send(config.hash_type, type_map)
+            elsif input_processor_compiler
+              input_processor_compiler.(rule_ast)
+            else
+              NOOP_INPUT_PROCESSOR
+            end
+          end
+      end
+
+      def self.input_processor_ast(type)
+        config.input_processor_map.fetch(type).schema_ast(rule_ast)
+      end
+
+      def self.input_processor_compiler
+        @input_processor_comp ||= config.input_processor_map[config.input_processor]
+      end
+    end
+  end
+end

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

@@ -1,10 +1,13 @@
 require 'dry/validation/schema/rule'
+require 'dry/validation/deprecations'
 
 module Dry
   module Validation
     class Schema
       class DSL < BasicObject
-        attr_reader :name, :rules, :checks, :parent, :options
+        include ::Dry::Validation::Deprecations
+
+        attr_reader :name, :registry, :rules, :checks, :parent, :options
 
         def self.[](name, options = {})
           new(options.merge(name: name))
@@ -13,6 +16,7 @@ module Dry
         def initialize(options = {})
           @name = options[:name]
           @parent = options[:parent]
+          @registry = options.fetch(:registry)
           @rules = options.fetch(:rules, [])
           @checks = options.fetch(:checks, [])
           @options = options
@@ -23,16 +27,14 @@ module Dry
         end
         alias_method :to_s, :inspect
 
-        def key(name, &block)
-          define(name, Key, &block)
-        end
+        def optional(name, type_spec = nil, &block)
+          rule = define(name, Key, :then, &block)
 
-        def optional(name, &block)
-          define(name, Key, :then, &block)
-        end
+          if type_spec
+            type_map[name] = type_spec
+          end
 
-        def attr(name, &block)
-          define(name, Attr, &block)
+          rule
         end
 
         def not
@@ -73,17 +75,22 @@ module Dry
           self.class.new(options.merge(new_options))
         end
 
+        def predicate?(meth)
+          registry.key?(meth)
+        end
+
         private
 
         def define(name, key_class, op = :and, &block)
           type = key_class.type
 
           val = Value[
-            name, type: type, parent: self, rules: rules, checks: checks
+            name, registry: registry, type: type, parent: self, rules: rules,
+            checks: checks, schema_class: schema_class.clone
           ].__send__(:"#{type}?", name)
 
           if block
-            key = key_class[name]
+            key = key_class[name, registry: registry]
             res = key.instance_eval(&block)
 
             if res.class == Value