dry-validation 0.9.5 → 0.10.0

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

@@ -31,18 +31,18 @@ module Dry
         end
 
         def hash?(&block)
-          predicate = registry[:hash?]
+          predicate = predicate(:hash?)
 
           if block
             val = value.instance_eval(&block)
 
-            rule = create_rule([:val, predicate.to_ast])
+            rule = create_rule(predicate)
               .and(create_rule([type, [name, val.to_ast]]))
 
             add_rule(rule)
             rule
           else
-            add_rule(create_rule([:val, predicate.to_ast]))
+            add_rule(create_rule(predicate))
           end
         end
 
@@ -54,13 +54,13 @@ module Dry
 
         def method_missing(meth, *args, &block)
           registry.ensure_valid_predicate(meth, args)
-          predicate = registry[meth].curry(*args)
+          predicate = predicate(meth, args)
 
           if block
             val = value.instance_eval(&block)
-            add_rule(create_rule([:and, [[:val, predicate.to_ast], val.to_ast]]))
+            add_rule(create_rule([:and, [predicate, val.to_ast]]))
           else
-            rule = create_rule([type, [name, predicate.to_ast]])
+            rule = create_rule([type, [name, predicate]])
             add_rule(rule)
             rule
           end

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

@@ -88,14 +88,14 @@ module Dry
         end
 
         def maybe(*predicates, &block)
-          left = key(:none?)
+          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.or(right)
+          rule = left.then(right)
 
           add_rule(__send__(type, rule))
         end
@@ -122,10 +122,12 @@ module Dry
         end
 
         def to_ast
+          rule_node = name ? [:rule, [name, node]] : node
+
           if deps.empty?
-            node
+            rule_node
           else
-            [:guard, [deps, node]]
+            [:guard, [deps, rule_node]]
           end
         end
 
@@ -138,22 +140,22 @@ module Dry
         end
 
         def and(other)
-          new([:and, [node, other.to_ast]])
+          new([:and, [to_ast, other.to_ast]])
         end
         alias_method :&, :and
 
         def or(other)
-          new([:or, [node, other.to_ast]])
+          new([:or, [to_ast, other.to_ast]])
         end
         alias_method :|, :or
 
         def xor(other)
-          new([:xor, [node, other.to_ast]])
+          new([:xor, [to_ast, other.to_ast]])
         end
         alias_method :^, :xor
 
         def then(other)
-          new([:implication, [node, other.to_ast]])
+          new([:implication, [to_ast, other.to_ast]])
         end
         alias_method :>, :then
 
@@ -173,6 +175,10 @@ module Dry
           self.class.new(node, options.merge(new_options))
         end
 
+        def to_rule
+          self
+        end
+
         private
 
         def method_missing(meth, *args, &block)

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

@@ -1,3 +1,4 @@
+require 'dry/struct'
 require 'dry/validation/schema/dsl'
 
 module Dry
@@ -76,26 +77,24 @@ module Dry
 
         def when(*predicates, &block)
           left = infer_predicates(predicates, Check[path, type: type, registry: registry])
+          right = Value.new(type: type, registry: registry).instance_eval(&block)
 
-          right = Value.new(type: type, registry: registry)
-          right.instance_eval(&block)
-
-          add_check(left.then(create_rule(right.to_ast)))
+          add_check(left.then(right.to_rule))
 
           self
         end
 
         def rule(id = nil, **options, &block)
           if id
-            val = Value[id, registry: registry]
+            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]
-            res = val.instance_exec(*deps.map { |name| val.value(name) }, &block)
+            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(deps: deps || [])]))
+          add_check(val.with(rules: [res.with(name: id, deps: deps || [])]))
         end
 
         def confirmation
@@ -103,17 +102,26 @@ module Dry
 
           parent.optional(conf).maybe
 
-          rule(conf => [conf, name]) { |left, right| left.eql?(right) }
+          rule(conf => [conf, name]) do |left, right|
+            left.eql?(right)
+          end
         end
 
