dry-validation 0.6.0 → 0.7.0

data/lib/dry/validation/schema_compiler.rb

@@ -0,0 +1,38 @@
+require 'dry/logic/rule_compiler'
+
+module Dry
+  module Validation
+    class Guard
+      attr_reader :rule, :deps
+
+      def initialize(rule, deps)
+        @rule = rule
+        @deps = deps
+      end
+
+      def call(input, results)
+        rule.(input) if deps_valid?(results)
+      end
+
+      private
+
+      def deps_valid?(results)
+        deps.all? do |path|
+          result = Array(path).reduce(results) { |a, e| a[e] }
+          result.success? if result
+        end
+      end
+    end
+
+    class SchemaCompiler < Logic::RuleCompiler
+      def visit_schema(klass)
+        klass.new
+      end
+
+      def visit_guard(node)
+        deps, other = node
+        Guard.new(visit(other), deps)
+      end
+    end
+  end
+end

data/lib/dry/validation/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Validation
-    VERSION = '0.6.0'.freeze
+    VERSION = '0.7.0'.freeze
   end
 end

data/spec/fixtures/locales/pl.yml

@@ -1,6 +1,6 @@
 pl:
   errors:
-    filled?: "%{name} nie może być pusty"
+    filled?: "nie może być pusty"
     size?:
       arg:
         default: "wielkość musi być równa %{num}"

data/spec/integration/attr_spec.rb

@@ -0,0 +1,122 @@
+RSpec.describe Dry::Validation::Schema, 'defining attr-based schema' do
+  describe 'with a flat structure' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        attr(:email).required
+        attr(:age) { none? | (int? & gt?(18)) }
+      end
+    end
+
+    let(:model) { Class.new(OpenStruct) }
+
+    it 'passes when input is valid' do
+      expect(schema.(model.new(email: 'jane@doe', age: 19))).to be_success
+      expect(schema.(model.new(email: 'jane@doe', age: nil))).to be_success
+    end
+
+    it 'fails when input is not valid' do
+      expect(schema.(model.new(email: 'jane@doe', age: 17))).to_not be_success
+    end
+  end
+
+  describe 'with nested structures' do
+    subject(:schema) do
+      Dry::Validation.Schema do
+        attr(:email).required
+
+        attr(:age) { none? | (int? & gt?(18)) }
+
+        attr(:address) do
+          attr(:city) { min_size?(3) }
+
+          attr(:street).required
+
+          attr(:country) do
+            attr(:name).required
+            attr(:code).required
+          end
+        end
+
+        attr(:phone_numbers) do
+          array? { each(&:str?) }
+        end
+      end
+    end
+
+    let(:input) do
+      OpenStruct.new(
+        email: 'jane@doe.org',
+        age: 19,
+        address: OpenStruct.new(
+          city: 'NYC', street: 'Street 1/2', country: OpenStruct.new(code: 'US', name: 'USA')
+        ),
+        phone_numbers: [
+          '123456', '234567'
+        ]
+      )
+    end
+
+    describe '#messages' do
+      it 'returns compiled error messages' do
+        input.email = ''
+
+        expect(schema.(input).messages).to eql(
+          email: ['must be filled']
+        )
+      end
+    end
+
+    describe '#call' do
+      it 'passes when attributes are valid' do
+        expect(schema.(input)).to be_success
+      end
+
+      it 'validates presence of an email and min age value' do
+        input.email = ''
+        input.age = 18
+
+        expect(schema.(input).messages).to eql(
+          email: ['must be filled'], age: ['must be greater than 18']
+        )
+      end
+
+      it 'validates type of age value' do
+        input.age = '18'
+
+        expect(schema.(input).messages).to eql(
+          age: ['must be an integer', 'must be greater than 18']
+        )
+      end
+
+      it 'validates presence of phone_number keys' do
+        input.phone_numbers = nil
+
+        expect(schema.(input).messages).to eql(
+          phone_numbers: ['must be an array']
+        )
+      end
+
+      it 'validates presence of address street & county & min size of the city' do
+        input.address.city = 'NY'
+        input.address.street = nil
+        input.address.country.name = nil
+
+        expect(schema.(input).messages).to eql(
+          address: {
+            street: ['must be filled'],
+            country: { name: ['must be filled'] },
+            city: ['size cannot be less than 3']
+          }
+        )
+      end
+
+      it 'validates each phone number' do
+        input.phone_numbers = ['123', 312]
+
+        expect(schema.(input).messages).to eql(
+          phone_numbers: { 1 => ['must be a string'] }
+        )
+      end
+    end
+  end
+end

