dry-validation 0.1.0 → 0.2.0

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

@@ -5,6 +5,10 @@ module Dry
         def key(name, &block)
           Key.new(name, rules).key?(&block)
         end
+
+        def optional(name, &block)
+          Key.new(name, rules).optional(&block)
+        end
       end
     end
   end

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

@@ -0,0 +1,19 @@
+require 'dry/validation/schema'
+require 'dry/validation/input_type_compiler'
+
+module Dry
+  module Validation
+    class Schema::Form < Schema
+      attr_reader :input_type
+
+      def initialize
+        super
+        @input_type = InputTypeCompiler.new.(self.class.rules.map(&:to_ary))
+      end
+
+      def call(input)
+        super(input_type[input])
+      end
+    end
+  end
+end

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

@@ -11,6 +11,19 @@ module Dry
           @rules = rules
         end
 
+        def optional(&block)
+          key_rule = key?
+
+          val_rule = yield(Value.new(name))
+
+          rules <<
+            if val_rule.is_a?(Array)
+              Schema::Rule.new([:implication, [key_rule.to_ary, [:set, [name, val_rule.map(&:to_ary)]]]])
+            else
+              Schema::Rule.new([:implication, [key_rule.to_ary, val_rule.to_ary]])
+            end
+        end
+
         private
 
         def method_missing(meth, *args, &block)
@@ -21,12 +34,12 @@ module Dry
 
             rules <<
               if val_rule.is_a?(Array)
-                Definition::Rule.new([:and, [key_rule, [:set, [name, val_rule.map(&:to_ary)]]]])
+                Schema::Rule.new([:and, [key_rule, [:set, [name, val_rule.map(&:to_ary)]]]])
               else
-                Definition::Rule.new([:and, [key_rule, val_rule.to_ary]])
+                Schema::Rule.new([:and, [key_rule, val_rule.to_ary]])
               end
           else
-            Definition::Rule.new(key_rule)
+            Schema::Rule.new(key_rule)
           end
         end
 

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

@@ -0,0 +1,29 @@
+module Dry
+  module Validation
+    class Schema::Result
+      include Dry::Equalizer(:params, :errors)
+      include Enumerable
+
+      attr_reader :params
+
+      attr_reader :errors
+
+      def initialize(params, errors)
+        @params = params
+        @errors = errors
+      end
+
+      def each(&block)
+        errors.each(&block)
+      end
+
+      def empty?
+        errors.empty?
+      end
+
+      def to_ary
+        errors.map(&:to_ary)
+      end
+    end
+  end
+end

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

@@ -1,26 +1,24 @@
 module Dry
   module Validation
     class Schema
-      module Definition
-        class Rule
-          attr_reader :node
+      class Rule
+        attr_reader :node
 
-          def initialize(node)
-            @node = node
-          end
+        def initialize(node)
+          @node = node
+        end
 
-          def to_ary
-            node
-          end
-          alias_method :to_a, :to_ary
+        def to_ary
+          node
+        end
+        alias_method :to_a, :to_ary
 
-          def &(other)
-            self.class.new([:and, [node, other.to_ary]])
-          end
+        def &(other)
+          self.class.new([:and, [node, other.to_ary]])
+        end
 
-          def |(other)
-            self.class.new([:or, [node, other.to_ary]])
-          end
+        def |(other)
+          self.class.new([:or, [node, other.to_ary]])
         end
       end
     end

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

@@ -13,13 +13,25 @@ module Dry
 
         def each(&block)
           rule = yield(self).to_ary
-          Definition::Rule.new([:each, [name, rule]])
+          Schema::Rule.new([:each, [name, rule]])
         end
 
         private
 
         def method_missing(meth, *args, &block)
-          Definition::Rule.new([:val, [name, [:predicate, [meth, args]]]])
+          rule = Schema::Rule.new([:val, [name, [:predicate, [meth, args]]]])
+
+          if block
+            val_rule = yield
+
+            if val_rule.is_a?(Schema::Rule)
+              rule & val_rule
+            else
+              Schema::Rule.new([:and, [rule.to_ary, [:set, [name, rules.map(&:to_ary)]]]])
+            end
+          else
+            rule
+          end
         end
 
         def respond_to_missing?(meth, _include_private = false)

data/lib/dry/validation/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Validation
-    VERSION = '0.1.0'.freeze
+    VERSION = '0.2.0'.freeze
   end
 end

data/spec/integration/custom_error_messages_spec.rb

@@ -26,7 +26,7 @@ RSpec.describe Dry::Validation, 'with custom messages' do
 
     describe '#messages' do
       it 'returns compiled error messages' do
