dry-validation 0.6.0 → 0.7.0

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

@@ -1,35 +1,13 @@
 module Dry
   module Validation
     class Schema
-      class Attr < BasicObject
-        attr_reader :name, :rules
-
-        def initialize(name, rules, &block)
-          @name = name
-          @rules = rules
-        end
-
-        private
-
-        def method_missing(meth, *args, &block)
-          attr_rule = [:attr, [name, [:predicate, [meth, args]]]]
-
-          if block
-            val_rule = yield(Value.new(name))
-
-            rules <<
-              if val_rule.is_a?(::Array)
-                Schema::Rule.new(name, [:and, [attr_rule, [:set, [name, val_rule.map(&:to_ary)]]]])
-              else
-                Schema::Rule.new(name, [:and, [attr_rule, val_rule.to_ary]])
-              end
-          else
-            Schema::Rule.new(name, attr_rule)
-          end
+      class Attr < Key
+        def self.type
+          :attr
         end
 
-        def respond_to_missing?(*)
-          true
+        def class
+          Attr
         end
       end
     end

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

@@ -0,0 +1,24 @@
+module Dry
+  module Validation
+    class Schema
+      class Check < Value
+        def class
+          Check
+        end
+
+        private
+
+        def method_missing(meth, *meth_args)
+          vals, args = meth_args.partition { |arg| arg.class < DSL }
+
+          keys = [name, *vals.map(&:name)]
+          predicate = [:predicate, [meth, args]]
+
+          rule = create_rule([:check, [name, predicate, keys]])
+          add_rule(rule)
+          rule
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+require 'dry/validation/schema/rule'
+
+module Dry
+  module Validation
+    class Schema
+      class DSL < BasicObject
+        attr_reader :name, :rules, :checks, :parent, :options
+
+        def self.[](name, options = {})
+          new(options.merge(name: name))
+        end
+
+        def initialize(options = {})
+          @name = options[:name]
+          @parent = options[:parent]
+          @rules = options.fetch(:rules, [])
+          @checks = options.fetch(:checks, [])
+          @options = options
+        end
+
+        def key(name, &block)
+          define(name, Key, &block)
+        end
+
+        def optional(name, &block)
+          define(name, Key, :then, &block)
+        end
+
+        def attr(name, &block)
+          define(name, Attr, &block)
+        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
+          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 path
+          items = [parent && parent.path, name].flatten.compact.uniq
+          items.size == 1 ? items[0] : items
+        end
+
+        def with(new_options)
+          self.class.new(options.merge(new_options))
+        end
+
+        private
+
+        def define(name, key_class, op = :and, &block)
+          type = key_class.type
+
+          val = Value[
+            name, type: type, parent: self, rules: rules, checks: checks
+          ].__send__(:"#{type}?", name)
+
+          if block
+            key = key_class[name]
+            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)
+          Schema::Rule.new(node, name: name, target: self)
+        end
+      end
+    end
+  end
+end

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

@@ -1,34 +1,10 @@
 require 'dry/validation/schema'
-require 'dry/validation/input_type_compiler'
 
 module Dry
   module Validation
     class Schema::Form < Schema
-      attr_reader :input_type
-
-      def self.key(name, &block)
-        if block
-          super
-        else
-          super(name, &:filled?)
-        end
-      end
-
-      def self.optional(name, &block)
-        if block
-          super
-        else
-          super(name, &:filled?)
-        end
-      end
-
-      def initialize
-        super
-        @input_type = InputTypeCompiler.new.(self.class.rules.map(&:to_ary))
-      end
-
-      def call(input)
-        super(input_type[input])
+      configure do |config|
+        config.input_processor = :form
       end
     end
   end

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

@@ -1,49 +1,53 @@
+require 'dry/validation/schema/dsl'
+
 module Dry
   module Validation
     class Schema
-      class Key < BasicObject
-        attr_reader :name, :rules
+      class Key < DSL
+        attr_reader :parent
+
+        def self.type
+          :key
+        end
+
+        def class
+          Key
+        end
 
-        def initialize(name, rules, &block)
-          @name = name
-          @rules = rules
+        def type
+          self.class.type
         end
 
-        def optional(&block)
-          key_rule = key?
+        def to_ast
+          [type, [name, super]]
+        end
+
+        def hash?(&block)
+          val = Value[name]
+          val.instance_eval(&block)
+
+          rule = create_rule([:val, [:predicate, [:hash?, []]]])
+            .and(create_rule([type, [name, [:set, val.rules.map(&:to_ast)]]]))
 
