dry-validation 0.6.0 → 0.7.0

data/lib/dry/validation/input_processor_compiler.rb

@@ -0,0 +1,98 @@
+require 'dry/types'
+require 'dry/types/compiler'
+
+module Dry
+  module Validation
+    class InputProcessorCompiler
+      attr_reader :type_compiler
+
+      DEFAULT_TYPE_NODE = [[:type, 'string']].freeze
+
+      def initialize
+        @type_compiler = Dry::Types::Compiler.new(Dry::Types)
+      end
+
+      def call(ast)
+        type_compiler.(hash_node(schema_ast(ast)))
+      end
+
+      def schema_ast(ast)
+        ast.map { |node| visit(node) }
+      end
+
+      def visit(node, *args)
+        send(:"visit_#{node[0]}", node[1], *args)
+      end
+
+      def visit_schema(node, *args)
+        hash_node(node.input_processor_ast(identifier))
+      end
+
+      def visit_or(node, *args)
+        left, right = node
+        [:sum, [visit(left, *args), visit(right, *args)]]
+      end
+
+      def visit_and(node, first = true)
+        if first
+          name, type = node.map { |n| visit(n, false) }.uniq
+          [:key, [name, type]]
+        else
+          result = node.map { |n| visit(n, first) }.uniq
+
+          if result.size == 1
+            result.first
+          else
+            (result - self.class::DEFAULT_TYPE_NODE).first
+          end
+        end
+      end
+
+      def visit_implication(node)
+        key, types = node
+        [:key, [visit(key), visit(types, false)]]
+      end
+
+      def visit_key(node, *args)
+        _, other = node
+        visit(other, *args)
+      end
+
+      def visit_val(node, *args)
+        visit(node, *args)
+      end
+
+      def visit_set(node, *)
+        hash_node(node.map { |n| visit(n) })
+      end
+
+      def visit_each(node, *args)
+        array_node(visit(node, *args))
+      end
+
+      def visit_predicate(node, *args)
+        id, args = node
+
+        if id == :key?
+          args[0]
+        else
+          type(id, args)
+        end
+      end
+
+      def type(predicate, args)
+        default = self.class::PREDICATE_MAP[:default]
+
+        if predicate == :type?
+          const = args[0]
+          [:type, self.class::CONST_MAP[const] || Types.identifier(const)]
+        else
+          [:type, self.class::PREDICATE_MAP[predicate] || default]
+        end
+      end
+    end
+  end
+end
+
+require 'dry/validation/input_processor_compiler/sanitizer'
+require 'dry/validation/input_processor_compiler/form'

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

@@ -0,0 +1,46 @@
+module Dry
+  module Validation
+    class InputProcessorCompiler::Form < InputProcessorCompiler
+      PREDICATE_MAP = {
+        default: 'string',
+        none?: 'form.nil',
+        bool?: 'form.bool',
+        str?: 'string',
+        int?: 'form.int',
+        float?: 'form.float',
+        decimal?: 'form.decimal',
+        date?: 'form.date',
+        date_time?: 'form.date_time',
+        time?: 'form.time'
+      }.freeze
+
+      CONST_MAP = {
+        NilClass => 'form.nil',
+        String => 'string',
+        Fixnum => 'form.int',
+        Integer => 'form.int',
+        Float => 'form.float',
+        BigDecimal => 'form.decimal',
+        Array => 'form.array',
+        Hash => 'form.hash',
+        Date => 'form.date',
+        DateTime => 'form.date_time',
+        Time => 'form.time',
+        TrueClass => 'form.true',
+        FalseClass => 'form.false'
+      }.freeze
+
+      def identifier
+        :form
+      end
+
+      def hash_node(schema)
+        [:type, ['form.hash', [:symbolized, schema]]]
+      end
+
+      def array_node(members)
+        [:type, ['form.array', members]]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Dry
+  module Validation
+    class InputProcessorCompiler::Sanitizer < InputProcessorCompiler
+      PREDICATE_MAP = {
+        default: 'string',
+        none?: 'nil',
+        bool?: 'bool',
+        str?: 'string',
+        int?: 'int',
+        float?: 'float',
+        decimal?: 'decimal',
+        date?: 'date',
+        date_time?: 'date_time',
+        time?: 'time'
+      }.freeze
+
+      CONST_MAP = {
+        NilClass => 'nil',
+        String => 'string',
+        Fixnum => 'int',
+        Integer => 'int',
+        Float => 'float',
+        BigDecimal => 'decimal',
+        Array => 'array',
+        Hash => 'hash',
+        Date => 'date',
+        DateTime => 'date_time',
+        Time => 'time',
+        TrueClass => 'true',
+        FalseClass => 'false'
+      }.freeze
+
+      def identifier
+        :sanitizer
+      end
+
+      def hash_node(schema)
+        [:type, ['hash', [:schema, schema]]]
+      end
+
+      def array_node(members)
+        [:type, ['array', members]]
+      end
+    end
+  end
+end

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