data/spec/integration/custom_error_messages_spec.rb

@@ -1,22 +1,20 @@
 require 'dry/validation/messages/i18n'
 
 RSpec.describe Dry::Validation do
-  subject(:validation) { schema.new }
-
   shared_context 'schema with customized messages' do
     describe '#messages' do
       it 'returns compiled error messages' do
-        expect(validation.(email: '').messages).to match_array([
-          [:email, [['Please provide your email'], '']]
-        ])
+        expect(schema.(email: '').messages).to eql(
+          email: ['Please provide your email']
+        )
       end
     end
   end
 
   context 'yaml' do
-    let(:schema) do
-      Class.new(Dry::Validation::Schema) do
-        configure do |config|
+    subject(:schema) do
+      Dry::Validation.Schema do
+        configure do
           config.messages_file = SPEC_ROOT.join('fixtures/locales/en.yml')
         end
 
@@ -34,9 +32,9 @@ RSpec.describe Dry::Validation do
         I18n.backend.load_translations
       end
 
-      let(:schema) do
-        Class.new(Dry::Validation::Schema) do
-          configure do |config|
+      subject(:schema) do
+        Dry::Validation.Schema do
+          configure do
             config.messages = :i18n
           end
 

data/spec/integration/custom_predicates_spec.rb

@@ -1,28 +1,36 @@
 RSpec.describe Dry::Validation do
-  subject(:validation) { schema.new }
-
   shared_context 'uses custom predicates' do
     it 'uses provided custom predicates' do
-      expect(validation.(email: 'jane@doe')).to be_empty
+      expect(schema.(email: 'jane@doe')).to be_success
 
-      expect(validation.(email: nil)).to match_array([
-        [:error, [:input, [:email, nil, [[:val, [:email, [:predicate, [:filled?, []]]]]]]]]
-      ])
+      expect(schema.(email: nil).messages).to eql(
+        email: ['must be filled', 'must be a valid email']
+      )
 
-      expect(validation.(email: 'jane')).to match_array([
-        [:error, [:input, [:email, 'jane', [[:val, [:email, [:predicate, [:email?, []]]]]]]]]
-      ])
+      expect(schema.(email: 'jane').messages).to eql(
+        email: ['must be a valid email']
+      )
+    end
+  end
+
+  let(:base_class) do
+    Class.new(Dry::Validation::Schema) do
+      def self.messages
+        Dry::Validation::Messages.default.merge(
+          en: { errors: { email?: 'must be a valid email' } }
+        )
+      end
     end
   end
 
   describe 'defining schema with custom predicates container' do
-    let(:schema) do
-      Class.new(Dry::Validation::Schema) do
-        configure do |config|
+    subject(:schema) do
+      Dry::Validation.Schema(base_class) do
+        configure do
           config.predicates = Test::Predicates
         end
 
-        key(:email) { |value| value.filled? & value.email? }
+        key(:email) { filled? & email? }
       end
     end
 
@@ -42,16 +50,58 @@ RSpec.describe Dry::Validation do
   end
 
   describe 'defining schema with custom predicate methods' do
-    let(:schema) do
-      Class.new(Dry::Validation::Schema) do
-        key(:email) { |value| value.filled? & value.email? }
+    subject(:schema) do
+      Dry::Validation.Schema(base_class) do
+        configure do
+          def email?(value)
+            value.include?('@')
+          end
+        end
+
+        key(:email) { filled? & email? }
+      end
+    end
+
+    include_context 'uses custom predicates'
+  end
 
