dry-validation 0.8.0 → 0.9.0

data/lib/dry/validation/executor.rb

@@ -0,0 +1,105 @@
+module Dry
+  module Validation
+    class ProcessInput
+      attr_reader :processor
+
+      def initialize(processor)
+        @processor = processor
+      end
+
+      def call(input, *)
+        processor.(input)
+      end
+    end
+
+    class ApplyInputRule
+      attr_reader :rule
+
+      def initialize(rule)
+        @rule = rule
+      end
+
+      def call(input, result)
+        rule_res = rule.(input)
+        result.update(nil => rule_res) unless rule_res.success?
+        input
+      end
+    end
+
+    class ApplyRules
+      attr_reader :rules
+
+      def initialize(rules)
+        @rules = rules
+      end
+
+      def call(input, result)
+        rules.each_with_object(result) do |(name, rule), hash|
+          hash[name] = rule.(input)
+        end
+        input
+      end
+    end
+
+    class ApplyChecks < ApplyRules
+      def call(input, result)
+        rules.each_with_object(result) do |(name, check), hash|
+          check_res = check.is_a?(Guard) ? check.(input, result) : check.(input)
+          hash[name] = check_res if check_res
+        end
+        input
+      end
+    end
+
+    class BuildErrors
+      attr_reader :path
+
+      def self.[](path)
+        path.nil? || path.empty? ? Flat.new : Nested.new(path)
+      end
+
+      class Flat < BuildErrors
+        def error_path(name)
+          name
+        end
+      end
+
+      class Nested < BuildErrors
+        def initialize(path)
+          @path = path
+        end
+
+        def error_path(name)
+          [*path, name]
+        end
+      end
+
+      def call(result)
+        result
+          .select { |_, r| r.failure? }
+          .map { |name, r| Error.new(error_path(name), r) }
+      end
+    end
+
+    class Executor
+      attr_reader :steps, :final
+
+      def self.new(path, &block)
+        super(BuildErrors[path]).tap { |executor| yield(executor.steps) }.freeze
+      end
+
+      def initialize(final)
+        @steps = []
+        @final = final
+      end
+
+      def call(input, result = {})
+        output = steps.reduce(input) do |a, e|
+          return [a, final.(result)] if result.key?(nil)
+          e.call(a, result)
+        end
+        [output, final.(result)]
+      end
+    end
+  end
+end

data/lib/dry/validation/hint_compiler.rb

@@ -1,8 +1,8 @@
-require 'dry/validation/error_compiler/input'
+require 'dry/validation/message_compiler'
 
 module Dry
   module Validation
-    class HintCompiler < ErrorCompiler::Input
+    class HintCompiler < MessageCompiler
       include Dry::Equalizer(:messages, :rules, :options)
 
       attr_reader :rules, :excluded, :cache
@@ -21,115 +21,83 @@ module Dry
         array?: Array
       }.freeze
 
-      EXCLUDED = [:none?, :filled?, :key?].freeze
-
-      DEFAULT_OPTIONS = { name: nil, input: nil, message_type: :hint }.freeze
-
-      EMPTY_MESSAGES = {}.freeze
+      EXCLUDED = (%i(key? none? filled?) + TYPES.keys).freeze
 
       def self.cache
         @cache ||= Concurrent::Map.new
       end
 
       def initialize(messages, options = {})
-        super(messages, DEFAULT_OPTIONS.merge(options))
-        @rules = @options.delete(:rules)
-        @excluded = @options.fetch(:excluded, EXCLUDED)
-        @val_type = options[:val_type]
+        super(messages, options)
+        @rules = options.fetch(:rules, EMPTY_ARRAY)
+        @excluded = options.fetch(:excluded, EXCLUDED)
         @cache = self.class.cache
       end
 
-      def hash
-        @hash ||= [messages, rules, options].hash
+      def message_type
+        :hint
       end
 
-      def with(new_options)
-        return self if new_options.empty?
-        super(new_options.merge(rules: rules))
+      def message_class
+        Hint
       end
 