@@ -5,9 +5,10 @@ module Dry
   module Validation
     module Messages
       class Abstract
-        DEFAULT_PATH = Pathname(__dir__).join('../../../../config/errors.yml').realpath.freeze
-
         extend Dry::Configurable
+        include Dry::Equalizer(:config)
+
+        DEFAULT_PATH = Pathname(__dir__).join('../../../../config/errors.yml').realpath.freeze
 
         setting :paths, [DEFAULT_PATH]
         setting :root, 'errors'.freeze
@@ -34,12 +35,30 @@ module Dry
           String => 'string'
         )
 
+        def self.cache
+          @cache ||= ThreadSafe::Cache.new { |h, k| h[k] = ThreadSafe::Cache.new }
+        end
+
+        attr_reader :config
+
+        def initialize
+          @config = self.class.config
+        end
+
+        def rule(name, options = {})
+          path = "%{locale}.rules.#{name}"
+          get(path, options) if key?(path, options)
+        end
+
         def call(*args)
-          cache.fetch_or_store(args.hash) { get(*lookup(*args)) }
+          cache.fetch_or_store(args.hash) do
+            path, opts = lookup(*args)
+            get(path, opts) if path
+          end
         end
         alias_method :[], :call
 
-        def lookup(predicate, options)
+        def lookup(predicate, options = {})
           tokens = options.merge(
             root: root,
             predicate: predicate,
@@ -47,8 +66,13 @@ module Dry
             val_type: config.val_types[options[:val_type]]
           )
 
+          tokens[:rule] = predicate unless tokens.key?(:rule)
+
           opts = options.reject { |k, _| config.lookup_options.include?(k) }
-          path = lookup_paths(tokens).detect { |key| key?(key, opts) && get(key).is_a?(String) }
+
+          path = lookup_paths(tokens).detect do |key|
+            key?(key, opts) && get(key, opts).is_a?(String)
+          end
 
           [path, opts]
         end
@@ -65,12 +89,8 @@ module Dry
           config.root
         end
 
-        def config
-          self.class.config
-        end
-
         def cache
-          @cache ||= ThreadSafe::Cache.new
+          self.class.cache[self]
         end
       end
     end

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

@@ -9,11 +9,12 @@ module Dry
       ::I18n.load_path.concat(config.paths)
 
       def initialize
+        super
         @t = I18n.method(:t)
       end
 
       def get(key, options = {})
-        t.(key, options)
+        t.(key, options) if key
       end
 
       def key?(key, options)

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

@@ -5,6 +5,7 @@ module Dry
         attr_reader :namespace, :messages, :root
 
         def initialize(namespace, messages)
+          super()
           @namespace = namespace
           @messages = messages
           @root = messages.root

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

@@ -6,10 +6,12 @@ require 'dry/validation/messages/abstract'
 module Dry
   module Validation
     class Messages::YAML < Messages::Abstract
+      include Dry::Equalizer(:data)
+
       attr_reader :data
 
       configure do |config|
-        config.root = 'en.errors'.freeze
+        config.root = '%{locale}.errors'.freeze
       end
 
       def self.load(paths = config.paths)
@@ -27,15 +29,16 @@ module Dry
       end
 
       def initialize(data)
+        super()
         @data = data
       end
 