+  describe 'custom predicate which requires an arbitrary dependency' do
+    subject(:schema) do
+      Dry::Validation.Schema(base_class) do
+        key(:email).required(:email?)
+
+        configure do
+          option :email_check
+
+          def email?(value)
+            email_check.(value)
+          end
+        end
+      end
+    end
+
+    it 'uses injected dependency for the custom predicate' do
+      email_check = -> input { input.include?('@') }
+
+      expect(schema.with(email_check: email_check).(email: 'foo').messages).to eql(
+        email: ['must be a valid email']
+      )
+    end
+  end
+
+  it 'raises an error when message is missing' do
+    schema = Dry::Validation.Schema do
+      configure do
         def email?(value)
-          value.include?('@')
+          false
         end
       end
+
+      key(:email).required(:email?)
     end
 
-    include_context 'uses custom predicates'
+    expect { schema.(email: 'foo').messages }.to raise_error(
+      Dry::Validation::MissingMessageError, /email/
+    )
   end
 end

data/spec/integration/error_compiler_spec.rb

@@ -9,239 +9,433 @@ RSpec.describe Dry::Validation::ErrorCompiler do
       en: {
         errors: {
           key?: '+%{name}+ key is missing in the hash',
-          attr?: 'Object does not respond to the +%{name}+ attr',
           rules: {
             address: {
               filled?: 'Please provide your address'
             }
           }
         }
+      },
+      pl: {
+        rules: {
+          email: 'adres email'
+        },
+        errors: {
+          email?: 'nie jest poprawny'
+        }
       }
     )
   end
 
-  describe '#call' do
+  describe '#call with flat inputs' do
     let(:ast) do
       [
-        [:error, [:input, [:name, nil, [[:key, [:name, [:predicate, [:key?, []]]]]]]]],
-        [:error, [:input, [:phone, nil, [[:attr, [:phone, [:predicate, [:attr?, []]]]]]]]],
-        [:error, [:input, [:age, 18, [[:val, [:age, [:predicate, [:gt?, [18]]]]]]]]],
-        [:error, [:input, [:email, "", [[:val, [:email, [:predicate, [:filled?, []]]]]]]]],
-        [:error, [:input, [:address, "", [[:val, [:address, [:predicate, [:filled?, []]]]]]]]]
+        [:error, [:name, [:input, [:name, [:result, [nil, [:val, [:predicate, [:key?, [:name]]]]]]]]]],
+        [:error, [:age, [:input, [:age, [:result, [18, [:val, [:predicate, [:gt?, [18]]]]]]]]]],
+        [:error, [:email, [:input, [:email, [:result, ["", [:val, [:predicate, [:filled?, []]]]]]]]]],
+        [:error, [:address, [:input, [:address, [:result, ["", [:val, [:predicate, [:filled?, []]]]]]]]]]
       ]
     end
 
     it 'converts error ast into another format' do
       expect(error_compiler.(ast)).to eql(
-        name: [["+name+ key is missing in the hash"], nil],
-        phone: [["Object does not respond to the +phone+ attr"], nil],
-        age: [["age must be greater than 18"], 18],
-        email: [["email must be filled"], ''],
-        address: [["Please provide your address"], '']
+        name: ["+name+ key is missing in the hash"],
+        age: ["must be greater than 18"],
+        email: ["must be filled"],
+        address: ["Please provide your address"]
       )
     end
   end
 
