dry-validation 0.13.3 → 1.7.0

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

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

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

@@ -1,202 +0,0 @@
-require 'dry/validation/deprecations'
-
-module Dry
-  module Validation
-    class Schema
-      class Rule < BasicObject
-        include ::Dry::Validation::Deprecations
-
-        INVALID_PREDICATES = {
-          value: [],
-          maybe: [:empty?, :none?],
-          filled: [:empty?, :filled?],
-        }.freeze
-
-        attr_reader :name, :node, :type, :target, :deps, :options
-
-        def initialize(node, options = {})
-          @node = node
-          @type = options.fetch(:type, :and)
-          @deps = options.fetch(:deps, [])
-          @name = options.fetch(:name)
-          @target = options.fetch(:target)
-          @options = options
-        end
-
-        def inspect
-          to_ast.inspect
-        end
-        alias_method :to_s, :inspect
-
-        def schema(other = nil, &block)
-          schema = Schema.create_class(target, other, &block)
-
-          if schema.config.type_specs
-            target.type_map[name] = schema.type_map
-          end
-
-          rule = __send__(type, key(:hash?).and(key(schema)))
-          add_rule(rule)
-        end
-
-        def schema?
-          target.schema?
-        end
-
-        def registry
-          target.registry
-        end
-
-        def type_map
-          target.type_map
-        end
-
-        def type_map?
-          target.type_map?
-        end
-
-        def required(*predicates)
-          warn 'required is deprecated - use filled instead.'
-
-          filled(*predicates)
-        end
-
-        def filled(*predicates, &block)
-          left = ([key(:filled?)] + infer_predicates(predicates, :filled)).reduce(:and)
-
-          rule =
-            if block
-              left.and(Key[name, registry: registry].instance_eval(&block))
-            else
-              left
-            end
-
-          add_rule(__send__(type, rule))
-        end
-
-        def value(*predicates, &block)
-          if predicates.empty? && !block
-            ::Kernel.raise ::ArgumentError, "wrong number of arguments (given 0, expected at least 1)"
-          end
-
-          from_predicates = infer_predicates(predicates, :value).reduce(:and)
-          from_block = block ? Key[name, registry: registry].instance_eval(&block) : nil
-
-          rule = [from_predicates, from_block].compact.reduce(:and)
-
-          add_rule(__send__(type, rule))
-        end
-
-        def maybe(*predicates, &block)
-          left = key(:none?).not
-
-          from_predicates = infer_predicates(predicates, :maybe).reduce(:and)
-          from_block = block ? Key[name, registry: registry].instance_eval(&block) : nil
-
-          right = [from_predicates, from_block].compact.reduce(:and) || key(:filled?)
-
-          rule = left.then(right)
-
-          add_rule(__send__(type, rule))
-        end
-
-        def each(*predicates, &block)
-          rule = target.each(*predicates, &block)
-          add_rule(__send__(type, new([target.type, [name, rule.to_ast]])))
-        end
-
-        def add_rule(rule)
-          target.add_rule(rule)
-        end
-
-        def rules
-          target.rules
-        end
-
-        def checks
-          target.checks
-        end
-
-        def rule_ast
-          rules.size > 0 ? target.rule_ast : [to_ast]
-        end
-
-        def to_ast
-          rule_node = name ? [:rule, [name, node]] : node
-
-          if deps.empty?
-            rule_node
-          else
-            [:guard, [deps, rule_node]]
-          end
-        end
-
-        def class
-          Schema::Rule
-        end
-
-        def not
-          new([:not, node])
-        end
-
-        def and(other)
-          new([:and, [to_ast, other.to_ast]])
-        end
-        alias_method :&, :and
-
-        def or(other)
-          new([:or, [to_ast, other.to_ast]])
-        end
-        alias_method :|, :or
-
-        def xor(other)
-          new([:xor, [to_ast, other.to_ast]])
-        end
-        alias_method :^, :xor
-
-        def then(other)
-          new([:implication, [to_ast, other.to_ast]])
-        end
-        alias_method :>, :then
-
-        def infer_predicates(predicates, macro = nil)
-          predicates.flat_map(&::Kernel.method(:Array)).map do |predicate|
-            name, *args = ::Kernel.Array(predicate)
-
-            if macro && INVALID_PREDICATES[macro].include?(name)
-              ::Kernel.raise InvalidSchemaError, "you can't use #{name} predicate with #{macro} macro"
-            else
-              key(name, args)
-            end
-          end
-        end
-
-        def with(new_options)
-          self.class.new(node, options.merge(new_options))
-        end
-
-        def to_rule
-          self
-        end
-
-        private
-
-        def method_missing(meth, *args, &block)
-          if target.predicate?(meth)
-            target.__send__(meth, *args, &block)
-          else
-            super
-          end
-        end
-
-        def key(predicate, args = [])
-          new(target.node(predicate, *args))
-        end
-
-        def new(node)
-          self.class.new(node, options)
-        end
-      end
-    end
-  end
-end

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

