dry-validation 0.13.3 → 1.7.0

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

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

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

@@ -1,47 +0,0 @@
-module Dry
-  module Validation
-    class InputProcessorCompiler::Sanitizer < InputProcessorCompiler
-      PREDICATE_MAP = {
-        default: 'string',
-        none?: 'nil',
-        bool?: 'bool',
-        str?: 'string',
-        int?: 'integer',
-        float?: 'float',
-        decimal?: 'decimal',
-        date?: 'date',
-        date_time?: 'date_time',
-        time?: 'time',
-        hash?: 'hash',
-        array?: 'array'
-      }.freeze
-
-      CONST_MAP = {
-        NilClass => 'nil',
-        String => 'string',
-        Integer => 'integer',
-        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)
-        [:hash, [:weak, schema, {}]]
-      end
-
-      def array_node(members)
-        [:array, [members, {}]]
-      end
-    end
-  end
-end

data/lib/dry/validation/input_processor_compiler.rb

@@ -1,137 +0,0 @@
-require 'dry/types'
-require 'dry/types/compiler'
-
-module Dry
-  module Validation
-    class InputProcessorCompiler
-      attr_reader :type_compiler
-
-      DEFAULT_TYPE_NODE = [:definition, [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_rule(node, *args)
-        _, rule = node
-        visit(rule, *args)
-      end
-
-      def visit_type(type, *args)
-        if type.is_a?(Types::Constructor)
-          constructor(type)
-        elsif type.respond_to?(:rule)
-          visit(type.rule.to_ast, *args)
-        end
-      end
-
-      def constructor(type)
-        fn_id = type.__send__(:register_fn, type.fn)
-        [:constructor, [[:definition, [type.primitive, {}]], fn_id, {}]]
-      end
-
-      def visit_schema(schema, *args)
-        hash_node(schema.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
-
-          if name.is_a?(Array)
-            type
-          else
-            [:member, [name, type]]
-          end
-        else
-          result = node.map { |n| visit(n, first) }.uniq
-
-          if result.size == 1
-            result.first
-          else
-            result.select { |r| r != self.class::DEFAULT_TYPE_NODE }.last
-          end
-        end
-      end
-
-      def visit_implication(node, *args)
-        left, right = node
-
-        key = visit(left)
-
-        if key.is_a?(Symbol)
-          [:member, [key, visit(right, false)]]
-        else
-          [:sum, [key, visit(right, false), {}]]
-        end
-      end
-
-      def visit_not(node, *args)
-        visit(node, *args)
-      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, *)
-        id, args = node
-
-        if id == :key?
-          args[0][1]
-        else
-          type(id, args.map(&:last))
-        end
-      end
-
-      def type(predicate, args)
-        default = self.class::PREDICATE_MAP[:default]
-
-        type_value = if predicate == :type?
-                       const = args[0]
-                       self.class::CONST_MAP[const] || Types.identifier(const)
-                     else
-                       self.class::PREDICATE_MAP[predicate] || default
-                     end
-
-        require 'dry/types/compat/int' unless Types.container.key?(type_value)
-
-        Types[type_value].to_ast
-      end
-    end
-  end
-end
-
-require 'dry/validation/input_processor_compiler/sanitizer'
-require 'dry/validation/input_processor_compiler/json'
-require 'dry/validation/input_processor_compiler/params'

data/lib/dry/validation/message_compiler/visitor_opts.rb

@@ -1,37 +0,0 @@
-module Dry
-  module Validation
-    class MessageCompiler
-      class VisitorOpts < Hash
-        def self.new
-          opts = super
-          opts[:path] = EMPTY_ARRAY
-          opts[:rule] = nil
-          opts[:message_type] = :failure
-          opts
-        end
-
-        def path?
-          ! path.empty?
-        end
-
-        def path
-          self[:path]
-        end
-
-        def rule
-          self[:rule]
-        end
-
-        def with_rule(new_rule, **other)
-          opts = dup
-          opts[:rule] = new_rule unless opts.rule
-          opts.(other)
-        end
-
-        def call(other)
-          merge(other.update(path: [*path, *other[:path]]))
-        end
-      end
-    end
-  end
-end

data/lib/dry/validation/message_compiler.rb

@@ -1,188 +0,0 @@
-require 'dry/validation/message'
-require 'dry/validation/message_set'
-require 'dry/validation/message_compiler/visitor_opts'
-
-module Dry
-  module Validation
-    class MessageCompiler
-      attr_reader :messages, :options, :locale, :default_lookup_options
-
-      EMPTY_OPTS = VisitorOpts.new
-      LIST_SEPARATOR = ', '.freeze
-
-      def initialize(messages, options = {})
-        @messages = messages
-        @options = options
-        @full = @options.fetch(:full, false)
-        @hints = @options.fetch(:hints, true)
-        @locale = @options.fetch(:locale, messages.default_locale)
-        @default_lookup_options = { locale: locale }
-      end
-
-      def full?
-        @full
-      end
-
-      def hints?
-        @hints
-      end
-
-      def with(new_options)
-        return self if new_options.empty?
-        self.class.new(messages, options.merge(new_options))
-      end
-
-      def call(ast)
-        MessageSet[ast.map { |node| visit(node) }, failures: options.fetch(:failures, true)]
-      end
-
-      def visit(node, *args)
-        __send__(:"visit_#{node[0]}", node[1], *args)
-      end
-
-      def visit_failure(node, opts = EMPTY_OPTS)
-        rule, other = node
-        visit(other, opts.(rule: rule))
-      end
-
-      def visit_hint(node, opts = EMPTY_OPTS)
-        if hints?
-          visit(node, opts.(message_type: :hint))
-        end
-      end
-
-      def visit_each(node, opts = EMPTY_OPTS)
-        # TODO: we can still generate a hint for elements here!
-        []
-      end
-
-      def visit_not(node, opts = EMPTY_OPTS)
-        visit(node, opts.(not: true))
-      end
-
-      def visit_check(node, opts = EMPTY_OPTS)
-        keys, other = node
-        visit(other, opts.(path: keys.last, check: true))
-      end
-
-      def visit_rule(node, opts = EMPTY_OPTS)
-        name, other = node
-        visit(other, opts.(rule: name))
-      end
-
-      def visit_schema(node, opts = EMPTY_OPTS)
-        node.rule_ast.map { |rule| visit(rule, opts) }
-      end
-
-      def visit_and(node, opts = EMPTY_OPTS)
-        left, right = node.map { |n| visit(n, opts) }
-
-        if right
-          [left, right]
-        else
-          left
-        end
-      end
-
-      def visit_or(node, opts = EMPTY_OPTS)
-        left, right = node.map { |n| visit(n, opts) }
-
-        if [left, right].flatten.map(&:path).uniq.size == 1
-          Message::Or.new(left, right, -> k { messages[k, default_lookup_options] })
-        elsif right.is_a?(Array)
-          right
-        else
-          [left, right]
-        end
-      end
-
-      def visit_predicate(node, base_opts = EMPTY_OPTS)
-        predicate, args = node
-
-        *arg_vals, val = args.map(&:last)
-        tokens = message_tokens(args)
-
-        input = val != Undefined ? val : nil
-
-        options = base_opts.update(lookup_options(arg_vals: arg_vals, input: input))
-        msg_opts = options.update(tokens)
-
-        rule = msg_opts[:rule]
-        path = msg_opts[:path]
-
-        template = messages[rule] || messages[predicate, msg_opts]
-
-        unless template
-          raise MissingMessageError, "message for #{predicate} was not found"
-        end
-
-        text = message_text(rule, template, tokens, options)
-
-        message_class = options[:message_type] == :hint ? Hint : Message
-
-        message_class[
-          predicate, path, text,
-          args: arg_vals,
-          input: input,
-          rule: rule,
-          check: base_opts[:check]
-        ]
-      end
-
-      def visit_key(node, opts = EMPTY_OPTS)
-        name, other = node
-        visit(other, opts.(path: name))
-      end
-
-      def visit_set(node, opts = EMPTY_OPTS)
-        node.map { |el| visit(el, opts) }
-      end
-
-      def visit_implication(node, *args)
-        _, right = node
-        visit(right, *args)
-      end
-
-      def visit_xor(node, opts = EMPTY_OPTS)
-        left, right = node
-        [visit(left, opts), visit(right, opts)].uniq
-      end
-
-      def visit_type(node, opts = EMPTY_OPTS)
-        visit(node.rule.to_ast, opts)
-      end
-
-      def lookup_options(arg_vals: [], input: nil)
-        default_lookup_options.merge(
-          arg_type: arg_vals.size == 1 && arg_vals[0].class,
-          val_type: input.class
-        )
-      end
-
-      def message_text(rule, template, tokens, opts)
-        text = template[template.data(tokens)]
-
-        if full?
-          rule_name = messages.rule(rule, opts) || rule
-          "#{rule_name} #{text}"
-        else
-          text
-        end
-      end
-
-      def message_tokens(args)
-        args.each_with_object({}) { |arg, hash|
-          case arg[1]
-          when Array
-            hash[arg[0]] = arg[1].join(LIST_SEPARATOR)
-          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

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

@@ -1,119 +0,0 @@
-require 'pathname'
-require 'concurrent/map'
-
-require 'dry/equalizer'
-require 'dry/configurable'
-
-require 'dry/validation/template'
-
-module Dry
-  module Validation
-    module Messages
-      class Abstract
-        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
-        setting :lookup_options, [:root, :predicate, :rule, :val_type, :arg_type].freeze
-
-        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}
-          %{root}.%{predicate}
-        ).freeze
-
-        setting :arg_type_default, 'default'.freeze
-        setting :val_type_default, 'default'.freeze
-
-        setting :arg_types, Hash.new { |*| config.arg_type_default }.update(
-          Range => 'range'
-        )
-
-        setting :val_types, Hash.new { |*| config.val_type_default }.update(
-          Range => 'range',
-          String => 'string'
-        )
-
-        CACHE_KEYS = %i[path message_type val_type arg_type locale].freeze
-
-        def self.cache
-          @cache ||= Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new }
-        end
-
-        attr_reader :config
-
-        def initialize
-          @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)
-        end
-
-        def call(predicate, options = EMPTY_HASH)
-          cache.fetch_or_store([predicate, options.reject { |k,| k.equal?(:input) }]) do
-            path, opts = lookup(predicate, options)
-            return unless path
-            text = yield(path, opts)
-            Template[text]
-          end
-        end
-        alias_method :[], :call
-
-        def lookup(predicate, options = {})
-          tokens = options.merge(
-            root: root,
-            predicate: predicate,
-            arg_type: config.arg_types[options[:arg_type]],
-            val_type: config.val_types[options[:val_type]],
-            message_type: options[:message_type] || :failure
-          )
-
-          tokens[:rule] = predicate unless tokens.key?(:rule)
-
-          opts = options.select { |k, _| !config.lookup_options.include?(k) }
-
-          path = lookup_paths(tokens).detect do |key|
-            key?(key, opts) && get(key, opts).is_a?(String)
-          end
-
-          [path, opts]
-        end
-
-        def lookup_paths(tokens)
-          config.lookup_paths.map { |path| path % tokens }
-        end
-
-        def namespaced(namespace)
-          Messages::Namespaced.new(namespace, self)
-        end
-
-        def root
-          config.root
-        end
-
-        def cache
-          @cache ||= self.class.cache[self]
-        end
-
-        def default_locale
-          :en
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-require 'i18n'
-require 'dry/validation/messages/abstract'
-
-module Dry
-  module Validation
-    class Messages::I18n < Messages::Abstract
-      attr_reader :t
-
-      ::I18n.load_path.concat(config.paths)
-
-      def initialize
-        super
-        @t = I18n.method(:t)
-      end
-
-      def call(predicate, options = EMPTY_HASH)
-        super do |path, opts|
-          get(path, opts)
-        end
-      end
-      alias_method :[], :call
-
-      def get(key, options = {})
-        t.(key, locale: options.fetch(:locale, default_locale)) if key
-      end
-
-      def rule(name, options = {})
-        path = "rules.#{name}"
-        get(path, options) if key?(path, options)
-      end
-
-      def key?(key, options)
-        ::I18n.exists?(key, options.fetch(:locale, default_locale)) ||
-        ::I18n.exists?(key, I18n.default_locale)
-      end
-
-      def merge(path)
-        ::I18n.load_path << path
-        self
-      end
-
-      def default_locale
-        I18n.locale || I18n.default_locale || super
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-module Dry
-  module Validation
-    module Messages
-      class Namespaced < Messages::Abstract
-        attr_reader :namespace, :messages, :root
-
-        def initialize(namespace, messages)
-          super()
-          @namespace = namespace
-          @messages = messages
-          @root = messages.root
-        end
-
-        def call(predicate, options = EMPTY_HASH)
-          super do |path, opts|
-            messages.get(path, opts)
-          end
-        end
-        alias_method :[], :call
-
-        def key?(key, *args)
-          messages.key?(key, *args)
-        end
-
-        def get(key, options = {})
-          messages.get(key, options)
-        end
-
-        def lookup_paths(tokens)
-          super(tokens.merge(root: "#{root}.rules.#{namespace}")) + super
-        end
-
-        def default_locale
-          messages.default_locale
-        end
-      end
-    end
-  end
-end