dry-validation 0.12.0 → 1.6.0

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

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