@@ -1,211 +0,0 @@
-require 'dry/validation/schema/dsl'
-
-module Dry
-  module Validation
-    class Schema
-      class Value < DSL
-        attr_reader :type, :schema_class, :type_map
-
-        def initialize(options = {})
-          super
-          @type = options.fetch(:type, :key)
-          @schema_class = options.fetch(:schema_class, ::Class.new(Schema))
-          @options = options.merge(type: @type, schema_class: @schema_class)
-          @type_map = parent && parent.root? ? parent.type_map : {}
-        end
-
-        def predicates(mod)
-          @registry = options[:registry] = schema_class.predicates(mod)
-        end
-
-        def input(*predicates)
-          schema_class.config.input = predicates
-          self
-        end
-
-        def key(name, &block)
-          warn 'key is deprecated - use required instead.'
-
-          required(name, &block)
-        end
-
-        def required(name, type_spec = nil, &block)
-          rule = define(name, Key, &block)
-
-          if type_spec
-            type_map[name] = type_spec
-          end
-
-          rule
-        end
-
-        def schema(other = nil, &block)
-          @schema = Schema.create_class(self, other, &block)
-          type_map.update(@schema.type_map)
-          hash?.and(@schema)
-        end
-
-        def each(*predicates, &block)
-          left = array?
-
-          right =
-            if predicates.size > 0
-              create_rule([:each, infer_predicates(predicates, new).to_ast])
-            else
-              val = Value[
-                name, registry: registry, schema_class: schema_class.clone
-              ].instance_eval(&block)
-
-              if val.type_map?
-                if root?
-                  @type_map = [val.type_map]
-                else
-                  type_map[name] = [val.type_map]
-                end
-              end
-
-              create_rule([:each, val.to_ast])
-            end
-
-          rule = left.and(right)
-
-          add_rule(rule) if root?
-
-          rule
-        end
-
-        def when(*predicates, &block)
-          left = infer_predicates(predicates, Check[path, type: type, registry: registry])
-          right = Value.new(type: type, registry: registry).instance_eval(&block)
-
-          add_check(left.then(right.to_rule))
-
-          self
-        end
-
-        def rule(id = nil, **options, &block)
-          if id
-            val = Value[id, registry: registry, schema_class: schema_class]
-            res = val.instance_exec(&block)
-          else
-            id, deps = options.to_a.first
-            val = Value[id, registry: registry, schema_class: schema_class]
-            res = val.instance_exec(*deps.map { |path| val.value(id, path: path) }, &block)
-          end
-
-          add_check(val.with(rules: [res.with(name: id, deps: deps || [])]))
-        end
-
-        def confirmation
-          conf = :"#{name}_confirmation"
-
-          parent.optional(conf).maybe
-
-          rule(conf => [conf, name]) do |left, right|
-            left.eql?(right)
-          end
-        end
-
-        def value(path, opts = {})
-          check(name || path, { registry: registry, rules: rules, path: path }.merge(opts))
-        end
-
-        def check(name, options = {})
-          Check[name, options.merge(type: type)]
-        end
-
-        def validate(**opts, &block)
-          id, *deps = opts.to_a.flatten
-          name = deps.size > 1 ? id : deps.first
-          rule = create_rule([:check, [deps, [:custom, [id, block]]]], name).with(deps: deps)
-          add_check(rule)
-        end
-
-        def configure(&block)
-          schema_class.class_eval(&block)
-          @registry = schema_class.registry
-          self
-        end
-
-        def root?
-          name.nil?
-        end
-
-        def type_map?
-          ! type_map.empty?
-        end
-
-        def schema?
-          ! @schema.nil?
-        end
-
-        def class
-          Value
-        end
-
-        def new
-          self.class.new(registry: registry, schema_class: schema_class.clone)
-        end
-
-        def key?(name)
-          create_rule(predicate(:key?, name))
-        end
-
-        def node(input, *args)
-          if input.is_a?(::Symbol)
-            registry.ensure_valid_predicate(input, args, schema_class)
-            [type, [name, predicate(input, args)]]
-          elsif input.respond_to?(:rule)
-            [type, [name, [:type, input]]]
-          elsif input.is_a?(Schema)
-            [type, [name, schema(input).to_ast]]
-          else
-            [type, [name, input.to_ast]]
-          end
-        end
-
-        def dyn_arg?(name)
-          !name.to_s.end_with?('?') && schema_class.instance_methods.include?(name)
-        end
-
-        def respond_to?(name)
-          self.class.public_methods.include?(name)
-        end
-
-        def infer_predicates(predicates, infer_on = self)
-          predicates.flat_map(&::Kernel.method(:Array)).map { |predicate|
-            name, *args = ::Kernel.Array(predicate)
-
-            if name.is_a?(Schema)
-              infer_on.schema(name)
-            elsif name.respond_to?(:rule)
-              create_rule(name.rule.to_ast)
-            else
-              infer_on.__send__(name, *args)
-            end
-          }.reduce(:and)
-        end
-
-        private
-
-        def method_missing(meth, *args, &block)
-          return schema_class.instance_method(meth) if dyn_arg?(meth)
-
-          val_rule = create_rule(predicate(meth, args))
-
-          if block
-            val = new.instance_eval(&block)
-
-            type_map.update(val.type_map) if val.type_map?
-
-            new_rule = create_rule([:and, [val_rule.to_ast, val.to_ast]])
-
-            add_rule(new_rule)
-          else
-            val_rule
-          end
-        end
-      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_compiler.rb

