dry-validation 0.13.3 → 1.7.0

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/messages.rb

@@ -1,14 +0,0 @@
-module Dry
-  module Validation
-    module Messages
-      def self.default
-        Messages::YAML.load
-      end
-    end
-  end
-end
-
-require 'dry/validation/messages/abstract'
-require 'dry/validation/messages/namespaced'
-require 'dry/validation/messages/yaml'
-require 'dry/validation/messages/i18n' if defined?(I18n)

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/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,190 +0,0 @@
-require 'dry/configurable'
-require 'dry/validation/predicates'
-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, Dry::Validation::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

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

@@ -1,30 +0,0 @@
-require 'dry/validation/input_processor_compiler'
-
-module Dry
-  module Validation
-    class Schema
-      def self.input_processor
-        @input_processor ||=
-          begin
-            if type_map.is_a?(Dry::Types::Safe) && config.input_processor != :noop
-              type_map
-            elsif type_map.size > 0 && config.input_processor != :noop
-              build_hash_type(type_map)
-            elsif input_processor_compiler
-              input_processor_compiler.(rule_ast)
-            else
-              NOOP_INPUT_PROCESSOR
-            end
-          end
-      end
-
-      def self.input_processor_ast(type)
-        config.input_processor_map.fetch(type).schema_ast(rule_ast)
-      end
-
-      def self.input_processor_compiler
-        @input_processor_comp ||= config.input_processor_map[config.input_processor]
-      end
-    end
-  end
-end

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

@@ -1,118 +0,0 @@
-require 'dry/validation/schema/rule'
-require 'dry/validation/deprecations'
-
-module Dry
-  module Validation
-    class Schema
-      class DSL < BasicObject
-        include ::Dry::Validation::Deprecations
-
-        attr_reader :name, :registry, :rules, :checks, :parent, :options
-
-        def self.[](name, options = {})
-          new(options.merge(name: name))
-        end
-
-        def initialize(options = {})
-          @name = options[:name]
-          @path = options.fetch(:path, name)
-          @parent = options[:parent]
-          @registry = options.fetch(:registry)
-          @rules = options.fetch(:rules, [])
-          @checks = options.fetch(:checks, [])
-          @options = options
-        end
-
-        def inspect
-          to_ast.inspect
-        end
-        alias_method :to_s, :inspect
-
-        def optional(name, type_spec = nil, &block)
-          rule = define(name, Key, :then, &block)
-
-          if type_spec
-            type_map[name] = type_spec
-          end
-
-          rule
-        end
-
-        def not
-          negated = create_rule([:not, to_ast])
-          @rules = [negated]
-          self
-        end
-
-        def add_rule(rule)
-          rules << rule
-          self
-        end
-
-        def add_check(check)
-          checks << check.to_rule
-          self
-        end
-
-        def to_ast
-          ast = rules.map(&:to_ast)
-          ast.size > 1 ? [:set, ast] : ast[0] || []
-        end
-
-        def to_rule
-          create_rule(to_ast)
-        end
-
-        def rule_ast
-          rules.map(&:to_ast)
-        end
-
-        def path
-          items = [parent && parent.path, *@path].flatten.compact.uniq
-          items.size == 1 ? items[0] : items
-        end
-
-        def with(new_options)
-          self.class.new(options.merge(new_options))
-        end
-
-        def predicate(name, args = EMPTY_ARRAY)
-          [:predicate, [name, registry.arg_list(name, *args)]]
-        end
-
-        def predicate?(meth)
-          registry.key?(meth)
-        end
-
-        private
-
-        def define(name, key_class, op = :and, &block)
-          type = key_class.type
-
-          val = Value[
-            name, registry: registry, type: type, parent: self, rules: rules,
-            checks: checks, schema_class: schema_class.clone
-          ].__send__(:"#{type}?", name)
-
-          if block
-            key = key_class[name, registry: registry]
-            res = key.instance_eval(&block)
-
-            if res.class == Value
-              checks.concat(key.checks)
-              add_rule(val.__send__(op, create_rule([type, [name, res.to_ast]])))
-            else
-              add_rule(val.__send__(op, create_rule(res.to_ast)))
-            end
-          else
-            val.with(type: op)
-          end
-        end
-
-        def create_rule(node, name = self.name)
-          Schema::Rule.new(node, name: name, target: self)
-        end
-      end
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-require 'dry/validation/schema'
-require 'dry/validation/schema/params'
-require 'dry/types/compat/form_types'
-
-module Dry
-  module Validation
-    Schema::Form = Schema::Params
-  end
-end

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

@@ -1,21 +0,0 @@
-require 'dry/validation/schema'
-
-module Dry
-  module Validation
-    class Schema::JSON < Schema
-      def self.configure(klass = nil, &block)
-        if klass
-          klass.configure do |config|
-            config.input_processor = :json
-            config.hash_type = :symbolized
-          end
-          klass
-        else
-          super(&block)
-        end
-      end
-
-      configure(self)
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-require 'dry/validation/schema/dsl'
-
-module Dry
-  module Validation
-    class Schema
-      class Key < DSL
-        attr_reader :parent
-
-        def self.type
-          :key
-        end
-
-        def class
-          Key
-        end
-
-        def type
-          self.class.type
-        end
-
-        def to_ast
-          [type, [name, super]]
-        end
-
-        def each(*predicates, &block)
-          create_rule([type, [name, value.each(*predicates, &block).to_ast]])
-        end
-
-        def schema(other = nil, &block)
-          create_rule([type, [name, value.schema(other, &block).to_ast]])
-        end
-
-        def hash?(&block)
-          predicate = predicate(:hash?)
-
-          if block
-            val = value.instance_eval(&block)
-
-            rule = create_rule(predicate)
-              .and(create_rule([type, [name, val.to_ast]]))
-
-            add_rule(rule)
-            rule
-          else
-            add_rule(create_rule(predicate))
-          end
-        end
-
-        def value
-          Value[name, registry: registry]
-        end
-
-        private
-
-        def method_missing(meth, *args, &block)
-          registry.ensure_valid_predicate(meth, args)
-          predicate = predicate(meth, args)
-
-          if block
-            val = value.instance_eval(&block)
-            add_rule(create_rule([:and, [predicate, val.to_ast]]))
-          else
-            rule = create_rule([type, [name, predicate]])
-            add_rule(rule)
-            rule
-          end
-        end
-      end
-    end
-  end
-end