dry-validation 0.13.3 → 1.4.2

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

data/lib/dry/validation/predicates.rb

@@ -1,19 +0,0 @@
-require 'dry/logic/predicates'
-
-module Dry
-  module Validation
-    module Predicates
-      include Dry::Logic::Predicates
-
-      class << self
-        undef :nil?
-      end
-
-      define_singleton_method :nil?, &Object.method(:nil?)
-
-      def self.none?(input)
-        input.nil?
-      end
-    end
-  end
-end

data/lib/dry/validation/schema.rb

@@ -1,126 +0,0 @@
-require 'dry/logic/predicates'
-require 'dry/types/constraints'
-
-require 'dry/validation/predicate_registry'
-require 'dry/validation/schema_compiler'
-require 'dry/validation/schema/key'
-require 'dry/validation/schema/value'
-require 'dry/validation/schema/check'
-
-require 'dry/validation/result'
-require 'dry/validation/messages'
-require 'dry/validation/message_compiler'
-
-require 'dry/validation/schema/deprecated'
-require 'dry/validation/schema/class_interface'
-require 'dry/validation/executor'
-
-module Dry
-  module Validation
-    class Schema
-      attr_reader :config
-
-      attr_reader :input_rule
-
-      attr_reader :rules
-
-      attr_reader :checks
-
-      attr_reader :predicates
-
-      attr_reader :input_processor
-
-      attr_reader :rule_compiler
-
-      attr_reader :message_compiler
-
-      attr_reader :options
-
-      attr_reader :type_map
-
-      attr_reader :executor
-
-      def initialize(rules, options)
-        @type_map = self.class.type_map
-        @config = self.class.config
-        @predicates = options.fetch(:predicate_registry).bind(self)
-        @rule_compiler = SchemaCompiler.new(predicates, options)
-        @message_compiler = options.fetch(:message_compiler)
-        @input_processor = options[:input_processor]
-
-        @input_rule = rule_compiler.visit(config.input_rule.(predicates)) if config.input_rule
-
-        initialize_options(options)
-        initialize_rules(rules)
-        initialize_checks(options.fetch(:checks, []))
-
-        @executor = Executor.new do |steps|
-          steps << ProcessInput.new(input_processor) if input_processor
-          steps << ApplyInputRule.new(input_rule) if input_rule
-          steps << ApplyRules.new(@rules)
-          steps << ApplyChecks.new(@checks) if @checks.any?
-        end
-
-        freeze
-      end
-
-      def with(new_options)
-        self.class.new(self.class.rules, options.merge(new_options))
-      end
-
-      def call(input)
-        output, result = executor.(input)
-        Result.new(output, result, message_compiler, config.path)
-      end
-
-      def curry(*curry_args)
-        -> *args { call(*(curry_args + args)) }
-      end
-
-      def to_proc
-        -> input { call(input) }
-      end
-
-      def arity
-        1
-      end
-
-      def ast(*)
-        self.class.to_ast
-      end
-      alias_method :to_ast, :ast
-
-      private
-
-      def initialize_options(options)
-        @options = options
-
-        self.class.options.each do |name, default|
-          value = options.fetch(name) do
-            case default
-            when Proc then default.()
-            else default end
-          end
-
-          instance_variable_set("@#{name}", value)
-        end
-      end
-
-      def initialize_rules(rules)
-        @rules = rules.each_with_object({}) do |rule, result|
-          result[rule.name] = rule_compiler.visit(rule.to_ast)
-        end
-      end
-
-      def initialize_checks(checks)
-        @checks = checks.each_with_object({}) do |check, result|
-          if result.key?(check.name)
-            result[check.name] << rule_compiler.visit(check.to_ast)
-          else
-            result[check.name] = [rule_compiler.visit(check.to_ast)]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/dry/validation/schema/check.rb

@@ -1,37 +0,0 @@
-module Dry
-  module Validation
-    class Schema
-      class Check < Value
-        def class
-          Check
-        end
-
-        def schema(other = nil, &block)
-          schema = Schema.create_class(self, other, &block)
-
-          if other
-            schema.config.input_processor = other.class.config.input_processor
-          end
-
-          hash?.and(create_rule([:check, [[path], schema.to_ast]]))
-        end
-
-        private
-
-        def method_missing(meth, *meth_args)
-          vals, args = meth_args.partition { |arg| arg.class < DSL }
-
-          keys = [path, vals.map(&:path)].reject(&:empty?)
-
-          registry.ensure_valid_predicate(meth, args.size + keys.size, schema_class)
-          predicate = predicate(meth, args)
-
-          rule = create_rule([:check, [keys.reverse, predicate]], name)
-
-          add_rule(rule)
-          rule
-        end
-      end
-    end
-  end
-end