-        expect(validation.messages(attrs.merge(email: ''))).to eql([
+        expect(validation.messages(attrs.merge(email: ''))).to match_array([
           [:email, ["email can't be blank"]]
         ])
       end

data/spec/integration/optional_keys_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe Dry::Validation::Schema do
+  subject(:validation) { schema.new }
+
+  describe 'defining schema with optional keys' do
+    let(:schema) do
+      Class.new(Dry::Validation::Schema) do
+        optional(:email) { |email| email.filled? }
+
+        key(:address) do |address|
+          address.key(:city, &:filled?)
+          address.key(:street, &:filled?)
+
+          address.optional(:phone_number) do |phone_number|
+            phone_number.none? | phone_number.str?
+          end
+        end
+      end
+    end
+
+    describe '#call' do
+      it 'skips rules when key is not present' do
+        expect(validation.(address: { city: 'NYC', street: 'Street 1/2' })).to be_empty
+      end
+
+      it 'applies rules when key is present' do
+        expect(validation.(email: '')).to_not be_empty
+      end
+    end
+  end
+end

data/spec/integration/schema_form_spec.rb

@@ -0,0 +1,99 @@
+require 'dry/validation/schema/form'
+
+RSpec.describe Dry::Validation::Schema::Form do
+  subject(:validation) { schema.new }
+
+  describe 'defining schema' do
+    let(:schema) do
+      Class.new(Dry::Validation::Schema::Form) do
+        key(:email) { |email| email.filled? }
+
+        key(:age) { |age| age.none? | (age.int? & age.gt?(18)) }
+
+        key(:address) do |address|
+          address.hash? do
+            address.key(:city, &:filled?)
+            address.key(:street, &:filled?)
+
+            address.key(:loc) do |loc|
+              loc.key(:lat) { |lat| lat.filled? & lat.float? }
+              loc.key(:lng) { |lng| lng.filled? & lng.float? }
+            end
+          end
+        end
+
+        optional(:phone_number) { |phone_number| phone_number.none? | phone_number.str? }
+      end
+    end
+
+    describe '#messages' do
+      it 'returns compiled error messages' do
+        result = validation.messages('email' => '', 'age' => '19')
+
+        expect(result).to match_array([
+          [:email, ["email must be filled"]],
+          [:address, ["address is missing"]]
+        ])
+
+        expect(result.params).to eql(email: '', age: 19)
+      end
+    end
+
+    describe '#call' do
+      it 'passes when attributes are valid' do
+        result = validation.(
+          'email' => 'jane@doe.org',
+          'age' => '19',
+          'address' => {
+            'city' => 'NYC',
+            'street' => 'Street 1/2',
+            'loc' => { 'lat' => '123.456', 'lng' => '456.123' }
+          }
+        )
+
+        expect(result).to be_empty
+
+        expect(result.params).to eql(
+          email: 'jane@doe.org', age: 19,
+          address: {
+            city: 'NYC', street: 'Street 1/2',
+            loc: { lat: 123.456, lng: 456.123 }
+          }
+        )
+      end
+
+      it 'validates presence of an email and min age value' do
+        expect(validation.('email' => '', 'age' => '18')).to match_array([
+          [:error, [:input, [:age, 18, [[:val, [:age, [:predicate, [:gt?, [18]]]]]]]]],
+          [:error, [:input, [:email, "", [[:val, [:email, [:predicate, [:filled?, []]]]]]]]],
+          [:error, [:input, [:address, nil, [[:key, [:address, [:predicate, [:key?, [:address]]]]]]]]]
+        ])
+      end
+
+      it 'handles optionals' do
+        result = validation.(
+          'email' => 'jane@doe.org',
+          'age' => '19',
+          'phone_number' => 12,
+          'address' => {
+            'city' => 'NYC',
+            'street' => 'Street 1/2',
+            'loc' => { 'lat' => '123.456', 'lng' => '456.123' }
+          }
+        )
+
+        expect(result).to match_array([
+          [:error, [:input, [:phone_number, 12, [[:val, [:phone_number, [:predicate, [:str?, []]]]]]]]],
+        ])
+
+        expect(result.params).to eql(
+          email: 'jane@doe.org', age: 19, phone_number: 12,
+          address: {
+            city: 'NYC', street: 'Street 1/2',
+            loc: { lat: 123.456, lng: 456.123 }
+          }
+        )
+      end
+    end
+  end
+end

data/spec/integration/{validation_spec.rb → schema_spec.rb}

@@ -1,4 +1,4 @@
-RSpec.describe Dry::Validation do
+RSpec.describe Dry::Validation::Schema do
   subject(:validation) { schema.new }
 
   describe 'defining schema' do
@@ -7,26 +7,28 @@ RSpec.describe Dry::Validation do
         key(:email) { |email| email.filled? }
 
         key(:age) do |age|
-          age.int? & age.gt?(18)
+          age.none? | (age.int? & age.gt?(18))
         end
 
         key(:address) do |address|
-          address.key(:city) do |city|
-            city.min_size?(3)
-          end
+          address.hash? do
+            address.key(:city) do |city|
+              city.min_size?(3)
+            end
 
-          address.key(:street) do |street|
-            street.filled?
-          end
+            address.key(:street) do |street|
+              street.filled?
+            end
 
-          address.key(:country) do |country|
-            country.key(:name, &:filled?)
-            country.key(:code, &:filled?)
+            address.key(:country) do |country|
+              country.key(:name, &:filled?)
+              country.key(:code, &:filled?)
+            end
           end
         end
 
         key(:phone_numbers) do |phone_numbers|
-          phone_numbers.each(&:str?)
+          phone_numbers.array? { phone_numbers.each(&:str?) }
         end
       end
     end
@@ -44,7 +46,7 @@ RSpec.describe Dry::Validation do
 
     describe '#messages' do
       it 'returns compiled error messages' do
-        expect(validation.messages(attrs.merge(email: ''))).to eql([
+        expect(validation.messages(attrs.merge(email: ''))).to match_array([
           [:email, ["email must be filled"]]
         ])
       end
@@ -91,6 +93,12 @@ RSpec.describe Dry::Validation do
         ])
       end
 
+      it 'validates address type' do
+        expect(validation.(attrs.merge(address: 'totally not a hash'))).to match_array([
+          [:error, [:input, [:address, "totally not a hash", [[:val, [:address, [:predicate, [:hash?, []]]]]]]]]
+        ])
+      end
+
       it 'validates address code and name values' do
         expect(validation.(attrs.merge(address: attrs[:address].merge(country: { code: 'US', name: '' })))).to match_array([
           [:error, [
@@ -113,6 +121,25 @@ RSpec.describe Dry::Validation do
           ]]
         ])
       end
+
+      it 'validates each phone number' do
+        expect(validation.(attrs.merge(phone_numbers: ['123', 312]))).to match_array([
+          [:error, [
+            :input, [
+              :phone_numbers, ["123", 312],
+              [
+                [
+                  :input, [
+                    :phone_numbers, 312, [
+                      [:val, [:phone_numbers, [:predicate, [:str?, []]]]]
+                    ]
+                  ]
+                ]
+              ]
+            ]
+          ]]
+        ])
+      end
     end
   end
 end

data/spec/shared/predicates.rb

@@ -1,7 +1,7 @@
 require 'dry/validation/predicates'
 
 RSpec.shared_examples 'predicates' do
-  let(:nil?) { Dry::Validation::Predicates[:nil?] }
+  let(:none?) { Dry::Validation::Predicates[:none?] }
 
   let(:str?) { Dry::Validation::Predicates[:str?] }
 

data/spec/unit/error_compiler_spec.rb

@@ -92,6 +92,22 @@ RSpec.describe Dry::Validation::ErrorCompiler do
       end
     end
 
+    describe ':hash?' do
+      it 'returns valid message' do
+        msg = error_compiler.visit_predicate([:hash?, []], '', :address)
+
+        expect(msg).to eql('address must be a hash')
+      end
+    end
+
+    describe ':array?' do
+      it 'returns valid message' do
+        msg = error_compiler.visit_predicate([:array?, []], '', :phone_numbers)
+
+        expect(msg).to eql('phone_numbers must be an array')
+      end
+    end
+
     describe ':int?' do
       it 'returns valid message' do
         msg = error_compiler.visit_predicate([:int?, []], '2', :num)
@@ -100,6 +116,46 @@ RSpec.describe Dry::Validation::ErrorCompiler do
       end
     end
 
+    describe ':float?' do
+      it 'returns valid message' do
+        msg = error_compiler.visit_predicate([:float?, []], '2', :num)
+
+        expect(msg).to eql('num must be a float')
+      end
+    end
+
+    describe ':decimal?' do
+      it 'returns valid message' do
+        msg = error_compiler.visit_predicate([:decimal?, []], '2', :num)
+
+        expect(msg).to eql('num must be a decimal')
+      end
+    end
+
+    describe ':date?' do
+      it 'returns valid message' do
+        msg = error_compiler.visit_predicate([:date?, []], '2', :num)
+
+        expect(msg).to eql('num must be a date')
+      end
+    end
+
+    describe ':date_time?' do
+      it 'returns valid message' do
+        msg = error_compiler.visit_predicate([:date_time?, []], '2', :num)
+
+        expect(msg).to eql('num must be a date time')
+      end
+    end
+
+    describe ':time?' do
+      it 'returns valid message' do
+        msg = error_compiler.visit_predicate([:time?, []], '2', :num)
+
+        expect(msg).to eql('num must be a time')
+      end
+    end
+
     describe ':max_size?' do
       it 'returns valid message' do
         msg = error_compiler.visit_predicate([:max_size?, [3]], 'abcd', :num)
@@ -146,6 +202,14 @@ RSpec.describe Dry::Validation::ErrorCompiler do
       end
     end
 
+    describe ':bool?' do
+      it 'returns valid message' do
+        msg = error_compiler.visit_predicate([:bool?, []], 3, :num)
+
+        expect(msg).to eql('num must be boolean')
+      end
+    end
+
     describe ':format?' do
       it 'returns valid message' do
         msg = error_compiler.visit_predicate([:format?, [/^F/]], 'Bar', :str)