-      def call
-        cache.fetch_or_store(hash) { super(rules) }
-      end
-
-      def visit_predicate(node)
-        predicate, _ = node
-
-        val_type = TYPES[predicate]
-
-        return with(val_type: val_type) if val_type
-        return EMPTY_MESSAGES if excluded.include?(predicate)
-
-        super
+      def hash
+        @hash ||= [messages, rules, options].hash
       end
 
-      def visit_set(node)
-        result = node.map do |el|
-          visit(el)
-        end
-        merge(result)
+      def call
+        cache.fetch_or_store(hash) { super(rules) }
       end
 
-      def visit_each(node)
-        visit(node)
+      def visit_predicate(node, opts = EMPTY_HASH)
+        predicate, args = node
+        return EMPTY_ARRAY if excluded.include?(predicate) || dyn_args?(args)
+        super(node, opts.merge(val_type: TYPES[predicate]))
       end
 
-      def visit_or(node)
-        left, right = node
-        merge([visit(left), visit(right)])
+      def visit_each(node, opts = EMPTY_HASH)
+        visit(node, opts.merge(each: true))
       end
 
-      def visit_and(node)
+      def visit_or(node, *args)
         left, right = node
-
-        result = visit(left)
-
-        if result.is_a?(self.class)
-          result.visit(right)
-        else
-          visit(right)
-        end
+        [Array[visit(left, *args)], Array[visit(right, *args)]].flatten
       end
 
-      def visit_implication(node)
+      def visit_and(node, *args)
         _, right = node
-        visit(right)
+        visit(right, *args)
       end
 
-      def visit_key(node)
-        name, predicate = node
-        with(name: Array([*self.name, name])).visit(predicate)
-      end
-      alias_method :visit_attr, :visit_key
-
-      def visit_val(node)
-        visit(node)
-      end
+      def visit_schema(node, opts = EMPTY_HASH)
+        path = node.config.path
+        rules = node.rule_ast
+        schema_opts = opts.merge(path: [path])
 
-      def visit_schema(node)
-        merge(node.rule_ast.map(&method(:visit)))
+        rules.map { |rule| visit(rule, schema_opts) }
       end
 
       def visit_check(node)
-        DEFAULT_RESULT
+        EMPTY_ARRAY
       end
 
       def visit_xor(node)
-        DEFAULT_RESULT
+        EMPTY_ARRAY
       end
 
       def visit_not(node)
-        DEFAULT_RESULT
+        EMPTY_ARRAY
       end
 
-      def visit_type(node)
-        visit(node.rule.to_ast)
+      def visit_type(node, *args)
+        visit(node.rule.to_ast, *args)
       end
 
       private
 
-      def merge(result)
-        super(result.reject { |el| el.is_a?(self.class) })
+      def dyn_args?(args)
+        args.map(&:last).any? { |a| a.is_a?(UnboundMethod) }
       end
     end
   end

data/lib/dry/validation/message.rb

@@ -0,0 +1,86 @@
+require 'dry/validation/constants'
+
+module Dry
+  module Validation
+    class Message
+      include Dry::Equalizer(:predicate, :path, :text, :options)
+
+      Index = Class.new {
+        def inspect
+          "index"
+        end
+        alias_method :to_s, :inspect
+      }.new
+
+      attr_reader :predicate, :path, :text, :rule, :args, :options
+
+      class Each < Message
+        def index_path
+          @index_path ||= [*path[0..path.size-2], Index]
+        end
+
+        def each?
+          true
+        end
+      end
+
+      def self.[](predicate, path, text, options)
+        klass = options[:each] ? Message::Each : Message
+        klass.new(predicate, path, text, options)
+      end
+
+      def initialize(predicate, path, text, options)
+        @predicate = predicate
+        @path = path
+        @text = text
+        @options = options
+        @rule = options[:rule]
+        @each = options[:each] || false
+        @args = options[:args] || EMPTY_ARRAY
+      end
+
+      alias_method :index_path, :path
+
+      def to_s
+        text
+      end
+
+      def signature
+        @signature ||= [predicate, args, index_path].hash
+      end
+
+      def each?
+        @each
+      end
+
+      def hint?
+        false
+      end
+
+      def root?
+        path.empty?
+      end
+
+      def eql?(other)
+        other.is_a?(String) ? text == other : super
+      end
+    end
+
+    class Hint < Message
+      def self.[](predicate, path, text, options)
+        klass = options[:each] ? Hint::Each : Hint
+        klass.new(predicate, path, text, options)
+      end
+
+      class Each < Hint
+        def index_path
+          @index_path ||= [*path, Index]
+        end
+      end
+
+      def hint?
+        true
+      end
+    end
+  end
+end

