dry-validation 0.13.3 → 1.3.1

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

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