-        def value(name)
-          check(name, registry: registry, rules: rules)
+        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
@@ -141,21 +149,15 @@ module Dry
         end
 
         def key?(name)
-          create_rule([:val, registry[:key?].curry(name).to_ast])
-        end
-
-        def predicate(name, *args)
-          registry.ensure_valid_predicate(name, args, schema_class)
-          registry[name].curry(*args)
+          create_rule(predicate(:key?, name))
         end
 
         def node(input, *args)
           if input.is_a?(::Symbol)
-            [type, [name, predicate(input, *args).to_ast]]
+            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?(::Class) && input < ::Dry::Types::Struct
-            [type, [name, [:schema, Schema.create_class(self, input)]]]
           elsif input.is_a?(Schema)
             [type, [name, schema(input).to_ast]]
           else
@@ -190,7 +192,7 @@ module Dry
         def method_missing(meth, *args, &block)
           return schema_class.instance_method(meth) if dyn_arg?(meth)
 
-          val_rule = create_rule([:val, predicate(meth, *args).to_ast])
+          val_rule = create_rule(predicate(meth, args))
 
           if block
             val = new.instance_eval(&block)

data/lib/dry/validation/schema.rb

@@ -7,11 +7,9 @@ require 'dry/validation/schema/key'
 require 'dry/validation/schema/value'
 require 'dry/validation/schema/check'
 
-require 'dry/validation/error'
 require 'dry/validation/result'
 require 'dry/validation/messages'
-require 'dry/validation/error_compiler'
-require 'dry/validation/hint_compiler'
+require 'dry/validation/message_compiler'
 
 require 'dry/validation/schema/deprecated'
 require 'dry/validation/schema/class_interface'
@@ -34,9 +32,7 @@ module Dry
 
       attr_reader :rule_compiler
 
-      attr_reader :error_compiler
-
-      attr_reader :hint_compiler
+      attr_reader :message_compiler
 
       attr_reader :options
 
@@ -49,16 +45,16 @@ module Dry
         @config = self.class.config
         @predicates = options.fetch(:predicate_registry).bind(self)
         @rule_compiler = SchemaCompiler.new(predicates, options)
-        @error_compiler = options.fetch(:error_compiler)
-        @hint_compiler = options.fetch(:hint_compiler)
+        @message_compiler = options.fetch(:message_compiler)
         @input_processor = options[:input_processor]
-        @input_rule = rule_compiler.visit(config.input_rule.to_ast) if config.input_rule
+
+        @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(config.path) do |steps|
+        @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)
@@ -74,7 +70,7 @@ module Dry
 
       def call(input)
         output, result = executor.(input)
-        Result.new(output, result, error_compiler, hint_compiler)
+        Result.new(output, result, message_compiler, config.path)
       end
 
       def curry(*curry_args)
@@ -89,9 +85,10 @@ module Dry
         1
       end
 
-      def to_ast
+      def ast(*)
         self.class.to_ast
       end
+      alias_method :to_ast, :ast
 
       private
 

data/lib/dry/validation/schema_compiler.rb

@@ -14,6 +14,10 @@ module Dry
         rule.(input) if deps_valid?(results)
       end
 
+      def with(options)
+        self.class.new(rule.with(options), deps)
+      end
+
       private
 
       def deps_valid?(results)
@@ -21,7 +25,7 @@ module Dry
           result = nil
           Array(path).each do |name|
             curr = results[name]
-            result = curr.success? if curr.respond_to?(:success)
+            result = curr.success? if curr
           end
           result
         end
@@ -37,8 +41,18 @@ module Dry
         @schema = predicates.schema
       end
 
+      def visit_rule(node)
+        id, other = node
+        visit(other).with(id: id)
+      end
+
       def visit_predicate(node)
-        super.evaluate_args!(schema)
+        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)

data/lib/dry/validation/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Validation
-    VERSION = '0.9.5'.freeze
+    VERSION = '0.10.0'.freeze
   end
 end