-          val_rule = yield(Value.new(name))
+          add_rule(rule)
 
-          rules <<
-            if val_rule.is_a?(::Array)
-              Schema::Rule.new(name, [:implication, [key_rule.to_ary, [:set, [name, val_rule.map(&:to_ary)]]]])
-            else
-              Schema::Rule.new(name, [:implication, [key_rule.to_ary, val_rule.to_ary]])
-            end
+          rule
         end
 
         private
 
         def method_missing(meth, *args, &block)
-          key_rule = [:key, [name, [:predicate, [meth, args]]]]
+          predicate = [:predicate, [meth, args]]
 
           if block
-            val_rule = yield(Value.new(name))
-
-            rules <<
-              if val_rule.is_a?(::Array)
-                Schema::Rule.new(name, [:and, [key_rule, [:set, [name, val_rule.map(&:to_ary)]]]])
-              else
-                Schema::Rule.new(name, [:and, [key_rule, val_rule.to_ary]])
-              end
+            val = Value[name].instance_eval(&block)
+            add_rule(create_rule([:and, [[:val, predicate], val.to_ast]]))
           else
-            Schema::Rule.new(name, key_rule)
+            rule = create_rule([type, [name, predicate]])
+            add_rule(rule)
+            rule
           end
         end
-
-        def respond_to_missing?(*)
-          true
-        end
       end
     end
   end

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

@@ -2,73 +2,129 @@ module Dry
   module Validation
     class Schema
       class Rule < BasicObject
-        attr_reader :name, :node
+        attr_reader :name, :node, :type, :target, :deps, :options
 
-        class Check < Rule
-          def class
-            Schema::Rule::Check
-          end
+        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 method_missing(meth, *)
-            self.class.new(name, [:check, [name, [:predicate, [name, [meth]]]]])
-          end
+        def schema(other = nil, &block)
+          schema = other ? ::Class.new(other.class) : Validation.Schema(
+            target.schema_class, parent: target, build: false, &block
+          )
+
+          schema.config.path = [name] if other
+          schema.config.input_processor = :noop
+
+          rule = __send__(type, key(:hash?).and(key(schema)))
+
+          add_rule(rule)
         end
 
-        class Result < Rule
-          def class
-            Schema::Rule::Result
-          end
+        def required(*predicates)
+          rule = ([key(:filled?)] + infer_predicates(predicates)).reduce(:and)
 
-          def method_missing(meth, *args)
-            self.class.new(name, [:res, [name, [:predicate, [meth, args]]]])
-          end
+          add_rule(__send__(type, rule))
         end
 
-        def initialize(name, node)
-          @name = name
-          @node = node
+        def maybe(*predicates)
+          rule =
+            if predicates.size > 0
+              key(:none?).or(infer_predicates(predicates).reduce(:and))
+            else
+              key(:none?).or(key(:filled?))
+            end
+
+          add_rule(__send__(type, rule))
         end
 
-        def class
-          Schema::Rule
+        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 to_ary
-          node
+        def rules
+          target.rules
         end
-        alias_method :to_a, :to_ary
 
-        def to_check
-          Rule::Check.new(name, [:check, [name, [:predicate, [name, []]]]])
+        def checks
+          target.checks
         end
 
-        def is_a?(other)
-          self.class == other
+        def to_ast
+          if deps.empty?
+            node
+          else
+            [:guard, [deps, node]]
+          end
+        end
+
+        def class
+          Schema::Rule
         end
 
         def not
-          self.class.new(:"not_#{name}", [:not, node])
+          new([:not, node])
         end
 
         def and(other)
-          self.class.new(:"#{name}_and_#{other.name}", [:and, [node, other.to_ary]])
+          new([:and, [node, other.to_ast]])
         end
         alias_method :&, :and
 
         def or(other)
-          self.class.new(:"#{name}_or_#{other.name}", [:or, [node, other.to_ary]])
+          new([:or, [node, other.to_ast]])
         end
         alias_method :|, :or
 
         def xor(other)
-          self.class.new(:"#{name}_xor_#{other.name}", [:xor, [node, other.to_ary]])
+          new([:xor, [node, other.to_ast]])
         end
         alias_method :^, :xor
 
         def then(other)