-  describe '#visit_predicate' do
+  describe '#call with check errors' do
+    let(:ast) do
+      [[:error, [:newsletter, [
+          :input, [[:settings, :newsletter], [
+            :result, [
+              [true, true],
+              [
+                :check, [
+                  :newsletter,
+                  [:implication, [
+                    [:key, [[:settings, :offers], [:predicate, [:true?, []]]]],
+                    [:key, [[:settings, :newsletter], [:predicate, [:false?, []]]]]]
+                  ]
+                ]
+              ]
+            ]
+          ]
+        ]]]
+      ]]
+    end
+
+    it 'converts error ast into another format' do
+      expect(error_compiler.(ast)).to eql(
+        settings: { newsletter: ['must be false'] }
+      )
+    end
+  end
+
+  describe '#call with arr inputs' do
+    let(:ast) do
+      [[:error, [:payments,
+        [:input, [
+          :payments, [:result, [
+              [{ method: "cc", amount: 1.23 }, { amount: 4.56 }], [:each, [
+                [:el, [
+                  1, [
+                    :result, [{ amount: 4.56 }, [:val, [:predicate, [:key?, [:method]]]]]
+                  ]
+                ]]
+              ]]]
+          ]]]
+      ]]]
+    end
+
+    it 'converts error ast into another format' do
+      expect(error_compiler.(ast)).to eql(
+        payments: { 1 => { method: ['+method+ key is missing in the hash'] } }
+      )
+    end
+  end
+
+  describe '#visit with an :input node' do
+    context 'full message' do
+      it 'returns full message including rule name' do
+        msg = error_compiler.with(full: true).visit(
+          [:input, [:num, [
+            :result, ['2', [:val, [:predicate, [:int?, []]]]]]
+          ]]
+        )
+
+        expect(msg).to eql(num: ['num must be an integer'])
+      end
+    end
+
+    context 'rule name translations' do
+      it 'translates rule name and its message' do
+        msg = error_compiler.with(locale: :pl, full: true).visit(
+          [:input, [:email, [
+            :result, ['oops', [:val, [:predicate, [:email?, []]]]]]
+          ]]
+        )
+
+        expect(msg).to eql(email: ['adres email nie jest poprawny'])
+      end
+    end
+
     describe ':empty?' do
       it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:empty?, []], [], :tags)
+        msg = error_compiler.visit(
+          [:input, [:tags, [:result, [nil, [:val, [:predicate, [:empty?, []]]]]]]]
+        )
 
