dry-validation 0.8.0 → 0.9.0

data/lib/dry/validation/message_set.rb

@@ -0,0 +1,70 @@
+require 'dry/validation/constants'
+
+module Dry
+  module Validation
+    class MessageSet
+      include Enumerable
+
+      attr_reader :messages, :hints, :paths, :placeholders
+
+      def self.[](messages)
+        new(messages.flatten)
+      end
+
+      def initialize(messages)
+        @messages = messages
+        @hints = {}
+        @paths = map(&:path).uniq
+        initialize_placeholders!
+      end
+
+      def empty?
+        messages.empty?
+      end
+
+      def each(&block)
+        return to_enum unless block
+        messages.each(&block)
+      end
+
+      def with_hints!(hints)
+        @hints = hints.group_by(&:index_path)
+        freeze
+      end
+
+      def to_h
+        reduce(placeholders) do |hash, msg|
+          if msg.root?
+            (hash[nil] ||= []) << msg.to_s
+          else
+            node = msg.path.reduce(hash) { |a, e| a[e] }
+            node << msg
+            node.concat(Array(hints[msg.index_path]))
+            node.uniq!(&:signature)
+            node.map!(&:to_s)
+          end
+          hash
+        end
+      end
+      alias_method :to_hash, :to_h
+
+      private
+
+      def initialize_placeholders!
+        @placeholders = paths.reduce({}) do |hash, path|
+          curr_idx = 0
+          last_idx = path.size - 1
+          node = hash
+
+          while curr_idx <= last_idx do
+            key = path[curr_idx]
+            node = (node[key] || node[key] = curr_idx < last_idx ? {} : [])
+            curr_idx += 1
+          end
+
+          hash
+        end
+      end
+    end
+  end
+end

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

@@ -98,7 +98,7 @@ module Dry
         end
 
         def cache
-          self.class.cache[self]
+          @cache ||= self.class.cache[self]
         end
       end
     end

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

@@ -20,6 +20,11 @@ module Dry
       def key?(key, options)
         ::I18n.exists?(key, options.fetch(:locale, I18n.default_locale))
       end
+
+      def merge(path)
+        ::I18n.load_path << path
+        self
+      end
     end
   end
 end

data/lib/dry/validation/predicate_registry.rb

@@ -5,8 +5,11 @@ module Dry
       attr_reader :external
 
       class Bound < PredicateRegistry
+        attr_reader :schema
+
         def initialize(*args)
-          super
+          super(*args[0..1])
+          @schema = args.last
           freeze
         end
       end
@@ -16,7 +19,7 @@ module Dry
           bound_predicates = predicates.each_with_object({}) do |(n, p), res|
             res[n] = p.bind(schema)
           end
-          Bound.new(external, bound_predicates)
+          Bound.new(external, bound_predicates, schema)
         end
 
         def update(other)
@@ -68,7 +71,9 @@ module Dry
         predicates.key?(name) || external.key?(name)
       end
 
-      def ensure_valid_predicate(name, args_or_arity)
+      def ensure_valid_predicate(name, args_or_arity, schema = nil)
+        return if schema && schema.instance_methods.include?(name)
+
         if name == :key?
           raise InvalidSchemaError, "#{name} is a reserved predicate name"
         end

data/lib/dry/validation/result.rb

@@ -41,17 +41,16 @@ module Dry
         @messages ||=
           begin
             return EMPTY_MESSAGES if success?
-
             hints = hint_compiler.with(options).call
-            comp = error_compiler.with(options.merge(hints: hints))
+            msg_set = error_compiler.with(options).(error_ast).with_hints!(hints)
 
-            messages = comp.(error_ast)
-            msg_hash = comp.dump_messages(messages)
+            as_hash = options.fetch(:as_hash, true)
 
-            if msg_hash.key?(nil)
-              msg_hash.values.flatten
+            if as_hash
+              hash = msg_set.to_h
+              hash.key?(nil) ? hash.values.flatten : hash
             else
-              msg_hash
+              msg_set
             end
           end
       end

data/lib/dry/validation/schema.rb

@@ -14,203 +14,15 @@ require 'dry/validation/error_compiler'
 require 'dry/validation/hint_compiler'
 
 require 'dry/validation/schema/deprecated'
+require 'dry/validation/schema/class_interface'
+require 'dry/validation/executor'
 
 module Dry
   module Validation
     class Schema
-      extend Dry::Configurable
+      attr_reader :config
 