@@ -1,81 +0,0 @@
-require 'dry/logic/rule_compiler'
-
-module Dry
-  module Validation
-    class Guard
-      attr_reader :rule, :deps
-
-      def initialize(rule, deps)
-        @rule = rule
-        @deps = deps
-      end
-
-      def call(input, results)
-        rule.(input) if deps_valid?(results)
-      end
-
-      def with(options)
-        self.class.new(rule.with(options), deps)
-      end
-
-      private
-
-      def deps_valid?(results)
-        deps.all? do |path|
-          result = nil
-          Array(path).each do |name|
-            curr = results[name]
-            if curr
-              result = curr.is_a?(Array) ? curr.first.success? : curr.success?
-            end
-          end
-          result
-        end
-      end
-    end
-
-    class SchemaCompiler < Logic::RuleCompiler
-      attr_reader :schema, :options
-
-      def initialize(*args, options)
-        super(*args)
-        @options = options
-        @schema = predicates.schema
-      end
-
-      def visit_rule(node)
-        id, other = node
-        visit(other).with(id: id)
-      end
-
-      def visit_predicate(node)
-        super.eval_args(schema)
-      end
-
-      def visit_custom(node)
-        id, predicate = node
-        Logic::Rule.new(predicate).with(id: id).bind(schema)
-      end
-
-      def visit_schema(klass)
-        opt_keys = klass.config.options.keys
-        opt_vals = options.values_at(*opt_keys).compact
-
-        if opt_vals.empty?
-          klass.new
-        else
-          klass.new(klass.config.rules, Hash[opt_keys.zip(opt_vals)])
-        end
-      end
-
-      def visit_guard(node)
-        deps, other = node
-        Guard.new(visit(other), deps)
-      end
-
-      def visit_type(type)
-        type.rule
-      end
-    end
-  end
-end

data/lib/dry/validation/template.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry/equalizer'
-
-module Dry
-  module Validation
-    module Messages
-      # Template wraps a string with interpolation tokens and defines evaluator function
-      # dynamically
-      #
-      # @api private
-      class Template
-        include Dry::Equalizer(:text)
-
-        TOKEN_REGEXP = /%{(\w*)}/
-
-        # !@attribute [r] text
-        # @return [String]
-        attr_reader :text
-
-        # !@attribute [r] tokens
-        # @return [Hash]
-        attr_reader :tokens
-
-        # !@attribute [r] evaluator
-        # @return [Proc]
-        attr_reader :evaluator
-
-        # @api private
-        def self.[](input)
-          new(*parse(input))
-        end
-
-        # @api private
-        def self.parse(input)
-          tokens = input.scan(TOKEN_REGEXP).flatten(1).map(&:to_sym)
-          text = input.gsub('%', '#')
-
-          evaluator = <<-RUBY.strip
-            -> (#{tokens.map { |token| "#{token}:" }.join(", ")}) { "#{text}" }
-          RUBY
-
-          [text, tokens, eval(evaluator, binding, __FILE__, __LINE__ - 3)]
-        end
-
-        # @api private
-        def initialize(text, tokens, evaluator)
-          @text = text
-          @tokens = tokens
-          @evaluator = evaluator
-        end
-
-        # @api private
-        def data(input)
-          tokens.each_with_object({}) { |k, h| h[k] = input[k] }
-        end
-
-        # @api private
-        def call(data = EMPTY_HASH)
-          data.empty? ? evaluator.() : evaluator.(data)
-        end
-        alias_method :[], :call
-      end
-    end
-  end
-end