data/lib/dry/validation/message_compiler.rb

@@ -0,0 +1,141 @@
+require 'dry/validation/constants'
+require 'dry/validation/message'
+require 'dry/validation/message_set'
+
+module Dry
+  module Validation
+    class MessageCompiler
+      attr_reader :messages, :options, :locale, :default_lookup_options
+
+      def initialize(messages, options = {})
+        @messages = messages
+        @options = options
+        @full = @options.fetch(:full, false)
+        @locale = @options.fetch(:locale, :en)
+        @default_lookup_options = { message_type: message_type, locale: locale }
+      end
+
+      def call(ast)
+        MessageSet[ast.map { |node| visit(node) }]
+      end
+
+      def full?
+        @full
+      end
+
+      def with(new_options)
+        return self if new_options.empty?
+        self.class.new(messages, options.merge(new_options))
+      end
+
+      def visit(node, *args)
+        __send__(:"visit_#{node[0]}", node[1], *args)
+      end
+
+      def visit_predicate(node, base_opts = EMPTY_HASH)
+        predicate, args = node
+
+        *arg_vals, _ = args.map(&:last)
+
+        tokens = message_tokens(args)
+
+        if base_opts[:message] == false
+          return [predicate, arg_vals, tokens]
+        end
+
+        options = base_opts.update(lookup_options(base_opts, arg_vals))
+        msg_opts = options.update(tokens)
+
+        name = msg_opts[:name]
+        rule = msg_opts[:rule] || name
+
+        template = messages[predicate, msg_opts]
+
+        unless template
+          raise MissingMessageError, "message for #{predicate} was not found"
+        end
+
+        text = message_text(rule, template, tokens, options)
+        path = message_path(msg_opts, name)
+
+        message_class[
+          predicate, path, text,
+          args: arg_vals, rule: rule, each: base_opts[:each] == true
+        ]
+      end
+
+      def visit_key(node, opts = EMPTY_HASH)
+        name, predicate = node
+        visit(predicate, opts.merge(name: name))
+      end
+
+      def visit_val(node, opts = EMPTY_HASH)
+        visit(node, opts)
+      end
+
+      def visit_set(node, opts = EMPTY_HASH)
+        node.map { |input| visit(input, opts) }
+      end
+
+      def visit_el(node, opts = EMPTY_HASH)
+        idx, el = node
+        visit(el, opts.merge(path: opts[:path] + [idx]))
+      end
+
+      def visit_implication(node, *args)
+        _, right = node
+        visit(right, *args)
+      end
+
+      def visit_xor(node, *args)
+        _, right = node
+        visit(right, *args)
+      end
+
+      def lookup_options(_opts, arg_vals = [])
+        default_lookup_options.merge(
+          arg_type: arg_vals.size == 1 && arg_vals[0].class
+        )
+      end
+
+      def message_text(rule, template, tokens, opts)
+        text = template % tokens
+
+        if full?
+          rule_name = messages.rule(rule, opts) || rule
+          "#{rule_name} #{text}"
+        else
+          text
+        end
+      end
+
+      def message_path(opts, name)
+        if name.is_a?(Array)
+          name
+        else
+          path = opts[:path] || Array(name)
+
+          if name && path.last != name
+            path += [name]
+          end
+
+          path
+        end
+      end
+
+      def message_tokens(args)
+        args.each_with_object({}) { |arg, hash|
+          case arg[1]
+          when Array
+            hash[arg[0]] = arg[1].join(', ')
+          when Range
+            hash["#{arg[0]}_left".to_sym] = arg[1].first
+            hash["#{arg[0]}_right".to_sym] = arg[1].last
+          else
+            hash[arg[0]] = arg[1]
+          end
+        }
+      end
+    end
+  end
+end