dry-validation 0.1.0 → 0.2.0

data/lib/dry/validation/input_type_compiler.rb

@@ -0,0 +1,78 @@
+require 'dry/data'
+require 'dry/data/compiler'
+
+module Dry
+  module Validation
+    class InputTypeCompiler
+      attr_reader :type_compiler
+
+      TYPES = {
+        default: 'string',
+        none?: 'form.nil',
+        bool?: 'form.bool',
+        str?: 'string',
+        int?: 'form.int',
+        float?: 'form.float',
+        decimal?: 'form.decimal',
+        date?: 'form.date',
+        date_time?: 'form.date_time',
+        time?: 'form.time'
+      }.freeze
+
+      DEFAULT_TYPE_NODE = [[:type, 'string']].freeze
+
+      def initialize
+        @type_compiler = Dry::Data::Compiler.new(Dry::Data)
+      end
+
+      def call(ast)
+        schema = ast.map { |node| visit(node) }
+        type_compiler.([:type, ['hash', [:symbolized, schema]]])
+      end
+
+      def visit(node, *args)
+        send(:"visit_#{node[0]}", node[1], *args)
+      end
+
+      def visit_or(node, *args)
+        left, right = node
+        [:sum, [visit(left, *args), visit(right, *args)]]
+      end
+
+      def visit_and(node, first = true)
+        if first
+          name, type = node.map { |n| visit(n, false) }.uniq
+          [:key, [name, type]]
+        else
+          result = node.map { |n| visit(n, first) }.uniq
+
+          if result.size == 1
+            result.first
+          else
+            (result - DEFAULT_TYPE_NODE).first
+          end
+        end
+      end
+
+      def visit_implication(node)
+        [:key, node.map(&method(:visit))]
+      end
+
+      def visit_key(node, *args)
+        node[0].to_s
+      end
+
+      def visit_val(node, *args)
+        visit(node[1], *args)
+      end
+
+      def visit_set(node, *args)
+        [:type, ['hash', [:symbolized, node[1].map { |n| visit(n) }]]]
+      end
+
+      def visit_predicate(node, *args)
+        [:type, TYPES[node[0]] || TYPES[:default]]
+      end
+    end
+  end
+end

data/lib/dry/validation/messages.rb

@@ -17,13 +17,7 @@ module Dry
       end
 
       def self.load_yaml(path)
-        symbolize_keys(YAML.load_file(path))
-      end
-
-      def self.symbolize_keys(hash)
-        hash.each_with_object({}) do |(k, v), r|
-          r[k.to_sym] = v.is_a?(Hash) ? symbolize_keys(v) : v
-        end
+        Validation.symbolize_keys(YAML.load_file(path))
       end
 
       class Namespaced

data/lib/dry/validation/predicates.rb

@@ -11,7 +11,7 @@ module Dry
         other.import(self)
       end
 
-      predicate(:nil?) do |input|
+      predicate(:none?) do |input|
         input.nil?
       end
 
@@ -32,14 +32,46 @@ module Dry
         !self[:empty?].(input)
       end
 
+      predicate(:bool?) do |input|
+        input.is_a?(TrueClass) || input.is_a?(FalseClass)
+      end
+
+      predicate(:date?) do |input|
+        input.is_a?(Date)
+      end
+
+      predicate(:date_time?) do |input|
+        input.is_a?(DateTime)
+      end
+
+      predicate(:time?) do |input|
+        input.is_a?(Time)
+      end
+
       predicate(:int?) do |input|
         input.is_a?(Fixnum)
       end
 
+      predicate(:float?) do |input|
+        input.is_a?(Float)
+      end
+
+      predicate(:decimal?) do |input|
+        input.is_a?(BigDecimal)
+      end
+
       predicate(:str?) do |input|
         input.is_a?(String)
       end
 
+      predicate(:hash?) do |input|
+        input.is_a?(Hash)
+      end
+
+      predicate(:array?) do |input|
+        input.is_a?(Array)
+      end
+
       predicate(:lt?) do |num, input|
         input < num
       end

data/lib/dry/validation/result.rb

@@ -36,6 +36,14 @@ module Dry
         @rule = rule
       end
 
+      def >(other)
+        if success?
+          other.(input)
+        else
+          Validation.Result(input, true, rule)
+        end
+      end
+
       def and(other)
         if success?
           other.(input)

data/lib/dry/validation/rule.rb

@@ -5,96 +5,6 @@ module Dry
     class Rule
       include Dry::Equalizer(:name, :predicate)
 
