dry-validation 0.9.5 → 0.10.0

data/lib/dry/validation/constants.rb

@@ -1,6 +0,0 @@
-module Dry
-  module Validation
-    EMPTY_ARRAY = [].freeze
-    EMPTY_HASH = {}.freeze
-  end
-end

data/lib/dry/validation/error.rb

@@ -1,26 +0,0 @@
-module Dry
-  module Validation
-    class Error
-      include Dry::Equalizer(:name, :result)
-
-      attr_reader :name, :result
-
-      def initialize(name, result)
-        @name = name
-        @result = result
-      end
-
-      def schema?
-        result.response.is_a?(Validation::Result)
-      end
-
-      def to_ast
-        if schema?
-          [:schema, [name, result.response.to_ast]]
-        else
-          [:error, [name, result.to_ast]]
-        end
-      end
-    end
-  end
-end

data/lib/dry/validation/error_compiler.rb

@@ -1,81 +0,0 @@
-require 'dry/validation/message_compiler'
-
-module Dry
-  module Validation
-    class ErrorCompiler < MessageCompiler
-      def message_type
-        :failure
-      end
-
-      def message_class
-        Message
-      end
-
-      def visit_error(node, opts = EMPTY_HASH)
-        rule, error = node
-        node_path = Array(opts.fetch(:path, rule))
-
-        path = if rule.is_a?(Array) && rule.size > node_path.size
-                 rule
-               else
-                 node_path
-               end
-
-        path.compact!
-
-        template = messages[rule.is_a?(Array) ? rule.last : rule, default_lookup_options]
-
-        if template
-          predicate, args, tokens = visit(error, opts.merge(path: path, message: false))
-          message_class[predicate, path, template % tokens, rule: rule, args: args]
-        else
-          visit(error, opts.merge(rule: rule, path: path))
-        end
-      end
-
-      def visit_input(node, opts = EMPTY_HASH)
-        rule, result = node
-        opt_rule = opts[:rule]
-
-        if opts[:each] && opt_rule.is_a?(Array)
-          visit(result, opts.merge(rule: rule, path: opts[:path] + [opt_rule.last]))
-        else
-          visit(result, opts.merge(rule: rule))
-        end
-      end
-
-      def visit_result(node, opts = EMPTY_HASH)
-        input, other = node
-        visit(other, opts.merge(input: input))
-      end
-
-      def visit_each(node, opts = EMPTY_HASH)
-        node.map { |el| visit(el, opts.merge(each: true)) }
-      end
-
-      def visit_schema(node, opts = EMPTY_HASH)
-        path, other = node
-
-        if opts[:path]
-          visit(other, opts.merge(path: opts[:path] + [path.last]))
-        else
-          visit(other, opts.merge(path: [path], schema: true))
-        end
-      end
-
-      def visit_check(node, opts = EMPTY_HASH)
-        name, other = node
-
-        if opts[:schema]
-          visit(other, opts)
-        else
-          visit(other, opts.merge(path: Array(name)))
-        end
-      end
-
-      def lookup_options(opts, arg_vals = [])
-        super.update(val_type: opts[:input].class)
-      end
-    end
-  end
-end

data/lib/dry/validation/hint_compiler.rb

@@ -1,104 +0,0 @@
-require 'dry/validation/message_compiler'
-
-module Dry
-  module Validation
-    class HintCompiler < MessageCompiler
-      include Dry::Equalizer(:messages, :rules, :options)
-
-      attr_reader :rules, :excluded, :cache
-
-      TYPES = {
-        none?: NilClass,
-        bool?: TrueClass,
-        str?: String,
-        int?: Fixnum,
-        float?: Float,
-        decimal?: BigDecimal,
-        date?: Date,
-        date_time?: DateTime,
-        time?: Time,
-        hash?: Hash,
-        array?: Array
-      }.freeze
-
-      EXCLUDED = (%i(key? none? filled?) + TYPES.keys).freeze
-
-      def self.cache
-        @cache ||= Concurrent::Map.new
-      end
-
-      def initialize(messages, options = {})
-        super(messages, options)
-        @rules = options.fetch(:rules, EMPTY_ARRAY)
-        @excluded = options.fetch(:excluded, EXCLUDED)
-        @cache = self.class.cache
-      end
-
-      def message_type
-        :hint
-      end
-
-      def message_class
-        Hint
-      end
-
-      def hash
-        @hash ||= [messages, rules, options].hash
-      end
-
-      def call
-        cache.fetch_or_store(hash) { super(rules) }
-      end
-
-      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_each(node, opts = EMPTY_HASH)
-        visit(node, opts.merge(each: true))
-      end
-
-      def visit_or(node, *args)
-        left, right = node
-        [Array[visit(left, *args)], Array[visit(right, *args)]].flatten
-      end
-
-      def visit_and(node, *args)
-        _, right = node
-        visit(right, *args)
-      end
-
-      def visit_schema(node, opts = EMPTY_HASH)
-        path = node.config.path
-        rules = node.rule_ast
-        schema_opts = opts.merge(path: [path])
-
-        rules.map { |rule| visit(rule, schema_opts) }
-      end
-
-      def visit_check(node)
-        EMPTY_ARRAY
-      end
-
-      def visit_xor(node)
-        EMPTY_ARRAY
-      end
-
-      def visit_not(node)
-        EMPTY_ARRAY
-      end
-
-      def visit_type(node, *args)
-        visit(node.rule.to_ast, *args)
-      end
-
-      private
-
-      def dyn_args?(args)
-        args.map(&:last).any? { |a| a.is_a?(UnboundMethod) }
-      end
-    end
-  end
-end

data/spec/unit/error_compiler_spec.rb

@@ -1,7 +0,0 @@
-RSpec.describe ErrorCompiler, '#call' do
-  subject(:error_compiler) { ErrorCompiler.new( Messages.default ) }
-
-  it 'returns an empty hash when there are no errors' do
-    expect(error_compiler.([])).to be_empty
-  end
-end

data/spec/unit/hint_compiler_spec.rb

@@ -1,51 +0,0 @@
-require 'dry/validation/hint_compiler'
-
-RSpec.describe HintCompiler, '#call' do
-  subject(:compiler) { HintCompiler.new(Messages.default, rules: rules) }
-
-  include_context 'predicate helper'
-
-  let(:rules) do
-    [
-      [
-        :and, [
-          [:val, p(:key?, :age)],
-          [
-            :or, [
-              [:key, [:age, p(:none?)]],
-              [
-                :and, [
-                  [:key, [:age, p(:int?)]],
-                  [:key, [:age, p(:gt?, 18)]]
-                ]
-              ]
-            ]
-          ]
-        ],
-      ],
-      [
-        :and, [
-          [:val, p(:key?, :height)],
-          [
-            :or, [
-              [:key, [:height, p(:none?)]],
-              [
-                :and, [
-                  [:key, [:height, p(:int?)]],
-                  [:key, [:height, p(:gt?, 180)]]
-                ]
-              ]
-            ]
-          ]
-        ]
-      ]
-    ]
-  end
-
-  it 'returns hint messages for given rules' do
-    expect(compiler.call.to_h).to eql(
-      age: ['must be greater than 18'],
-      height: ['must be greater than 180'],
-    )
-  end
-end