-      def get(key, _options = {})
-        data[key]
+      def get(key, options = {})
+        data[key % { locale: options.fetch(:locale, :en) }]
       end
 
-      def key?(key, *args)
-        data.key?(key)
+      def key?(key, options = {})
+        data.key?(key % { locale: options.fetch(:locale, :en) })
       end
 
       def merge(overrides)

data/lib/dry/validation/result.rb

@@ -1,53 +1,61 @@
 module Dry
   module Validation
     class Result
+      include Dry::Equalizer(:output, :messages)
       include Enumerable
 
-      attr_reader :rule_results
+      attr_reader :output
+      attr_reader :errors
+      attr_reader :error_compiler
+      attr_reader :hint_compiler
 
-      def initialize(rule_results)
-        @rule_results = rule_results
+      alias_method :to_hash, :output
+
+      EMPTY_MESSAGES = {}.freeze
+
+      def initialize(output, errors, error_compiler, hint_compiler)
+        @output = output
+        @errors = errors
+        @error_compiler = error_compiler
+        @hint_compiler = hint_compiler
       end
 
       def each(&block)
-        rule_results.each(&block)
+        output.each(&block)
       end
 
       def [](name)
-        to_h[name]
+        output.fetch(name)
       end
 
-      def to_h
-        @to_h ||= each_with_object({}) { |result, hash| hash[result.name] = result }
+      def success?
+        errors.empty?
       end
 
-      def merge!(other)
-        rule_results.concat(other.rule_results)
+      def failure?
+        !success?
       end
 
-      def to_ary
-        failures.map(&:to_ary)
-      end
+      def messages(options = {})
+        @messages ||=
+          begin
+            return EMPTY_MESSAGES if success?
 
-      def <<(rule_result)
-        rule_results << rule_result
-      end
+            hints = hint_compiler.with(options).call
+            comp = error_compiler.with(options.merge(hints: hints))
 
-      def with_values(names, &block)
-        values = names.map { |name| by_name(name) }.compact.map(&:input)
-        yield(values) if values.size == names.size
+            comp.(error_ast)
+          end
       end
 
-      def by_name(name)
-        successes.detect { |rule_result| rule_result.name == name }
+      def to_ast
+        [:set, error_ast]
       end
 
-      def successes
-        rule_results.select(&:success?)
-      end
+      private
 
-      def failures
-        rule_results.select(&:failure?)
+      def error_ast
+        errors.map { |error| error.to_ast }
       end
     end
   end

data/lib/dry/validation/schema.rb

@@ -1,45 +1,73 @@
-require 'dry/logic/predicates'
-require 'dry/logic/rule_compiler'
+require 'dry/types/constraints'
+
+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'
 
-require 'dry/validation/schema/definition'
 require 'dry/validation/error'
+require 'dry/validation/result'
 require 'dry/validation/messages'
 require 'dry/validation/error_compiler'
 require 'dry/validation/hint_compiler'
-require 'dry/validation/result'
-require 'dry/validation/schema/result'
+
+require 'dry/validation/input_processor_compiler'
 
 module Dry
   module Validation
     class Schema
       extend Dry::Configurable
-      extend Definition
 
-      setting :predicates, Logic::Predicates
+      NOOP_INPUT_PROCESSOR = -> input { input }
+
+      setting :path
+      setting :predicates, Types::Predicates
       setting :messages, :yaml
       setting :messages_file
       setting :namespace
+      setting :rules, []
+      setting :checks, []
 
-      def self.predicates
-        config.predicates
+      setting :input_processor, :noop
+
+      setting :input_processor_map, {
+        sanitizer: InputProcessorCompiler::Sanitizer.new,
+        form: InputProcessorCompiler::Form.new
+      }.freeze
+
+      def self.inherited(klass)
+        super
+        klass.setting :options, {}
       end
 
-      def self.error_compiler
-        ErrorCompiler.new(messages)
+      def self.new(rules = config.rules, **options)
+        super(rules, default_options.merge(options))
       end
 
-      def self.hint_compiler
-        HintCompiler.new(messages, rules: rules.map(&:to_ary))
+      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.predicates
+        config.predicates
+      end
+
+      def self.options
+        config.options
       end
 
       def self.messages