-      NOOP_INPUT_PROCESSOR = -> input { input }
-
-      setting :path
-      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.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)
-        super(rules, default_options.merge(options))
-      end
-
-      def self.create_class(target, other = nil, &block)
-        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
-            Validation.Schema(target.schema_class, parent: target, build: false, &block)
-          end
-
-        klass.config.path = target.path if other
-        klass.config.input_processor = :noop
-
-        klass
-      end
-
-      def self.option(name, default = nil)
-        attr_reader(*name)
-        options.update(name => default)
-      end
-
-      def self.to_ast
-        [:schema, self]
-      end
-
-      def self.rules
-        config.rules
-      end
-
-      def self.options
-        config.options
-      end
-
-      def self.messages
-        default = default_messages
-
-        if config.messages_file && config.namespace
-          default.merge(config.messages_file).namespaced(config.namespace)
-        elsif config.messages_file
-          default.merge(config.messages_file)
-        elsif config.namespace
-          default.namespaced(config.namespace)
-        else
-          default
-        end
-      end
-
-      def self.default_messages
-        case config.messages
-        when :yaml then Messages.default
-        when :i18n then Messages::I18n.new
-        else
-          raise "+#{config.messages}+ is not a valid messages identifier"
-        end
-      end
-
-      def self.error_compiler
-        @error_compiler ||= ErrorCompiler.new(messages)
-      end
-
-      def self.hint_compiler
-        @hint_compiler ||= HintCompiler.new(messages, rules: rule_ast)
-      end
-
-      def self.rule_ast
-        @rule_ast ||= config.rules.map(&:to_ast)
-      end
-
-      def self.default_options
-        { predicate_registry: registry,
-          error_compiler: error_compiler,
-          hint_compiler: hint_compiler,
-          input_processor: input_processor,
-          checks: config.checks }
-      end
+      attr_reader :input_rule
 
       attr_reader :rules
 
@@ -230,18 +42,29 @@ module Dry
 
       attr_reader :type_map
 
+      attr_reader :executor
+
       def initialize(rules, options)
         @type_map = self.class.type_map
+        @config = self.class.config
         @predicates = options.fetch(:predicate_registry).bind(self)
-        @rule_compiler = SchemaCompiler.new(predicates)
+        @rule_compiler = SchemaCompiler.new(predicates, options)
         @error_compiler = options.fetch(:error_compiler)
         @hint_compiler = options.fetch(:hint_compiler)
-        @input_processor = options.fetch(:input_processor, NOOP_INPUT_PROCESSOR)
+        @input_processor = options[:input_processor]
+        @input_rule = rule_compiler.visit(config.input_rule.to_ast) if config.input_rule
 
         initialize_options(options)
         initialize_rules(rules)
         initialize_checks(options.fetch(:checks, []))
 
+        @executor = Executor.new(config.path) do |steps|
+          steps << ProcessInput.new(input_processor) if input_processor
+          steps << ApplyInputRule.new(input_rule) if input_rule
+          steps << ApplyRules.new(@rules)
+          steps << ApplyChecks.new(@checks) if @checks.any?
+        end
+
         freeze
       end
 
@@ -250,12 +73,12 @@ module Dry
       end
 
       def call(input)
-        processed_input = input_processor[input]
-        Result.new(processed_input, apply(processed_input), error_compiler, hint_compiler)
+        output, result = executor.(input)
+        Result.new(output, result, error_compiler, hint_compiler)
       end
 
-      def curry(*args)
-        to_proc.curry.(*args)
+      def curry(*curry_args)
+        -> *args { call(*(curry_args + args)) }
       end
 
       def to_proc
@@ -272,35 +95,6 @@ module Dry
 
       private
 
-      def apply(input)
-        results = rule_results(input)
-
-        results.merge!(check_results(input, results)) unless checks.empty?
-
-        results
-          .select { |_, result| result.failure? }
-          .map { |name, result| Error.new(error_path(name), result) }
-      end
-
-      def error_path(name)
-        full_path = Array[*self.class.config.path]
-        full_path << name
-        full_path.size > 1 ? full_path : full_path[0]
-      end
-
-      def rule_results(input)
-        rules.each_with_object({}) do |(name, rule), hash|
-          hash[name] = rule.(input)
-        end
-      end
-
-      def check_results(input, result)
-        checks.each_with_object({}) do |(name, check), hash|
-          check_res = check.is_a?(Guard) ? check.(input, result) : check.(input)
-          hash[name] = check_res if check_res
-        end
-      end
-
       def initialize_options(options)
         @options = options
 

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

@@ -23,7 +23,7 @@ module Dry
 
           keys = [name, *vals.map(&:name)]
 
-          registry.ensure_valid_predicate(meth, args.size + keys.size)
+          registry.ensure_valid_predicate(meth, args.size + keys.size, schema_class)
           predicate = registry[meth].curry(*args)
 
           rule = create_rule([:check, [name, predicate.to_ast, keys]])