-        expect(msg).to eql('tags cannot be empty')
+        expect(msg).to eql(tags: ['cannot be empty'])
       end
     end
 
     describe ':exclusion?' do
       it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:exclusion?, [[1, 2, 3]]], 2, :num)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, [2, [:val, [:predicate, [:exclusion?, [[1, 2, 3]]]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num must not be one of: 1, 2, 3')
+        expect(msg).to eql(num: ['must not be one of: 1, 2, 3'])
       end
     end
 
     describe ':inclusion?' do
       it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:inclusion?, [[1, 2, 3]]], 2, :num)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, [2, [:val, [:predicate, [:inclusion?, [[1, 2, 3]]]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num must be one of: 1, 2, 3')
+        expect(msg).to eql(num: ['must be one of: 1, 2, 3'])
       end
     end
 
     describe ':gt?' do
       it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:gt?, [3]], 2, :num)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, [2, [:val, [:predicate, [:gt?, [3]]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num must be greater than 3')
+        expect(msg).to eql(num: ['must be greater than 3'])
       end
     end
 
     describe ':gteq?' do
       it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:gteq?, [3]], 2, :num)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, [2, [:val, [:predicate, [:gteq?, [3]]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num must be greater than or equal to 3')
+        expect(msg).to eql(num: ['must be greater than or equal to 3'])
       end
     end
 
     describe ':lt?' do
       it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:lt?, [3]], 2, :num)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, [2, [:val, [:predicate, [:lt?, [3]]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num must be less than 3 (2 was given)')
+        expect(msg).to eql(num: ['must be less than 3 (2 was given)'])
       end
     end
 
     describe ':lteq?' do
       it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:lteq?, [3]], 2, :num)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, [2, [:val, [:predicate, [:lteq?, [3]]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num must be less than or equal to 3')
+        expect(msg).to eql(num: ['must be less than or equal to 3'])
       end
     end
 
     describe ':hash?' do
       it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:hash?, []], '', :address)
+        msg = error_compiler.visit(
+          [:input, [:address, [
+            :result, ['', [:val, [:predicate, [:hash?, []]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('address must be a hash')
+        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)
+        msg = error_compiler.visit(
+          [:input, [:phone_numbers, [
+            :result, ['', [:val, [:predicate, [:array?, []]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('phone_numbers must be an array')
+        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)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, ['2', [:val, [:predicate, [:int?, []]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num must be an integer')
+        expect(msg).to eql(num: ['must be an integer'])
       end
     end
 
     describe ':float?' do
       it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:float?, []], '2', :num)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, ['2', [:val, [:predicate, [:float?, []]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num must be a float')
+        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)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, ['2', [:val, [:predicate, [:decimal?, []]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num must be a decimal')
+        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)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, ['2', [:val, [:predicate, [:date?, []]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num must be a date')
+        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)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, ['2', [:val, [:predicate, [:date_time?, []]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num must be a date time')
+        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)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, ['2', [:val, [:predicate, [:time?, []]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num must be a time')
+        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)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, ['abcd', [:val, [:predicate, [:max_size?, [3]]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num size cannot be greater than 3')
+        expect(msg).to eql(num: ['size cannot be greater than 3'])
       end
     end
 
     describe ':min_size?' do
       it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:min_size?, [3]], 'ab', :num)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, ['ab', [:val, [:predicate, [:min_size?, [3]]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num size cannot be less than 3')
+        expect(msg).to eql(num: ['size cannot be less than 3'])
       end
     end
 
     describe ':none?' do
       it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:none?, []], nil, :num)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, [nil, [:val, [:predicate, [:none?, []]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num cannot be defined')
+        expect(msg).to eql(num: ['cannot be defined'])
       end
     end
 
     describe ':size?' do
       it 'returns valid message when val is array and arg is int' do
-        msg = error_compiler.visit_predicate([:size?, [3]], [1], :numbers)
+        msg = error_compiler.visit(
+          [:input, [:numbers, [
+            :result, [[1], [:val, [:predicate, [:size?, [3]]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('numbers size must be 3')
+        expect(msg).to eql(numbers: ['size must be 3'])
       end
 
       it 'returns valid message when val is array and arg is range' do
-        msg = error_compiler.visit_predicate([:size?, [3..4]], [1], :numbers)
+        msg = error_compiler.visit(
+          [:input, [:numbers, [
+            :result, [[1], [:val, [:predicate, [:size?, [3..4]]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('numbers size must be within 3 - 4')
+        expect(msg).to eql(numbers: ['size must be within 3 - 4'])
       end
 
       it 'returns valid message when arg is int' do
-        msg = error_compiler.visit_predicate([:size?, [3]], 'ab', :num)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, ['ab', [:val, [:predicate, [:size?, [3]]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num length must be 3')
+        expect(msg).to eql(num: ['length must be 3'])
       end
 
       it 'returns valid message when arg is range' do
-        msg = error_compiler.visit_predicate([:size?, [3..4]], 'ab', :num)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, ['ab', [:val, [:predicate, [:size?, [3..4]]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num length must be within 3 - 4')
+        expect(msg).to eql(num: ['length must be within 3 - 4'])
       end
     end
 
     describe ':str?' do
       it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:str?, []], 3, :num)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, [3, [:val, [:predicate, [:str?, []]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num must be a string')
+        expect(msg).to eql(num: ['must be a string'])
       end
     end
 
     describe ':bool?' do
       it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:bool?, []], 3, :num)
+        msg = error_compiler.visit(
+          [:input, [:num, [
+            :result, [3, [:val, [:predicate, [:bool?, []]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('num must be boolean')
+        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)
+        msg = error_compiler.visit(
+          [:input, [:str, [
+            :result, ['Bar', [:val, [:predicate, [:format?, [/^F/]]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('str is in invalid format')
+        expect(msg).to eql(str: ['is in invalid format'])
       end
     end
 
     describe ':eql?' do
       it 'returns valid message' do
-        msg = error_compiler.visit_predicate([:eql?, ['Bar']], 'Foo', :str)
+        msg = error_compiler.visit(
+          [:input, [:str, [
+            :result, ['Foo', [:val, [:predicate, [:eql?, ['Bar']]]]]]
+          ]]
+        )
+
+        expect(msg).to eql(str: ['must be equal to Bar'])
+      end
+    end
+
+    describe ':type??' do
+      it 'returns valid message' do
+        msg = error_compiler.visit(
+          [:input, [:age, [
+            :result, ['1', [:val, [:predicate, [:type?, [Integer]]]]]]
+          ]]
+        )
 
-        expect(msg).to eql('str must be equal to Bar')
+        expect(msg).to eql(age: ['must be Integer'])
       end
     end
   end