dry-validation 0.13.3 → 1.0.0.alpha1

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.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,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