dry-validation 0.12.0 → 1.6.0

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

@@ -1,35 +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 get(key, options = {})
-        t.(key, options) if key
-      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,32 +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 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,54 +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 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/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

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

@@ -1,189 +0,0 @@
-require 'dry/configurable'
-require 'dry/validation/messages'
-require 'dry/validation/type_specs'
-
-module Dry
-  module Validation
-    class Schema
-      extend Dry::Configurable
-      extend TypeSpecs
-      extend PredicateRegistry::PredicateDetector
-
-      NOOP_INPUT_PROCESSOR = -> input { input }
-
-      setting :path
-      setting :predicates, Logic::Predicates
-      setting :registry
-      setting :messages, :yaml
-      setting :messages_file
-      setting :namespace
-      setting :rules, []
-      setting :checks, []
-      setting :options, {}
-      setting :input, nil
-      setting :input_rule, nil
-      setting :dsl_extensions, nil
-
-      DEFAULT_PROCESSOR_MAP = {
-        sanitizer: InputProcessorCompiler::Sanitizer.new,
-        json: InputProcessorCompiler::JSON.new,
-        params: InputProcessorCompiler::Params.new,
-      }
-
-      setting :input_processor_map, DEFAULT_PROCESSOR_MAP
-
-      setting :type_specs, false
-
-      def self.new(rules = config.rules, **options)
-        super(rules, default_options.merge(options))
-      end
-
-      def self.define(options = {}, &block)
-        source = options.fetch(:schema_class)
-        config = source.config
-
-        dsl_ext = config.dsl_extensions
-
-        options = options.merge(rules: options[:rules].dup) if options.key?(:rules)
-        dsl = Schema::Value.new(options.merge(registry: source.registry))
-        dsl_ext.__send__(:extend_object, dsl) if dsl_ext
-        dsl.predicates(options[:predicates]) if options.key?(:predicates)
-        dsl.instance_exec(&block) if block
-
-        target = dsl.schema_class
-
-        if config.input
-          config.input_rule = -> predicates {
-            Schema::Value.new(registry: predicates).infer_predicates(Array(target.config.input)).to_ast
-          }
-        end
-
-        rules = target.config.rules + (options.fetch(:rules, []) + dsl.rules)
-
-        target.configure do |cfg|
-          cfg.rules = rules
-          cfg.checks = cfg.checks + dsl.checks
-          cfg.path = dsl.path
-          cfg.type_map = target.build_type_map(dsl.type_map) if cfg.type_specs
-        end
-
-        target
-      end
-
-      def self.define!(options = {}, &block)
-        define(schema_class: self, &block)
-      end
-
-      def self.predicates(predicate_set = nil)
-        if predicate_set
-          config.predicates = predicate_set
-          set_registry!
-        else
-          config.predicates
-        end
-      end
-
-      def self.option(name, default = nil)
-        attr_reader(*name)
-        options.update(name => default)
-      end
-
-      def self.create_class(target, other = nil, &block)
-        klass =
-          if other.is_a?(self)
-            Class.new(other.class)
-          elsif other.respond_to?(:schema) && other.schema.is_a?(self)
-            Class.new(other.schema.class)
-          else
-            Validation.Schema(target.schema_class, parent: target, build: false, &block)
-          end
-
-        klass.config.path = target.path if other
-        klass.config.input_processor = :noop
-
-        klass
-      end
-
-      def self.clone
-        klass = Class.new(self)
-        klass.config.rules = []
-        klass.config.registry = registry
-        klass
-      end
-
-      def self.to_ast
-        [:schema, self]
-      end
-
-      def self.registry
-        config.registry
-      end
-
-      def self.type_map
-        config.type_map
-      end
-
-      def self.rules
-        config.rules
-      end
-
-      def self.options
-        config.options
-      end
-
-      def self.messages
-        default = default_messages
-
-        if config.messages_file && config.namespace
-          default.merge(config.messages_file).namespaced(config.namespace)
-        elsif config.messages_file
-          default.merge(config.messages_file)
-        elsif config.namespace
-          default.namespaced(config.namespace)
-        else
-          default
-        end
-      end
-
-      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.message_compiler
-        @message_compiler ||= MessageCompiler.new(messages)
-      end
-
-      def self.rule_ast
-        @rule_ast ||= config.rules.map(&:to_ast)
-      end
-
-      def self.default_options
-        @default_options ||= { predicate_registry: registry,
-          message_compiler: message_compiler,
-          input_processor: input_processor,
-          checks: config.checks }
-      end
-
-      def self.inherited(klass)
-        super
-
-        klass.config.options = klass.config.options.dup
-
-        if registry && self != Schema
-          klass.config.registry = registry.new(self)
-        else
-          klass.set_registry!
-        end
-      end
-
-      def self.set_registry!
-        config.registry = PredicateRegistry[config.predicates]
-      end
-    end
-  end
-end