-          self.class.new(:"#{name}_then_#{other.name}", [:implication, [node, other.to_ary]])
+          new([:implication, [node, other.to_ast]])
         end
         alias_method :>, :then
+
+        def infer_predicates(predicates)
+          predicates.map do |predicate|
+            name, *args = ::Kernel.Array(predicate).first
+            key(name, args)
+          end
+        end
+
+        def with(new_options)
+          self.class.new(node, options.merge(new_options))
+        end
+
+        private
+
+        def key(predicate, args = [])
+          node =
+            if predicate.is_a?(::Symbol)
+              [target.type, [name, [:predicate, [predicate, args]]]]
+            elsif predicate.is_a?(Types::Constrained)
+              [target.type, [name, predicate.rule.to_ast]]
+            else
+              [target.type, [name, predicate.to_ast]]
+            end
+
+          new(node)
+        end
+
+        def new(node)
+          self.class.new(node, options)
+        end
       end
     end
   end

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

@@ -1,52 +1,102 @@
+require 'dry/validation/schema/dsl'
+
 module Dry
   module Validation
     class Schema
-      class Value < BasicObject
-        include Schema::Definition
+      class Value < DSL
+        attr_reader :type, :schema_class
 
-        attr_reader :name, :rules, :groups, :checks
+        def initialize(options = {})
+          super
+          @type = options.fetch(:type, :key)
+          @schema_class = options.fetch(:schema_class, ::Class.new(Schema))
+        end
 
-        def initialize(name)
-          @name = name
-          @rules = []
-          @groups = []
-          @checks = []
+        def configure(&block)
+          klass = ::Class.new(schema_class, &block)
+          @schema_class = klass
+          self
         end
 
-        def each(&block)
-          val_rule = yield(self)
+        def root?
+          name.nil?
+        end
 
-          each_rule =
-            if val_rule.is_a?(Schema::Rule)
-              val_rule.to_ary
+        def class
+          Value
+        end
+
+        def each(*predicates, &block)
+          val =
+            if predicates.size > 0
+              predicates
+                .reduce(Value.new) { |a, e| a.__send__(*::Kernel.Array(e)) }
             else
-              [:set, [name, rules.map(&:to_ary)]]
+              Value[name].instance_eval(&block)
             end
 
-          Schema::Rule.new(name, [:each, [name, each_rule]])
+          rule = array?.and(create_rule([:each, val.to_ast]))
+
+          add_rule(rule) if root?
+
+          rule
+        end
+
+        def when(*predicates, &block)
+          left = predicates
+            .reduce(Check[path, type: type]) { |a, e| a.__send__(*::Kernel.Array(e)) }
+
+          right = Value.new(type: type)
+          right.instance_eval(&block)
+
+          add_check(left.then(create_rule(right.to_ast)))
+
+          self
+        end
+
+        def rule(id = nil, **options, &block)
+          if id
+            val = Value[id]
+            res = val.instance_exec(&block)
+          else
+            id, deps = options.to_a.first
+            val = Value[id]
+            res = val.instance_exec(*deps.map { |name| val.value(name) }, &block)
+          end
+
+          add_check(val.with(rules: [res.with(deps: deps || [])]))
+        end
+
+        def confirmation
+          rule = check(:"#{name}_confirmation")
+            .eql?(check(name))
+            .with(deps: [name])
+
+          add_check(rule)
+        end
+
+        def value(name)
+          check(name, rules: rules)
+        end
+
+        def check(name, options = {})
+          Check[name, options.merge(type: type)]
         end
 
         private
 
         def method_missing(meth, *args, &block)
-          rule = Schema::Rule.new(name, [:val, [name, [:predicate, [meth, args]]]])
+          val_rule = create_rule([:val, [:predicate, [meth, args]]])
 
           if block
-            val_rule = yield
+            val = Value.new.instance_eval(&block)
+            new_rule = create_rule([:and, [val_rule.to_ast, val.to_ast]])
 
-            if val_rule.is_a?(Schema::Rule)
-              rule & val_rule
-            else
-              Schema::Rule.new(name, [:and, [rule.to_ary, [:set, [name, rules.map(&:to_ary)]]]])
-            end
+            add_rule(new_rule)
           else
-            rule
+            val_rule
           end
         end
-
-        def respond_to_missing?(meth, _include_private = false)
-          true
-        end
       end
     end
   end