dry-validation 0.13.3 → 1.0.0.alpha1

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_set.rb

@@ -1,122 +0,0 @@
-module Dry
-  module Validation
-    class MessageSet
-      include Enumerable
-
-      HINT_EXCLUSION = %i(
-        key? filled? none? bool?
-        str? int? float? decimal?
-        date? date_time? time? hash?
-        array? format?
-      ).freeze
-
-      attr_reader :messages, :failures, :hints, :paths, :placeholders, :options
-
-      def self.[](messages, options = EMPTY_HASH)
-        new(messages.flatten, options)
-      end
-
-      def initialize(messages, options = EMPTY_HASH)
-        @messages = messages
-        @hints = messages.select(&:hint?)
-        @failures = messages - hints
-        @paths = failures.map(&:path).uniq
-        @options = options
-
-        initialize_hints!
-        initialize_placeholders!
-      end
-
-      def dump
-        root? ? to_a : to_h
-      end
-
-      def failures?
-        options[:failures].equal?(true)
-      end
-
-      def empty?
-        messages.empty?
-      end
-
-      def root?
-        !empty? && failures.all?(&:root?)
-      end
-
-      def each(&block)
-        return to_enum unless block
-        messages.each(&block)
-      end
-
-      def to_h
-        if root?
-          { nil => failures.map(&:to_s) }
-        else
-          failures? ? messages_map : hints_map
-        end
-      end
-      alias_method :to_hash, :to_h
-
-      def to_a
-        to_h.values.flatten
-      end
-
-      private
-
-      def messages_map
-        failures.group_by(&:path).reduce(placeholders) do |hash, (path, msgs)|
-          node = path.reduce(hash) { |a, e| a[e] }
-
-          msgs.each do |msg|
-            node << msg
-
-            msg_hints = hint_groups[msg.path]
-            node.concat(msg_hints) if msg_hints
-          end
-
-          node.map!(&:to_s)
-
-          hash
-        end
-      end
-
-      def hints_map
-        hints.group_by(&:path).reduce(placeholders) do |hash, (path, msgs)|
-          node = path.reduce(hash) { |a, e| a[e] }
-
-          msgs.each do |msg|
-            node << msg
-          end
-
-          node.map!(&:to_s)
-
-          hash
-        end
-      end
-
-      def hint_groups
-        @hint_groups ||= hints.group_by(&:path)
-      end
-
-      def initialize_hints!
-        hints.reject! { |hint| HINT_EXCLUSION.include?(hint.predicate) }
-      end
-
-      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

@@ -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

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

@@ -1,61 +0,0 @@
-require 'yaml'
-require 'pathname'
-
-require 'dry/equalizer'
-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 = '%{locale}.errors'.freeze
-      end
-
-      def self.load(paths = config.paths)
-        new(paths.map { |path| load_file(path) }.reduce(:merge))
-      end
-
-      def self.load_file(path)
-        flat_hash(YAML.load_file(path))
-      end
-
-      def self.flat_hash(h, f = [], g = {})
-        return g.update(f.join('.'.freeze) => h) unless h.is_a? Hash
-        h.each { |k, r| flat_hash(r, f + [k], g) }
-        g
-      end
-
-      def initialize(data)
-        super()
-        @data = data
-      end
-
-      def call(predicate, options = EMPTY_HASH)
-        super do |path, opts|
-          get(path, opts)
-        end
-      end
-      alias_method :[], :call
-
-      def get(key, options = {})
-        data[key % { locale: options.fetch(:locale, default_locale) }]
-      end
-
-      def key?(key, options = {})
-        data.key?(key % { locale: options.fetch(:locale, default_locale) })
-      end
-
-      def merge(overrides)
-        if overrides.is_a?(Hash)
-          self.class.new(data.merge(self.class.flat_hash(overrides)))
-        else
-          self.class.new(data.merge(Messages::YAML.load_file(overrides)))
-        end
-      end
-    end
-  end
-end

data/lib/dry/validation/predicate_registry.rb

@@ -1,115 +0,0 @@
-require 'dry/logic/rule/predicate'
-
-module Dry
-  module Validation
-    class PredicateRegistry
-      module PredicateDetector
-        def method_added(name)
-          super
-
-          if name.to_s.end_with?('?')
-            registry.update(name => instance_method(name))
-          end
-        end
-      end
-
-      attr_reader :predicates
-      attr_reader :external
-
-      class Bound < PredicateRegistry
-        attr_reader :schema
-
-        def initialize(*args)
-          super(*args[0..1])
-          @schema = args.last
-          freeze
-        end
-      end
-
-      class Unbound < PredicateRegistry
-        def bind(schema)
-          bound_predicates = predicates.each_with_object({}) do |(n, p), res|
-            res[n] = p.bind(schema)
-          end
-          Bound.new(external, bound_predicates, schema)
-        end
-
-        def update(other)
-          predicates.update(other)
-          self
-        end
-      end
-
-      def self.[](predicates)
-        Unbound.new(predicates)
-      end
-
-      def initialize(external, predicates = {})
-        @external = external
-        @predicates = predicates
-      end
-
-      def new(klass)
-        new_predicates = predicates
-          .keys
-          .each_with_object({}) { |key, res| res[key] = klass.instance_method(key) }
-
-        self.class.new(external).update(new_predicates)
-      end
-
-      def [](name)
-        predicates.fetch(name) do
-          if external.public_methods.include?(name)
-            external[name]
-          else
-            raise_unknown_predicate_error(name)
-          end
-        end
-      end
-
-      def key?(name)
-        predicates.key?(name) || external.public_methods.include?(name)
-      end
-
-      def arg_list(name, *values)
-        predicate = self[name]
-
-        predicate
-          .parameters
-          .map(&:last)
-          .zip(values + Array.new(predicate.arity - values.size, Undefined))
-      end
-
-      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
-
-        if key?(name)
-          arity = self[name].arity
-
-          case args_or_arity
-          when Array
-            raise_invalid_arity_error(name) if ![0, args_or_arity.size + 1].include?(arity)
-          when Integer
-            raise_invalid_arity_error(name) if args_or_arity != arity
-          end
-        else
-          raise_unknown_predicate_error(name)
-        end
-      end
-
-      private
-
-      def raise_unknown_predicate_error(name)
-        raise ArgumentError, "+#{name}+ is not a valid predicate name"
-      end
-
-      def raise_invalid_arity_error(name)
-        raise ArgumentError, "#{name} predicate arity is invalid"
-      end
-    end
-  end
-end