dry-validation 0.9.2 → 0.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 671e0b5c9aeccb3851d4d654e82be0d2cc0dc23c
-  data.tar.gz: d61862295923a7a6e4cf1dacf733606bf648c9b8
+  metadata.gz: d65d8862d070db6d2641c69e7077b4d2b9a97ee9
+  data.tar.gz: 25ce604442b2886454a39e13180b52dfc498598c
 SHA512:
-  metadata.gz: 0d9e4a6203a141ac29630a0a38dd4c29363dd7acd094f4dba55321729d6b036275111bcaae09e1764a5df4ac41c2dfe70c26b73606307c910e6c7eb56981c165
-  data.tar.gz: 4439a78095b19e8e1464395eccb49bd17394fb06f9d245e7bc7576fe8c9586067f90c3b46132db56ea967f0f87abcd16425963276fc4841c9b302e7ce8a6d340
+  metadata.gz: 1ff29e904cf720763e48e4e329a85e81695e9e2a17b093f1581ce46b295f4abf1116b216abb7f8ca9703b0ccd86473591dfa38d41d92b8da621c9abc729a3447
+  data.tar.gz: 97169242904d4bd1c05efc41ef54021b10a304b2bd92ff074632a37053e81ccaab415d228c8391fb916acd73768029cf5adc065c7c29d7eb6e0e47870d1c4830

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+# v0.9.3 2016-07-22
+
+### Added
+
+* Support for range arg in error messages for `excluded_from?` and `included_in?` (mrbongiolo)
+* `Result#message_set` returns raw message set object (solnic)
+
+### Fixed
+
+* Error messages for high-level rules in nested schemas are nested correctly (solnic)
+* Dumping error messages works with high-level rules relying on the same value (solnic)
+
+### Changed
+
+* `#messages` is no longer memoized (solnic)
+
+[Compare v0.9.2...v0.9.3](https://github.com/dryrb/dry-validation/compare/v0.9.2...v0.9.3)
+
 # v0.9.2 2016-07-13
 
 ### Fixed

data/Gemfile

@@ -10,6 +10,11 @@ end
 group :tools do
   gem 'byebug', platform: :mri
   gem 'pry'
+
+  unless ENV['TRAVIS']
+    gem 'mutant', github: 'mbj/mutant'
+    gem 'mutant-rspec', github: 'mbj/mutant'
+  end
 end
 
 group :benchmarks do

data/config/errors.yml

@@ -6,7 +6,10 @@ en:
 
     excludes?: "must not include %{value}"
 
-    excluded_from?: "must not be one of: %{list}"
+    excluded_from?:
+      arg:
+        default: "must not be one of: %{list}"
+        range: "must not be one of: %{list_left} - %{list_right}"
     exclusion?: "must not be one of: %{list}"
 
     eql?: "must be equal to %{left}"
@@ -29,7 +32,10 @@ en:
 
     hash?: "must be a hash"
 
-    included_in?: "must be one of: %{list}"
+    included_in?:
+      arg:
+        default: "must be one of: %{list}"
+        range: "must be one of: %{list_left} - %{list_right}"
     inclusion?: "must be one of: %{list}"
 
     includes?: "must include %{value}"

data/lib/dry/validation/error_compiler.rb

@@ -23,7 +23,7 @@ module Dry
 
         path.compact!
 
-        template = messages[rule, default_lookup_options]
+        template = messages[rule.is_a?(Array) ? rule.last : rule, default_lookup_options]
 
         if template
           predicate, args, tokens = visit(error, opts.merge(path: path, message: false))
@@ -60,13 +60,18 @@ module Dry
           opts[:path] << path.last
           visit(other, opts)
         else
-          visit(other, opts.merge(path: [path]))
+          visit(other, opts.merge(path: [path], schema: true))
         end
       end
 
       def visit_check(node, opts = EMPTY_HASH)
-        path, other = node
-        visit(other, opts.merge(path: Array(path)))
+        name, other = node
+
+        if opts[:schema]
+          visit(other, opts)
+        else
+          visit(other, opts.merge(path: Array(name)))
+        end
       end
 
       def lookup_options(opts, arg_vals = [])

data/lib/dry/validation/message_set.rb

@@ -18,36 +18,57 @@ module Dry
         initialize_placeholders!
       end
 
+      def dump
+        root? ? to_a : to_h
+      end
+
       def empty?
         messages.empty?
       end
 
+      def root?
+        !empty? && messages.all?(&:root?)
+      end
+
       def each(&block)
         return to_enum unless block
         messages.each(&block)
       end
 
       def with_hints!(hints)
-        @hints = hints.group_by(&:index_path)
-        freeze
+        @hints.update(hints.group_by(&:index_path))
+        self
       end
 
       def to_h
-        reduce(placeholders) do |hash, msg|
-          if msg.root?
-            (hash[nil] ||= []) << msg.to_s
-          else
-            node = msg.path.reduce(hash) { |a, e| a[e] }
-            node << msg
-            node.concat(Array(hints[msg.index_path]))
-            node.uniq!(&:signature)
+        if root?
+          { nil => map(&:to_s) }
+        else
+          group_by(&:path).reduce(placeholders) do |hash, (path, msgs)|
+            node = path.reduce(hash) { |a, e| a[e] }
+
+            msgs.each do |msg|
+              node << msg
+              msg_hints = hints[msg.index_path]
+
+              if msg_hints
+                node.concat(msg_hints)
+                node.uniq!(&:signature)
+              end
+            end
+
             node.map!(&:to_s)
+
+            hash
           end
-          hash
         end
       end
       alias_method :to_hash, :to_h
 
+      def to_a
+        to_h.values.flatten
+      end
+
       private
 
       def initialize_placeholders!

data/lib/dry/validation/result.rb

@@ -1,3 +1,5 @@
+require 'dry/validation/constants'
+
 module Dry
   module Validation
     class Result
@@ -12,13 +14,12 @@ module Dry
       alias_method :to_hash, :output
       alias_method :to_h, :output # for MRI 2.0, remove it when drop support
 
-      EMPTY_MESSAGES = {}.freeze
-
       def initialize(output, errors, error_compiler, hint_compiler)
         @output = output
         @errors = errors
         @error_compiler = error_compiler
         @hint_compiler = hint_compiler
+        @messages = EMPTY_HASH if success?
       end
 
       def each(&block)
@@ -37,22 +38,14 @@ module Dry
         !success?
       end
 
-      def messages(options = {})
-        @messages ||=
-          begin
-            return EMPTY_MESSAGES if success?
-            hints = hint_compiler.with(options).call
-            msg_set = error_compiler.with(options).(error_ast).with_hints!(hints)
-
-            as_hash = options.fetch(:as_hash, true)
+      def messages(options = EMPTY_HASH)
+        message_set(options).dump
+      end
 
-            if as_hash
-              hash = msg_set.to_h
-              hash.key?(nil) ? hash.values.flatten : hash
-            else
-              msg_set
-            end
-          end
+      def message_set(options = EMPTY_HASH)
+        error_compiler
+          .with(options).(error_ast)
+          .with_hints!(hint_compiler.with(options).())
       end
 
       def to_ast
@@ -62,7 +55,7 @@ module Dry
       private
 
       def error_ast
-        errors.map { |error| error.to_ast }
+        @error_ast ||= errors.map { |error| error.to_ast }
       end
     end
   end

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

@@ -48,7 +48,7 @@ module Dry
         target = dsl.schema_class
 
         if config.input
-          config.input_rule = dsl.__send__(:infer_predicates, Array(target.config.input))
+          config.input_rule = dsl.infer_predicates(Array(target.config.input))
         end
 
         rules = target.config.rules + (options.fetch(:rules, []) + dsl.rules)

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

@@ -171,8 +171,6 @@ module Dry
           self.class.public_methods.include?(name)
         end
 
-        private
-
         def infer_predicates(predicates, infer_on = self)
           predicates.map { |predicate|
             name, *args = ::Kernel.Array(predicate).first
@@ -187,6 +185,8 @@ module Dry
           }.reduce(:and)
         end
 
+        private
+
         def method_missing(meth, *args, &block)
           return schema_class.instance_method(meth) if dyn_arg?(meth)
 

data/lib/dry/validation/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Validation
-    VERSION = '0.9.2'.freeze
+    VERSION = '0.9.3'.freeze
   end
 end

data/spec/integration/result_spec.rb

@@ -0,0 +1,59 @@
+RSpec.describe Dry::Validation::Result do
+  subject(:result) { schema.(input) }
+
+  let(:schema) { Dry::Validation.Schema { required(:name).filled(:str?) } }
+
+  context 'with valid input' do
+    let(:input) { { name: 'Jane' } }
+
+    it 'is successful' do
+      expect(result).to be_successful
+    end
+
+    it 'is not a failure' do
+      expect(result).to_not be_failure
+    end
+
+    it 'coerces to validated hash' do
+      expect(Hash(result)).to eql(name: 'Jane')
+    end
+
+    describe '#messages' do
+      it 'returns an empty hash' do
+        expect(result.messages).to be_empty
+      end
+    end
+  end
+
+  context 'with invalid input' do
+    let(:input) { { name: '' } }
+
+    it 'is not successful' do
+      expect(result).to_not be_successful
+    end
+
+    it 'is failure' do
+      expect(result).to be_failure
+    end
+
+    it 'coerces to validated hash' do
+      expect(Hash(result)).to eql(name: '')
+    end
+
+    describe '#messages' do
+      it 'returns a hash with error messages' do
+        expect(result.messages).to eql(name: ['must be filled'])
+      end
+
+      it 'with full: true returns full messages' do
+        expect(result.messages(full: true)).to eql(name: ['name must be filled'])
+      end
+    end
+
+    describe '#message_set' do
+      it 'returns message set' do
+        expect(result.message_set.to_h).to eql(name: ['must be filled'])
+      end
+    end
+  end
+end

data/spec/integration/schema/macros/rule_spec.rb

@@ -0,0 +1,74 @@
+RSpec.describe 'Macros / rule' do
+  shared_context 'password confirmation high-level rule' do
+    subject(:schema) { schema_class.new }
+
+    let(:schema_class) do
+      Dry::Validation.Schema(build: false) do
+        required(:user).schema do
+          required(:password).filled
+          required(:password_confirmation).filled
+
+          rule(password_confirmation: %i[password_confirmation password]) do |pc, p|
+            pc.eql?(p)
+          end
+        end
+      end
+    end
+
+    it 'passes when input is valid' do
+      expect(schema.(user: { password: 'foo', password_confirmation: 'foo' })).to be_successful
+    end
+
+    it 'fails when the rule failed' do
+      expect(schema.(user: { password: 'foo', password_confirmation: 'bar' }).messages).to eql(
+        user: { password_confirmation: [error_message] }
+      )
+    end
+  end
+
+  context 'with the default message' do
+    let(:error_message) { 'must be equal to foo' }
+
+    include_context 'password confirmation high-level rule'
+  end
+
+  context 'with a custom message' do
+    let(:error_message) { 'does not match' }
+
+    before do
+      schema_class.class_eval do
+        def self.messages
+          default_messages.merge(en: { errors: { password_confirmation: 'does not match' } })
+        end
+      end
+    end
+
+    include_context 'password confirmation high-level rule'
+  end
+
+  context 'with two rules relying on the same value' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        required(:x).filled(:int?)
+
+        rule(a: [:x]) do |x|
+          x.gt?(3)
+        end
+
+        rule(b: [:x]) do |x|
+          x.gt?(5)
+        end
+      end
+    end
+
+    it 'passes when input is valid' do
+      expect(schema.(x: 6)).to be_successful
+    end
+
+    it 'fails when rules failed' do
+      expect(schema.(x: 2).messages).to eql(
+        x: ['must be greater than 3', 'must be greater than 5']
+      )
+    end
+  end
+end

data/spec/integration/schema/predicates/excluded_from/array_spec.rb

@@ -0,0 +1,459 @@
+RSpec.describe 'Predicates: Excluded From' do
+
+  context "Array" do
+
+    context 'with required' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          required(:foo) { excluded_from?([1, 3, 5]) }
+        end
+      end
+
+      context 'with valid input' do
+        let(:input) { { foo: 2 } }
+
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+
+      context 'with missing input' do
+        let(:input) { {} }
+
+        it 'is not successful' do
+          expect(result).to be_failing ['is missing', 'must not be one of: 1, 3, 5']
+        end
+      end
+
+      context 'with nil input' do
+        let(:input) { { foo: nil } }
+
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+
+      context 'with blank input' do
+        let(:input) { { foo: '' } }
+
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+
+      context 'with invalid type' do
+        let(:input) { { foo: { a: 1 } } }
+
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+
+      context 'with invalid input' do
+        let(:input) { { foo: 5 } }
+
+        it 'is not successful' do
+          expect(result).to be_failing ['must not be one of: 1, 3, 5']
+        end
+      end
+    end
+
+    context 'with optional' do
+      subject(:schema) do
+        Dry::Validation.Schema do
+          optional(:foo) { excluded_from?([1, 3, 5]) }
+        end
+      end
+
+      context 'with valid input' do
+        let(:input) { { foo: 2 } }
+
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+
+      context 'with missing input' do
+        let(:input) { {} }
+
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+
+      context 'with nil input' do
+        let(:input) { { foo: nil } }
+
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+
+      context 'with blank input' do
+        let(:input) { { foo: '' } }
+
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+
+      context 'with invalid type' do
+        let(:input) { { foo: { a: 1 } } }
+
+        it 'is successful' do
+          expect(result).to be_successful
+        end
+      end
+
+      context 'with invalid input' do
+        let(:input) { { foo: 5 } }
+
+        it 'is not successful' do
+          expect(result).to be_failing ['must not be one of: 1, 3, 5']
+        end
+      end
+    end
+
+    context 'as macro' do
+      context 'with required' do
+        context 'with value' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              required(:foo).value(excluded_from?: [1, 3, 5])
+            end
+          end
+
+          context 'with valid input' do
+            let(:input) { { foo: 2 } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with missing input' do
+            let(:input) { {} }
+
+            it 'is not successful' do
+              expect(result).to be_failing ['is missing', 'must not be one of: 1, 3, 5']
+            end
+          end
+
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with invalid type' do
+            let(:input) { { foo: { a: 1 } } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with invalid input' do
+            let(:input) { { foo: 5 } }
+
+            it 'is not successful' do
+              expect(result).to be_failing ['must not be one of: 1, 3, 5']
+            end
+          end
+        end
+
+        context 'with filled' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              required(:foo).filled(excluded_from?: [1, 3, 5])
+            end
+          end
+
+          context 'with valid input' do
+            let(:input) { { foo: 2 } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with missing input' do
+            let(:input) { {} }
+
+            it 'is not successful' do
+              expect(result).to be_failing ['is missing', 'must not be one of: 1, 3, 5']
+            end
+          end
+
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+
+            it 'is not successful' do
+              expect(result).to be_failing ['must be filled', 'must not be one of: 1, 3, 5']
+            end
+          end
+
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+
+            it 'is not successful' do
+              expect(result).to be_failing ['must be filled', 'must not be one of: 1, 3, 5']
+            end
+          end
+
+          context 'with invalid type' do
+            let(:input) { { foo: { a: 1 } } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with invalid input' do
+            let(:input) { { foo: 5 } }
+
+            it 'is not successful' do
+              expect(result).to be_failing ['must not be one of: 1, 3, 5']
+            end
+          end
+        end
+
+        context 'with maybe' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              required(:foo).maybe(excluded_from?: [1, 3, 5])
+            end
+          end
+
+          context 'with valid input' do
+            let(:input) { { foo: 2 } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with missing input' do
+            let(:input) { {} }
+
+            it 'is not successful' do
+              expect(result).to be_failing ['is missing', 'must not be one of: 1, 3, 5']
+            end
+          end
+
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with invalid type' do
+            let(:input) { { foo: { a: 1 } } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with invalid input' do
+            let(:input) { { foo: 5 } }
+
+            it 'is not successful' do
+              expect(result).to be_failing ['must not be one of: 1, 3, 5']
+            end
+          end
+        end
+      end
+
+      context 'with optional' do
+        context 'with value' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              optional(:foo).value(excluded_from?: [1, 3, 5])
+            end
+          end
+
+          context 'with valid input' do
+            let(:input) { { foo: 2 } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with missing input' do
+            let(:input) { {} }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with invalid type' do
+            let(:input) { { foo: { a: 1 } } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with invalid input' do
+            let(:input) { { foo: 5 } }
+
+            it 'is not successful' do
+              expect(result).to be_failing ['must not be one of: 1, 3, 5']
+            end
+          end
+        end
+
+        context 'with filled' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              optional(:foo).filled(excluded_from?: [1, 3, 5])
+            end
+          end
+
+          context 'with valid input' do
+            let(:input) { { foo: 2 } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with missing input' do
+            let(:input) { {} }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+
+            it 'is not successful' do
+              expect(result).to be_failing ['must be filled', 'must not be one of: 1, 3, 5']
+            end
+          end
+
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+
+            it 'is not successful' do
+              expect(result).to be_failing ['must be filled', 'must not be one of: 1, 3, 5']
+            end
+          end
+
+          context 'with invalid type' do
+            let(:input) { { foo: { a: 1 } } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with invalid input' do
+            let(:input) { { foo: 5 } }
+
+            it 'is not successful' do
+              expect(result).to be_failing ['must not be one of: 1, 3, 5']
+            end
+          end
+        end
+
+        context 'with maybe' do
+          subject(:schema) do
+            Dry::Validation.Schema do
+              optional(:foo).maybe(excluded_from?: [1, 3, 5])
+            end
+          end
+
+          context 'with valid input' do
+            let(:input) { { foo: 2 } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with missing input' do
+            let(:input) { {} }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with nil input' do
+            let(:input) { { foo: nil } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with blank input' do
+            let(:input) { { foo: '' } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with invalid type' do
+            let(:input) { { foo: { a: 1 } } }
+
+            it 'is successful' do
+              expect(result).to be_successful
+            end
+          end
+
+          context 'with invalid input' do
+            let(:input) { { foo: 5 } }
+
+            it 'is not successful' do
+              expect(result).to be_failing ['must not be one of: 1, 3, 5']
+            end
+          end
+        end
+      end
+    end
+  end
+end