-        default =
-          case config.messages
-          when :yaml then Messages.default
-          when :i18n then Messages::I18n.new
-          else
-            fail "+#{config.messages}+ is not a valid messages identifier"
-          end
+        default = default_messages
 
         if config.messages_file && config.namespace
           default.merge(config.messages_file).namespaced(config.namespace)
@@ -52,23 +80,61 @@ module Dry
         end
       end
 
-      def self.rules
-        @__rules__ ||= []
+      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.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.schemas
-        @__schemas__ ||= []
+      def self.input_processor_compiler
+        @input_processor_comp ||= config.input_processor_map[config.input_processor]
       end
 
-      def self.groups
-        @__groups__ ||= []
+      def self.rule_ast
+        @rule_ast ||= config.rules.flat_map(&:rules).map(&:to_ast)
       end
 
-      def self.checks
-        @__checks__ ||= []
+      def self.default_options
+        { predicates: predicates,
+          error_compiler: error_compiler,
+          hint_compiler: hint_compiler,
+          input_processor: input_processor,
+          checks: config.checks }
       end
 
-      attr_reader :rules, :schemas, :groups, :checks
+      attr_reader :rules
+
+      attr_reader :checks
+
+      attr_reader :predicates
+
+      attr_reader :input_processor
 
       attr_reader :rule_compiler
 
@@ -76,55 +142,96 @@ module Dry
 
       attr_reader :hint_compiler
 
-      def initialize(rules = [])
-        @rule_compiler = Logic::RuleCompiler.new(self)
-        @rules = rule_compiler.(self.class.rules.map(&:to_ary) + rules.map(&:to_ary))
-        @checks = self.class.checks.map(&:to_ary)
-        @groups = rule_compiler.(self.class.groups.map(&:to_ary))
-        @schemas = self.class.schemas.map(&:new)
-        @error_compiler = self.class.error_compiler
-        @hint_compiler = self.class.hint_compiler
+      attr_reader :options
+
+      def initialize(rules, options)
+        @rule_compiler = SchemaCompiler.new(self)
+        @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)
+        initialize_rules(rules)
+        initialize_checks(options.fetch(:checks, []))
+
+        freeze
+      end
+
+      def with(new_options)
+        self.class.new(self.class.rules, options.merge(new_options))
       end
 
       def call(input)
-        result = Validation::Result.new(rules.map { |rule| rule.(input) })
+        processed_input = input_processor[input]
+        Result.new(processed_input, apply(processed_input), error_compiler, hint_compiler)
+      end
 
-        schemas.each do |schema|
-          result.merge!(schema.(input).result)
+      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
 
-        if checks.size > 0
-          resolver = -> name { result[name] || self[name] }
-          compiled_checks = Logic::RuleCompiler.new(resolver).(checks)
+      private
 
-          compiled_checks.each do |rule|
-            result << rule.(result)
-          end
+      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
 
-        groups.each do |group|
-          result.with_values(group.rules) do |values|
-            result << group.(*values)
-          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
 
-        errors = Error::Set.new(result.failures.map { |failure| Error.new(failure) })
+        self.class.options.each do |name, default|
+          value = options.fetch(name) do
+            case default
+            when Proc then default.()
+            else default end
+          end
 
-        Schema::Result.new(input, result, errors, error_compiler, hint_compiler)
+          instance_variable_set("@#{name}", value)
+        end
       end
 
-      def [](name)
-        if predicates.key?(name)
-          predicates[name]
-        elsif respond_to?(name)
-          Logic::Predicate.new(name, &method(name))
-        else
-          fail ArgumentError, "+#{name}+ is not a valid predicate name"
+      def initialize_rules(rules)
+        @rules = rules.each_with_object({}) do |rule, result|
+          result[rule.name] = rule_compiler.visit(rule.to_ast)
         end
       end
 
-      def predicates
-        self.class.predicates
+      def initialize_checks(checks)
+        @checks = checks.each_with_object({}) do |check, result|
+          result[check.name] = rule_compiler.visit(check.to_ast)
+        end
       end
     end
   end