-      class Key < Rule
-        def self.new(name, predicate)
-          super(name, predicate.curry(name))
-        end
-
-        def type
-          :key
-        end
-
-        def call(input)
-          Validation.Result(input[name], predicate.(input), self)
-        end
-      end
-
-      class Value < Rule
-        def call(input)
-          Validation.Result(input, predicate.(input), self)
-        end
-
-        def type
-          :val
-        end
-      end
-
-      class Composite
-        include Dry::Equalizer(:left, :right)
-
-        attr_reader :name, :left, :right
-
-        def initialize(left, right)
-          @name = left.name
-          @left = left
-          @right = right
-        end
-
-        def to_ary
-          [type, left.to_ary, [right.to_ary]]
-        end
-        alias_method :to_a, :to_ary
-      end
-
-      class Conjunction < Composite
-        def call(input)
-          left.(input).and(right)
-        end
-
-        def type
-          :and
-        end
-      end
-
-      class Disjunction < Composite
-        def call(input)
-          left.(input).or(right)
-        end
-
-        def type
-          :or
-        end
-      end
-
-      class Each < Rule
-        def call(input)
-          Validation.Result(input, input.map { |element| predicate.(element) }, self)
-        end
-
-        def type
-          :each
-        end
-      end
-
-      class Set < Rule
-        def call(input)
-          Validation.Result(input, predicate.map { |rule| rule.(input) }, self)
-        end
-
-        def type
-          :set
-        end
-
-        def at(*args)
-          self.class.new(name, predicate.values_at(*args))
-        end
-
-        def to_ary
-          [type, [name, predicate.map(&:to_ary)]]
-        end
-        alias_method :to_a, :to_ary
-      end
-
       attr_reader :name, :predicate
 
       def initialize(name, predicate)
@@ -117,9 +27,20 @@ module Dry
       end
       alias_method :|, :or
 
+      def then(other)
+        Implication.new(self, other)
+      end
+      alias_method :>, :then
+
       def curry(*args)
         self.class.new(name, predicate.curry(*args))
       end
     end
   end
 end
+
+require 'dry/validation/rule/key'
+require 'dry/validation/rule/value'
+require 'dry/validation/rule/each'
+require 'dry/validation/rule/set'
+require 'dry/validation/rule/composite'

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

@@ -0,0 +1,50 @@
+module Dry
+  module Validation
+    class Rule::Composite < Rule
+      include Dry::Equalizer(:left, :right)
+
+      attr_reader :name, :left, :right
+
+      def initialize(left, right)
+        @name = left.name
+        @left = left
+        @right = right
+      end
+
+      def to_ary
+        [type, [left.to_ary, right.to_ary]]
+      end
+      alias_method :to_a, :to_ary
+    end
+
+    class Rule::Implication < Rule::Composite
+      def call(input)
+        left.(input) > right
+      end
+
+      def type
+        :implication
+      end
+    end
+
+    class Rule::Conjunction < Rule::Composite
+      def call(input)
+        left.(input).and(right)
+      end
+
+      def type
+        :and
+      end
+    end
+
+    class Rule::Disjunction < Rule::Composite
+      def call(input)
+        left.(input).or(right)
+      end
+
+      def type
+        :or
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Dry
+  module Validation
+    class Rule::Each < Rule
+      def call(input)
+        Validation.Result(input, input.map { |element| predicate.(element) }, self)
+      end
+
+      def type
+        :each
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Dry
+  module Validation
+    class Rule::Key < Rule
+      def self.new(name, predicate)
+        super(name, predicate.curry(name))
+      end
+
+      def type
+        :key
+      end
+
+      def call(input)
+        Validation.Result(input[name], predicate.(input), self)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Dry
+  module Validation
+    class Rule::Set < Rule
+      def call(input)
+        Validation.Result(input, predicate.map { |rule| rule.(input) }, self)
+      end
+
+      def type
+        :set
+      end
+
+      def at(*args)
+        self.class.new(name, predicate.values_at(*args))
+      end
+
+      def to_ary
+        [type, [name, predicate.map(&:to_ary)]]
+      end
+      alias_method :to_a, :to_ary
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Dry
+  module Validation
+    class Rule::Value < Rule
+      def call(input)
+        Validation.Result(input, predicate.(input), self)
+      end
+
+      def type
+        :val
+      end
+    end
+  end
+end

data/lib/dry/validation/rule_compiler.rb

@@ -52,6 +52,11 @@ module Dry
         left, right = node
         visit(left) | visit(right)
       end
+
+      def visit_implication(node)
+        left, right = node
+        visit(left) > visit(right)
+      end
     end
   end
 end

data/lib/dry/validation/schema.rb

@@ -4,6 +4,7 @@ require 'dry/validation/error'
 require 'dry/validation/rule_compiler'
 require 'dry/validation/messages'
 require 'dry/validation/error_compiler'
+require 'dry/validation/schema/result'
 
 module Dry
   module Validation
@@ -52,14 +53,17 @@ module Dry
       end
 
       def call(input)
-        rules.each_with_object(Error::Set.new) do |rule, errors|
+        error_set = rules.each_with_object(Error::Set.new) do |rule, errors|
           result = rule.(input)
           errors << Error.new(result) if result.failure?
         end
+
+        Result.new(input, error_set)
       end
 
       def messages(input)
-        error_compiler.call(call(input).map(&:to_ary))
+        result = call(input)
+        Result.new(result.params, error_compiler.(result.to_ary))
       end
 
       def [](name)