data/lib/dry/validation.rb

@@ -1,32 +1,16 @@
 require 'dry-equalizer'
 require 'dry-configurable'
 require 'dry-container'
+require 'dry/core/extensions'
 
 require 'dry/validation/schema'
 require 'dry/validation/schema/form'
 require 'dry/validation/schema/json'
 
 module Dry
-  # FIXME: move this to dry-logic if it works lol
-  require 'dry/logic/predicate'
-  module Logic
-    class Predicate
-      class Curried < Predicate
-        def evaluate_args!(schema)
-          @args = args.map { |arg|
-            arg.is_a?(UnboundMethod) ? arg.bind(schema).() : arg
-          }
-          self
-        end
-      end
-
-      def evaluate_args!(*)
-        self
-      end
-    end
-  end
-
   module Validation
+    extend Dry::Core::Extensions
+
     MissingMessageError = Class.new(StandardError)
     InvalidSchemaError = Class.new(StandardError)
 
@@ -45,12 +29,16 @@ module Dry
       end
     end
 
-    def self.Form(options = {}, &block)
-      Validation.Schema(Schema::Form, options, &block)
+    def self.Form(base = nil, **options, &block)
+      klass = base ? Schema::Form.configure(Class.new(base)) : Schema::Form
+      Validation.Schema(klass, options, &block)
     end
 
-    def self.JSON(options = {}, &block)
-      Validation.Schema(Schema::JSON, options, &block)
+    def self.JSON(base = Schema::JSON, **options, &block)
+      klass = base ? Schema::JSON.configure(Class.new(base)) : Schema::JSON
+      Validation.Schema(klass, options, &block)
     end
   end
 end
+
+require 'dry/validation/extensions'

data/spec/extensions/monads/result_spec.rb

@@ -0,0 +1,38 @@
+RSpec.describe Dry::Validation::Result do
+  before { Dry::Validation.load_extensions(:monads) }
+
+  let(:schema) { Dry::Validation.Schema { required(:name).filled(:str?, size?: 2..4) } }
+
+  context 'with valid input' do
+    let(:input) { { name: 'Jane' } }
+
+    describe '#to_either' do
+      it 'returns a Right instance' do
+        either = result.to_either
+
+        expect(either).to be_right
+        expect(either.value).to eql(name: 'Jane')
+      end
+    end
+  end
+
+  context 'with invalid input' do
+    let(:input) { { name: '' } }
+
+    describe '#to_either' do
+      it 'returns a Left instance' do
+        either = result.to_either
+
+        expect(either).to be_left
+        expect(either.value).to eql(name: ['must be filled', 'length must be within 2 - 4'])
+      end
+
+      it 'returns full messages' do
+        either = result.to_either(full: true)
+
+        expect(either).to be_left
+        expect(either.value).to eql(name: ['name must be filled', 'name length must be within 2 - 4'])
+      end
+    end
+  end
+end

data/spec/extensions/struct/schema_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe Dry::Validation::Schema, 'defining schema using dry struct' do
+  before do
+    Dry::Validation.load_extensions(:struct)
+  end
+
+  subject(:schema) do
+    Dry::Validation.Schema do
+      required(:person).filled(Test::Person)
+    end
+  end
+
+  before do
+    class Test::Name < Dry::Struct::Value
+      attribute :given_name, Dry::Types['strict.string']
+      attribute :family_name, Dry::Types['strict.string']
+    end
+
+    class Test::Person < Dry::Struct::Value
+      attribute :name, Test::Name
+    end
+  end
+
+  it 'handles nested structs' do
+    expect(schema.call(person: { name: { given_name: 'Tim', family_name: 'Cooper' } })).to be_success
+  end
+
+  it 'fails when input is not valid' do
+    expect(schema.call(person: { name: { given_name: 'Tim' } }).messages).to eq(
+      person: { name: { family_name: ['is missing', 'must be String'] } }
+    )
+  end
+end