nested_validator 1.0.4 → 1.0.5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    N2Q3NDk5NTYwYjY5YWQwNGIzZGJiYzM2YzIyOTNlMzUyMmE1MzQzOA==
+    OTc4N2MxNWMwNGRjZGRlNjA0MzBkNzZlZjRlZjczMGU5M2I4YjE3OQ==
   data.tar.gz: !binary |-
-    NmUxMGU2NWEyMDllNjhhNDZhMWQxZWI3ZjE1ZWQ0YmYzODFiNjUzZQ==
+    YmNhNWI2YzdjYmE1YjNhNGE0ZDdiMzY4Yzg0YWYwZmRiODUzNjk2Yg==
 SHA512:
   metadata.gz: !binary |-
-    OTI0ZmY3MGQzZmUyNGEzNzAxOWJjZTQ3N2M5ZGQ3MTNjZTEzYTgxZTI2NTBh
-    ZmY3MmJjOTgzMGFhNWIzOWJkMDU3MWRkODVkNzhiNWFkOGFlODEwZWZkZDZi
-    ODkxYThkOGE4MjRlNzQ4YTJhMzkyYmNhYTRlNDQxODhkZTA0Yjk=
+    NWY5NmU2ZjA4NmY4OWI3ZGMwMjI0NzU0ZDM4YWVjZjRlNzYzZDc5MTE4ZDM4
+    NjgxZWQyNTc3ODZhMDhlYzc4OGQyYTk4MTI1Y2Q1N2NhYmFiNmMxMTgwYzBl
+    NTEzYjhhMDM2MjMzMTI0MzQ3ZGZkY2EyNmRiNzAxZDJjZThhMTE=
   data.tar.gz: !binary |-
-    ZjJhMTQxZmY2NDM0M2IzZTg1YjJiZDI1YTY2ODhmODQ4OGJjNWJlNzkwNTNl
-    ODY3NTVhOWNmMzUzMzM2ZWFmNzE2M2E3Y2NmODkxN2FkNjg5Nzg5NzE0NDgy
-    MmU5OWIyOTcxOWI0NmUzYTdjZmE2MDdiMmI5NmE2ODQ3MmZlNTI=
+    YzkyZmRiNGJiYjFkZTRhMWIxODY0ZmFiNGZkN2Y5Mjk5ZjYyMTU5YzJkODFi
+    ODEzMWRmZDg2NjdhNjNhYzdjNTUxZWEwODY1ZjcwNTE2N2YyMjQxMjM1ZmNj
+    MzczMjU5ZmQ3MmY1ZDlmYTBiYzA1ZjYwNGUxNGM1NjA0Mzg5ODM=

data/Gemfile.lock

@@ -1,17 +1,17 @@
 PATH
   remote: .
   specs:
-    nested_validator (1.0.4)
+    nested_validator (1.0.5)
       activemodel
       activesupport
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (4.1.0)
-      activesupport (= 4.1.0)
+    activemodel (4.1.1)
+      activesupport (= 4.1.1)
       builder (~> 3.1)
-    activesupport (4.1.0)
+    activesupport (4.1.1)
       i18n (~> 0.6, >= 0.6.9)
       json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
@@ -26,8 +26,8 @@ GEM
       thor (= 0.18.1)
     diff-lcs (1.2.5)
     docile (1.1.5)
-    i18n (0.6.11)
-    json (1.8.1)
+    i18n (0.7.0)
+    json (1.8.2)
     mime-types (2.4.3)
     minitest (5.3.3)
     multi_json (1.10.1)
@@ -57,7 +57,7 @@ GEM
     term-ansicolor (1.2.2)
       tins (~> 0.8)
     thor (0.18.1)
-    thread_safe (0.3.3)
+    thread_safe (0.3.4)
     tins (0.13.2)
     tzinfo (1.1.0)
       thread_safe (~> 0.1)

data/README.md

@@ -94,6 +94,23 @@ puts parent.errors.messages
  # => {:"child attribute1"=>["can't be blank"]}
 ```
 
+### OK, is there a way to require one of several attributes?
+
+Yes. You can use the ```any``` option which requires that at least
+one of the specified child attributes is valid:
+
+``` ruby
+class ParentExcept < ParentBase
+  validates :child, nested: { any: [:attribute1, :attribute2] }
+end
+
+parent = ParentExcept.new
+parent.valid?
+puts parent.errors.messages
+
+ # => {:"child attribute1"=>["can't be blank"], :"child attribute2"=>["can't be blank"]}
+```
+
 ### Alright, what if I want a custom message?
 
 You can specify a ```prefix``` instead of the child's attribute name:
@@ -183,6 +200,7 @@ describe Parent do
   it { should validate_nested(:child).only(:attribute1, :attribute2) }
   it { should validate_nested(:child).except(:attribute1) }
   it { should validate_nested(:child).except(:attribute1, :attribute2) }
+  it { should validate_nested(:child).any(:attribute1, :attribute2) }
 end
 ```
 ## Contributing

data/lib/nested_validator/nested_validator.rb

@@ -37,7 +37,12 @@ module ActiveModel
       end
 
       def record_error(record, prefix, value)
+        if any.present?
+          valid_keys = any - value.errors.keys.map{|k| k.to_s.split.first}
+          return if valid_keys.present?
+        end
         value.errors.each do |key, error|
+          key = key.to_s.split.first
           record.errors.add(nested_key(prefix, key), error) if include?(key)
         end
       end
@@ -47,21 +52,31 @@ module ActiveModel
       end
 
       def include?(key)
-        if options[:only]
-          only.any?{|k| key =~ /^#{k}/}
-        elsif options[:except]
-          except.none?{|k| key =~ /^#{k}/}
+        if only.present?
+          only.include?(key.to_s)
+        elsif except.present?
+          !except.include?(key.to_s)
+        elsif any.present?
+          any.include?(key.to_s)
         else
           true
         end
       end
 
       def only
-        @only ||= Array.wrap(options[:only])
+        @only ||= prepare_options(:only)
       end
 
       def except
-        @except ||= Array.wrap(options[:except])
+        @except ||= prepare_options(:except)
+      end
+
+      def any
+        @any ||= prepare_options(:any)
+      end
+
+      def prepare_options(key)
+        Array.wrap(options[key]).map(&:to_s).map{|k| k.split(/\s+|,/)}.flatten.reject(&:blank?)
       end
     end
 
@@ -75,7 +90,8 @@ module ActiveModel
       #   end
       #
       #   class Child < ActiveRecord::Base
-      #     has_one :child
+      #     attr_accessor :attribute
+      #     validates     :attribute, presence: true
       #
       #     validates_presence_of :attribute
       #   end

data/lib/nested_validator/validate_nested_matcher.rb

@@ -12,10 +12,11 @@ require 'rspec/expectations'
 #       it { should validate_nested(:child).only(:attribute1) }
 #       it { should validate_nested(:child).only(:attribute1, :attribute2) }
 #       it { should validate_nested(:child).except(:attribute1) }
+#       it { should validate_nested(:child).any(:attribute1, :attribute2) }
 #     end
 RSpec::Matchers.define :validate_nested do |child_name|
 
-  attr_accessor :child_name, :prefix, :only_keys, :except_keys # inputs
+  attr_accessor :child_name, :prefix, :only_keys, :except_keys, :any_keys
   attr_accessor :parent, :actual_keys
 
   TEST_KEY ||= :__test_key__
@@ -24,6 +25,7 @@ RSpec::Matchers.define :validate_nested do |child_name|
     self.prefix      ||= ''
     self.only_keys   ||= []
     self.except_keys ||= []
+    self.any_keys    ||= []
 
     self.child_name  = child_name
     self.parent      = parent
@@ -32,20 +34,28 @@ RSpec::Matchers.define :validate_nested do |child_name|
     self.actual_keys = (error_keys_when_child_validity_is(false) - error_keys_when_child_validity_is(true))
     return false if invalid_child_keys.present?
 
-
     actual_keys == expected_keys
   end
 
+  def prepare_keys(keys)
+    if keys.length == 1 && keys[0].is_a?(String)
+      keys[0].split(/\s+|,/).reject(&:blank?)
+    else
+      keys
+    end
+  end
+
   chain(:with_prefix) { |prefix|  self.prefix      = prefix }
-  chain(:only)        { |*only|   self.only_keys   = only   }
-  chain(:except)      { |*except| self.except_keys = except }
+  chain(:only)        { |*only|   self.only_keys   = prepare_keys(only)   }
+  chain(:except)      { |*except| self.except_keys = prepare_keys(except) }
+  chain(:any)         { |*any|    self.any_keys    = prepare_keys(any) }
 
   def child
-    parent.send child_name
+    parent.public_send child_name
   end
 
   def error_keys_when_child_validity_is(valid)
-    child_error_keys = combine TEST_KEY, only_keys, except_keys
+    child_error_keys = combine TEST_KEY, only_keys, except_keys, any_keys
     child_errors = child_error_keys.inject({}){|result, key| result[key] = ['error message'];result }
 
     allow(child).to receive(:valid?) { valid }
@@ -68,8 +78,15 @@ RSpec::Matchers.define :validate_nested do |child_name|
   end
 
   def expected_child_keys
-    expected_keys = only_keys.present? ? only_keys : [TEST_KEY]
-    unique_except_keys = except_keys - only_keys
+    expected_keys = case
+      when only_keys.present?
+        only_keys
+      when any_keys.present?
+        any_keys
+      else
+        [TEST_KEY]
+    end
+    unique_except_keys = except_keys - only_keys - any_keys
     combine expected_keys - unique_except_keys
   end
 
@@ -78,6 +95,7 @@ RSpec::Matchers.define :validate_nested do |child_name|
   end
 
   def invalid_child_keys
+    #binding.pry
     (only_keys + except_keys).reject{|key| child.respond_to? key}
   end
 
@@ -85,6 +103,7 @@ RSpec::Matchers.define :validate_nested do |child_name|
     message =  "validate nested #{show child_name}"
     message << " with only: #{show only_keys}" if only_keys.present?
     message << " except: #{show except_keys}"  if except_keys.present?
+    message << " any: #{show any_keys}"        if any_keys.present?
     message << " with prefix #{show prefix}"   if prefix.present?
     message
   end

data/lib/nested_validator/version.rb

@@ -1,3 +1,3 @@
 module NestedValidator
-  VERSION = '1.0.4'
+  VERSION = '1.0.5'
 end

data/spec/lib/nested_validator/nested_validator_context.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+require 'nested_validator'
+
+shared_context 'nested validator' do
+  let(:parent_class) do
+    opts = options
+    Class.new {
+      include ActiveModel::Validations
+
+      attr_accessor :child, :other
+
+      instance_eval "validates :child, nested: #{opts}"
+
+      def initialize(child=nil)
+        self.child = child
+        self.other = ''
+      end
+
+      def to_s
+        'parent'
+      end
+    }
+  end
+
+  let(:options) { 'true' }
+
+  let(:child_class) do
+    Class.new {
+      include ActiveModel::Validations
+
+      attr_accessor :attribute, :attribute2, :attribute3
+
+      validates :attribute, presence: true
+      validates :attribute2, presence: true
+      validates :attribute3, presence: true
+
+      def self.model_name
+        ActiveModel::Name.new(self, nil, 'temp')
+      end
+    }
+  end
+end

data/spec/lib/nested_validator/nested_validator_spec.rb

@@ -1,218 +1,269 @@
-require 'spec_helper'
-require 'nested_validator'
+require_relative 'nested_validator_context'
 
-describe NestedValidator do
-  let(:base_class) do
-    Class.new {
-      include ActiveModel::Validations
-
-      # To keep ActiveModel happy
-      def self.model_name
-        ActiveModel::Name.new(self, nil, 'temp')
-      end
-    }
+RSpec::Matchers.define :detect_nested_error_for do
+  match do
+    subject.valid?
+    error.present?
   end
 
-  let(:parent_class) do
-    Class.new(base_class) {
-      attr_accessor :child1, :child2
-    }
+  def description
+    "detect an error for '#{child_attribute}'"
   end
 
-  let(:child_class) do
-    Class.new(base_class) {
-      attr_accessor :attribute1
-      validates     :attribute1, presence: true
-
-      attr_accessor :attribute2
-      validates     :attribute2, presence: true
-
-      attr_accessor :attribute3
-      validates     :attribute3, presence: true
-
-      def initialize
-        @attribute1 = 'valid'
-        @attribute2 = 'valid'
-        @attribute3 = 'valid'
-      end
-    }
+  failure_message do
+    "has no error for '#{child_attribute}'"
   end
 
-  let(:child1) { child_class.new }
-  let(:child2) { child_class.new }
-
-  def parent_with(&block)
-    parent = Class.new(parent_class) { instance_exec &block }.new
-    parent.child1 = child1
-    parent.child2 = child2
-    parent
+  failure_message_when_negated do
+    "has an error '#{child_attribute}' => '#{error}'"
   end
 
-  def with_nested_options(options)
-    parent_with { validates :child1, nested: options }
+  def error
+    subject.errors[child_attribute].first
   end
 
-  shared_examples 'valid:' do |child_name, *attributes|
-    attributes.each do |attribute|
-      specify "when #{child_name}.#{attribute} set to nil" do
-        send(child_name).send("#{attribute}=", nil)
-        expect(subject).to be_valid
-      end
-    end
+  def attribute
+    expected
   end
 
-  shared_examples 'invalid:' do |child_name, *attributes|
-    attributes.each do |attribute|
-      specify "when #{child_name}.#{attribute} set to nil" do
-        send(child_name).send("#{attribute}=", nil)
-        expect(subject).to be_invalid
-      end
-    end
+  def attribute_display_value
+    "#{subject.child.send(attribute) || 'nil'}"
   end
 
-  describe 'with "nested: true"' do
-    subject { with_nested_options true }
-
-    it_should_validate_nested 'invalid:', :child1, :attribute1, :attribute2, :attribute3
+  def child_attribute
+    :"child #{attribute}"
   end
+end
 
-  describe 'error messages' do
-    context 'with scalar values' do
-      before  { child1.attribute1 = nil;subject.valid? }
-
-      describe 'with no prefix' do
-        subject { with_nested_options true }
+describe 'nested validation' do
 
-        its('errors.messages') { should eq :'child1 attribute1' => ["can't be blank"] }
-      end
+  include_context 'nested validator'
 
-      describe 'with "prefix: "OMG"' do
-        subject { with_nested_options prefix: 'OMG' }
+  let(:options) { 'true' }
+  let(:parent)  { parent_class.new child }
+  let(:child)   { child_class.new }
 
-        its('errors.messages') { puts subject.errors.messages; should eq :'OMG attribute1' => ["can't be blank"] }
-      end
+  subject { parent }
 
-      describe 'with "prefix: ""' do
-        subject { with_nested_options prefix: '' }
+  let(:options) { self.class.description }
 
-        its('errors.messages') { should eq :'attribute1' => ["can't be blank"] }
-      end
+  describe 'should support boolean value' do
+    describe 'true' do
+      it { should detect_nested_error_for :attribute }
     end
 
-    context 'with an array of values' do
-      let(:child1) { [child_class.new, child_class.new]  }
-
-      before  { child1[0].attribute1 = nil;subject.valid? }
-      subject { with_nested_options true }
+    describe 'false' do
+      it { should_not detect_nested_error_for :attribute }
+    end
+  end
 
-      describe 'with single invalid value' do
-        its('errors.messages') { should eq :'child1[0] attribute1' => ["can't be blank"] }
+  describe '"only" should be ignored if value missing' do
+    ['{only: ""}',
+     '{only: nil}',
+    ].each do |only|
+      describe only do
+        it { should detect_nested_error_for :attribute }
+        it { should detect_nested_error_for :attribute2 }
+        it { should detect_nested_error_for :attribute3 }
       end
+    end
+  end
 
-      describe 'with multiple invalid values' do
-        before  { child1[1].attribute1 = nil;subject.valid? }
-        its('errors.messages') { should include :'child1[0] attribute1' => ["can't be blank"] }
-        its('errors.messages') { should include :'child1[1] attribute1' => ["can't be blank"] }
+  describe '"only" should support a single key' do
+    ['{only: :attribute}',
+     '{only: "attribute"}',
+     '{only: " \tattribute\t\n"}'
+    ].each do |only|
+      describe only do
+        it { should     detect_nested_error_for :attribute }
+        it { should_not detect_nested_error_for :attribute2 }
+        it { should_not detect_nested_error_for :attribute3 }
       end
+    end
+  end
 
-      context 'with a prefix' do
-        subject { with_nested_options prefix: 'OMG' }
-
-        its('errors.messages') { should eq :'OMG[0] attribute1' => ["can't be blank"] }
+  describe '"only" should support multiple keys' do
+    ['{only: [:attribute, :attribute2]}',
+     '{only: "attribute attribute2"}',
+     '{only: "attribute, attribute2"}',
+     '{only: " \tattribute,\n\tattribute2\t\n"}'
+    ].each do |only|
+      describe only do
+        it { should     detect_nested_error_for :attribute }
+        it { should     detect_nested_error_for :attribute2 }
+        it { should_not detect_nested_error_for :attribute3 }
       end
     end
   end
 
-  context 'with a hash of values' do
-    let(:child1) { { first: child_class.new, second: child_class.new }  }
-
-    before  { child1[:first].attribute1 = nil;subject.valid? }
-    subject { with_nested_options true }
-
-    describe 'with single invalid value' do
-      its('errors.messages') { should eq :'child1[first] attribute1' => ["can't be blank"] }
+  describe '"except" should be ignored if value missing' do
+    ['{except: ""}',
+     '{except: nil}',
+    ].each do |only|
+      describe only do
+        it { should detect_nested_error_for :attribute }
+        it { should detect_nested_error_for :attribute2 }
+        it { should detect_nested_error_for :attribute3 }
+      end
     end
+  end
 
-    describe 'with multiple invalid values' do
-      before  { child1[:second].attribute1 = nil;subject.valid? }
-      its('errors.messages') { should include :'child1[first] attribute1' => ["can't be blank"] }
-      its('errors.messages') { should include :'child1[second] attribute1' => ["can't be blank"] }
+  describe '"except" should support a single key' do
+    ['{except: :attribute}',
+     '{except: "attribute"}',
+     '{except: " \tattribute\t\n"}'
+    ].each do |only|
+      describe only do
+        it { should_not detect_nested_error_for :attribute }
+        it { should     detect_nested_error_for :attribute2 }
+        it { should     detect_nested_error_for :attribute2 }
+      end
     end
+  end
 
-    context 'with a prefix' do
-      subject { with_nested_options prefix: 'OMG' }
-
-      its('errors.messages') { should eq :'OMG[first] attribute1' => ["can't be blank"] }
+  describe '"except" should support multiple keys' do
+    ['{except: [:attribute, :attribute2]}',
+     '{except: "attribute attribute2"}',
+     '{except: "attribute, attribute2"}',
+     '{except: " \tattribute,\n\tattribute2\t\n"}'
+    ].each do |only|
+      describe only do
+        it { should_not detect_nested_error_for :attribute }
+        it { should_not detect_nested_error_for :attribute2 }
+        it { should     detect_nested_error_for :attribute3 }
+      end
     end
   end
 
-  describe '"validates :child1, nested: {only: ...}"' do
-
-    describe 'with "only: :attribute1"' do
-
-      subject { with_nested_options only: :attribute1 }
-
-      it_should_validate_nested 'invalid:', :child1, :attribute1
-      it_should_validate_nested 'valid:',   :child1, :attribute2, :attribute3
+  describe '"any" should be ignored if value missing' do
+    ['{any: ""}',
+     '{any: nil}',
+    ].each do |only|
+      describe only do
+        it { should detect_nested_error_for :attribute }
+        it { should detect_nested_error_for :attribute2 }
+        it { should detect_nested_error_for :attribute3 }
+      end
     end
+  end
 
-    describe 'with "only: [:atnested_validator_spec.rbtribute1, :attribute2]"' do
+  describe '"any" should behave like "only" with a single key' do
+    [
+     '{any: :attribute}',
+     '{any: "attribute"}',
+     '{any: " \tattribute\t\n"}'
+    ].each do |only|
+      describe only do
+        it { should     detect_nested_error_for :attribute }
+        it { should_not detect_nested_error_for :attribute2 }
+        it { should_not detect_nested_error_for :attribute3 }
+      end
+    end
+  end
 
-      subject { parent_with { validates :child1, nested: { only: [:attribute1, :attribute2] } } }
+  describe '"any" should not detect errors if first attribute valid' do
+    before { child.attribute = true }
+
+    ['{any: [:attribute, :attribute2]}',
+     '{any: "attribute attribute2"}',
+     '{any: "attribute, attribute2"}',
+     '{any: " \tattribute,\n\tattribute2\t\n"}'
+    ].each do |only|
+      describe only do
+        it { should_not detect_nested_error_for :attribute }
+        it { should_not detect_nested_error_for :attribute2 }
+        it { should_not detect_nested_error_for :attribute3 }
+      end
+    end
+  end
 
-      it_should_validate_nested 'invalid:', :child1, :attribute1, :attribute2
-      it_should_validate_nested 'valid:',   :child1, :attribute3
+  describe '"any" should not detect errors if second attribute valid' do
+    before { child.attribute2 = true }
+
+    ['{any: [:attribute, :attribute2]}',
+     '{any: "attribute attribute2"}',
+     '{any: "attribute, attribute2"}',
+     '{any: " \tattribute,\n\tattribute2\t\n"}'
+    ].each do |only|
+      describe only do
+        it { should_not detect_nested_error_for :attribute }
+        it { should_not detect_nested_error_for :attribute2 }
+        it { should_not detect_nested_error_for :attribute3 }
+      end
     end
   end
 
-  describe '"validates :child1, nested: {except: ...}"' do
-    describe 'with "except: :attribute1"' do
-      subject { with_nested_options except: :attribute1 }
+  describe 'error message keys' do
+    before { parent.valid? }
+    subject { parent.errors.messages.keys.first }
 
-      it_should_validate_nested 'invalid:', :child1, :attribute2, :attribute3
-      it_should_validate_nested 'valid:',   :child1, :attribute1
-    end
+    context('true')            { it { should eq :'child attribute' } }
+    context('{prefix: ""}')    { it { should eq :'attribute' } }
+    context('{prefix: nil}')   { it { should eq :'attribute' } }
+    context('{prefix: "OMG"}') { it { should eq :'OMG attribute' } }
 
-    describe 'with "except: [:attribute1, :attribute2"' do
-      subject { with_nested_options except: [:attribute1, :attribute2] }
+    context 'with arrays' do
+      let(:child) { [child_class.new] }
 
-      it_should_validate_nested 'invalid:', :child1, :attribute3
-      it_should_validate_nested 'valid:',   :child1, :attribute1, :attribute2
+      context('true')            { it { should eq :'child[0] attribute' } }
+      context('{prefix: ""}')    { it { should eq :'[0] attribute' } }
+      context('{prefix: nil}')   { it { should eq :'[0] attribute' } }
+      context('{prefix: "OMG"}') { it { should eq :'OMG[0] attribute' } }
     end
-  end
 
-  describe 'attributes in "only" option should take precedence over "except"' do
-    describe '"validates :child1, nested: {only: attribute1, except: :attribute1}"' do
-      subject { with_nested_options only: :attribute1, except: :attribute1 }
+    context('with hashes') do
+      let(:child) { {key: child_class.new} }
 
-      it_should_validate_nested 'invalid:', :child1, :attribute1
-      it_should_validate_nested 'valid:',   :child1, :attribute2, :attribute3
+      context('true')            { it { should eq :'child[key] attribute' } }
+      context('{prefix: ""}')    { it { should eq :'[key] attribute' } }
+      context('{prefix: nil}')   { it { should eq :'[key] attribute' } }
+      context('{prefix: "OMG"}') { it { should eq :'OMG[key] attribute' } }
     end
   end
 
-  describe 'validates_nested' do
+  describe 'multiple levels' do
+    let(:grand_parent_class) do
+      opts = parent_options
+      Class.new {
+        include ActiveModel::Validations
 
-    describe 'validates_nested :child1' do
-      subject { parent_with { validates_nested :child1 } }
+        attr_accessor :parent
 
-      it_should_validate_nested 'invalid:', :child1,  :attribute1, :attribute2, :attribute3
-      it_should_validate_nested 'valid:',   :child2,  :attribute1, :attribute2, :attribute3
-    end
+        instance_eval "validates :parent, nested: #{opts}"
 
-    describe 'validates_nested :child1, :child2' do
-      subject { parent_with { validates_nested :child1, :child2 } }
+        def initialize(parent=nil)
+          self.parent = parent
+        end
 
-      it_should_validate_nested 'invalid:', :child1, :attribute1, :attribute2, :attribute3
-      it_should_validate_nested 'invalid:', :child2, :attribute1, :attribute2, :attribute3
+        def to_s
+          'grand_parent'
+        end
+      }
     end
 
-    describe 'validates_nested :child1, :child2, only: :attribute1' do
-      subject { parent_with { validates_nested :child1, :child2, only: :attribute1 } }
+    let(:grand_parent)   { grand_parent_class.new parent }
+    let(:parent_options) { self.class.description }
+    let(:options)        { 'true' }
+
+    [
+      '{only:   :other}',
+      '{any:    :other}',
+      '{except: :child}'
+    ].each do |parent_options|
+      describe parent_options do
+        it { expect(grand_parent).to be_valid }
+      end
+    end
 
-      it_should_validate_nested 'invalid:', :child1, :attribute1
-      it_should_validate_nested 'invalid:', :child2, :attribute1
-      it_should_validate_nested 'valid:',   :child1, :attribute2, :attribute3
-      it_should_validate_nested 'valid:',   :child2, :attribute2, :attribute3
+    [
+      'true',
+      '{only:   :child}',
+      '{any:    :child}',
+      '{except: :other}'
+    ].each do |parent_options|
+      describe parent_options do
+        it { expect(grand_parent).to_not be_valid }
+      end
     end
   end
 end

data/spec/lib/nested_validator/usage_spec.rb

@@ -51,6 +51,16 @@ describe 'Typical usage' do
     puts parent.errors.messages
   end
 
+  specify 'any child attributes' do
+    class ParentExcept < ParentBase
+      validates :child, nested: { any: [:attribute1, :attribute2] }
+    end
+
+    parent = ParentExcept.new
+    parent.valid?
+    puts parent.errors.messages
+  end
+
   specify 'custom message prefix' do
     class ParentPrefix < ParentBase
       validates :child, nested: { only: :attribute1, prefix: 'OMG'}

data/spec/lib/nested_validator/validate_nested_matcher_spec.rb

@@ -1,110 +1,84 @@
-require 'spec_helper'
-require 'nested_validator'
+require_relative 'nested_validator_context'
 
-describe 'validates_nested with [parent class with "validates, child1]"' do
-  let(:parent_class) do
-    Class.new {
-      include ActiveModel::Validations
+describe 'validates_nested with [parent class with "validates, child]"' do
 
-      attr_accessor :child1, :child2
+  include_context 'nested validator'
 
-      def initialize(child1=nil, child2=nil)
-        self.child1 = child1
-        self.child2 = child2
-      end
-
-      def to_s
-        'parent'
-      end
-    }
-
-  end
-
-  let(:child_class) do
-    Class.new {
-      include ActiveModel::Validations
-
-      attr_accessor :attribute1, :attribute2, :attribute3
-
-      validates :attribute1, presence: true
-      validates :attribute2, presence: true
-      validates :attribute3, presence: true
-
-      def initialize
-        @attribute1 = 'valid'
-        @attribute2 = 'valid'
-        @attribute3 = 'valid'
-      end
-    }
-  end
-
-  let(:parent)    { parent_class.new child_class.new, child_class.new }
+  let(:parent)    { parent_class.new child_class.new }
   let(:options)   { { nested: true } }
   let(:validator) { instance_eval self.class.description }
 
-  before { parent_class.class_eval "validates :child1, #{options}" }
-
   describe 'its validations with options:' do
     let(:options) { self.class.description }
 
     subject { parent }
 
-    context 'nested: true' do
-      it { should validate_nested(:child1) }
-      it { should validate_nested('child1') }
+    context 'true' do
+      it { should validate_nested(:child) }
+      it { should validate_nested('child') }
 
       it { should_not validate_nested(:child2) }
       it { should_not validate_nested(:invalid_child_name) }
     end
 
-    context 'nested: {prefix: "OMG"}' do
-      it { should validate_nested(:child1).with_prefix('OMG') }
-      it { should validate_nested(:child1).with_prefix(:OMG) }
+    context '{prefix: "OMG"}' do
+      it { should validate_nested(:child).with_prefix('OMG') }
+      it { should validate_nested(:child).with_prefix(:OMG) }
 
-      it { should_not validate_nested(:child1) }
-      it { should_not validate_nested(:child1).with_prefix('WTF') }
-      it { should_not validate_nested(:child1).with_prefix(:WTF) }
+      it { should_not validate_nested(:child) }
+      it { should_not validate_nested(:child).with_prefix('WTF') }
+      it { should_not validate_nested(:child).with_prefix(:WTF) }
     end
 
-    context 'nested: {only: :attribute1}' do
-      it { should validate_nested(:child1).only(:attribute1) }
-      it { should validate_nested(:child1).only('attribute1') }
+    context '{only: :attribute}' do
+      it { should validate_nested(:child).only(:attribute) }
+      it { should validate_nested(:child).only('attribute') }
 
-      it { should_not validate_nested(:child1).only(:attribute2) }
-      it { should_not validate_nested(:child1).only('attribute2') }
-      it { should_not validate_nested(:child1).only(:invalid_attribute_name) }
-      it { should_not validate_nested(:child1).only(:attribute1, :attribute2) }
+      it { should_not validate_nested(:child).only(:attribute2) }
+      it { should_not validate_nested(:child).only('attribute2') }
+      it { should_not validate_nested(:child).only(:invalid_attribute_name) }
+      it { should_not validate_nested(:child).only(:attribute, :attribute2) }
     end
 
-    context 'nested: {only: [:attribute1, :attribute2]}' do
-      it { should validate_nested(:child1).only(:attribute1) }
-      it { should validate_nested(:child1).only(:attribute2) }
-      it { should validate_nested(:child1).only(:attribute1, :attribute2) }
-      it { should validate_nested(:child1).only('attribute1', 'attribute2') }
+    context '{only: [:attribute, :attribute2]}' do
+      it { should validate_nested(:child).only(:attribute) }
+      it { should validate_nested(:child).only(:attribute2) }
+      it { should validate_nested(:child).only(:attribute,  :attribute2) }
+      it { should validate_nested(:child).only('attribute', 'attribute2') }
+      it { should validate_nested(:child).only('attribute,   attribute2') }
 
-      it { should_not validate_nested(:child1).only(:attribute2, :attribute3) }
-      it { should_not validate_nested(:child1).only(:invalid_attribute_name) }
+      it { should_not validate_nested(:child).only(:attribute2, :attribute3) }
+      it { should_not validate_nested(:child).only(:invalid_attribute_name) }
     end
 
-    context 'nested: {except: :attribute1}' do
-      it { should validate_nested(:child1).except(:attribute1) }
-      it { should validate_nested(:child1).except('attribute1') }
+    context '{except: :attribute}' do
+      it { should validate_nested(:child).except(:attribute) }
+      it { should validate_nested(:child).except('attribute') }
 
-      it { should_not validate_nested(:child1).except(:attribute2) }
+      it { should_not validate_nested(:child).except(:attribute2) }
     end
 
-    context 'nested: {except: [:attribute1, :attribute2]}' do
-      it { should validate_nested(:child1).except(:attribute1, :attribute2) }
+    context '{except: [:attribute, :attribute2]}' do
+      it { should validate_nested(:child).except(:attribute, :attribute2) }
+    end
+
+    context '{any: :attribute}' do
+      it { should validate_nested(:child).any(:attribute) }
+      it { should validate_nested(:child).any('attribute') }
+
+      it { should_not validate_nested(:child).any(:attribute2) }
+      it { should_not validate_nested(:child).any('attribute2') }
     end
   end
 
   describe 'its description for:' do
     subject { validator.description }
 
-    context('validate_nested(:child1)')                     { it { should eq 'validate nested :child1' } }
-    context('validate_nested(:child1).only(:attribute1)')   { it { should eq 'validate nested :child1 with only: :attribute1' } }
-    context('validate_nested(:child1).except(:attribute1)') { it { should eq 'validate nested :child1 except: :attribute1' } }
-    context('validate_nested(:child1).with_prefix(:OMG)')   { it { should eq 'validate nested :child1 with prefix :OMG' } }
+    context('validate_nested(:child)')                    { it { should eq 'validate nested :child' } }
+    context('validate_nested(:child).only(:attribute)')   { it { should eq 'validate nested :child with only: :attribute' } }
+    context('validate_nested(:child).except(:attribute)') { it { should eq 'validate nested :child except: :attribute' } }
+    context('validate_nested(:child).any(:attribute)')    { it { should eq 'validate nested :child any: :attribute' } }
+    context('validate_nested(:child).with_prefix(:OMG)')  { it { should eq 'validate nested :child with prefix :OMG' } }
   end
 
   describe 'its error messages:' do
@@ -113,70 +87,75 @@ describe 'validates_nested with [parent class with "validates, child1]"' do
 
     before { expect(validator.matches? parent).to be expect_match }
 
-    describe 'failures for should and should_not' do
+    describe 'common failure messages' do
       [:failure_message, :failure_message_when_negated].each do |message|
         subject { validator.send message }
 
-        context 'nested: true' do
-          describe('validate_nested(:invalid_child_name)')                     { it { should eq "parent doesn't respond to :invalid_child_name" } }
-          describe('validate_nested(:child1).only(:invalid_attribute_name)')   { it { should eq "child1 doesn't respond to :invalid_attribute_name" } }
-          describe('validate_nested(:child1).except(:invalid_attribute_name)') { it { should eq "child1 doesn't respond to :invalid_attribute_name"  } }
+        context 'true' do
+          describe('validate_nested(:invalid_child_name)')                    { it { should eq "parent doesn't respond to :invalid_child_name" } }
+          describe('validate_nested(:child).only(:invalid_attribute_name)')   { it { should eq "child doesn't respond to :invalid_attribute_name" } }
+          describe('validate_nested(:child).except(:invalid_attribute_name)') { it { should eq "child doesn't respond to :invalid_attribute_name"  } }
         end
       end
     end
 
-    describe 'should failure messages for' do
+    describe 'failure_message' do
       subject { validator.failure_message }
 
-      context 'nested: true' do
-        describe('validate_nested(:child2)') { it { should eq "parent doesn't nest validations for :child2" } }
+      context 'true' do
+        describe('validate_nested(:other)') { it { should eq "parent doesn't nest validations for :other" } }
+      end
+
+      context '{prefix: :OMG}' do
+        describe('validate_nested(:child)')                   { it { should eq "parent has a prefix of :OMG. Are you missing '.with_prefix(:OMG)'?" } }
+        describe('validate_nested(:child).with_prefix(:WTF)') { it { should eq 'parent uses a prefix of :OMG rather than :WTF' } }
       end
 
-      context 'nested: {prefix: :OMG}' do
-        describe('validate_nested(:child1)')                   { it { should eq "parent has a prefix of :OMG. Are you missing '.with_prefix(:OMG)'?" } }
-        describe('validate_nested(:child1).with_prefix(:WTF)') { it { should eq 'parent uses a prefix of :OMG rather than :WTF' } }
+      context '{only: :attribute}' do
+        describe('validate_nested(:child).only(:attribute2)')             { it { should eq "parent doesn't nest validations for: :attribute2"  } }
+        describe('validate_nested(:child).only(:attribute, :attribute2)') { it { should eq "parent doesn't nest validations for: :attribute2"  } }
       end
 
-      context 'nested: {only: :attribute1}' do
-        describe('validate_nested(:child1).only(:attribute2)')              { it { should eq "parent doesn't nest validations for: :attribute2"  } }
-        describe('validate_nested(:child1).only(:attribute1, :attribute2)') { it { should eq "parent doesn't nest validations for: :attribute2"  } }
+      context '{except: :attribute}' do
+        describe('validate_nested(:child).except(:attribute2)')             { it { should eq 'parent does nest validations for: :attribute2' } }
+        describe('validate_nested(:child).except(:attribute, :attribute2)') { it { should eq 'parent does nest validations for: :attribute2' } }
       end
 
-      context 'nested: {except: :attribute1}' do
-        describe('validate_nested(:child1).except(:attribute2)')              { it { should eq 'parent does nest validations for: :attribute2' } }
-        describe('validate_nested(:child1).except(:attribute1, :attribute2)') { it { should eq 'parent does nest validations for: :attribute2' } }
+      context '{any: :attribute}' do
+        describe('validate_nested(:child).any(:attribute2)')             { it { should eq "parent doesn't nest validations for: :attribute2"  } }
+        describe('validate_nested(:child).any(:attribute, :attribute2)') { it { should eq "parent doesn't nest validations for: :attribute2"  } }
       end
     end
 
-    describe 'should_not failure messages for' do
+    describe 'failure_message_when_negated' do
       let(:expect_match) { true }
 
       subject { validator.failure_message_when_negated }
 
-      context 'nested: true' do
-        describe('validate_nested(:child1)') { it { should eq 'parent does nest validations for: :child1' } }
+      context 'true' do
+        describe('validate_nested(:child)') { it { should eq 'parent does nest validations for: :child' } }
       end
 
-      context 'nested: {prefix: :OMG}' do
-        describe('validate_nested(:child1).with_prefix(:OMG)') { it { should eq 'parent does nest validations for: :child1 with a prefix of :OMG' } }
+      context '{prefix: :OMG}' do
+        describe('validate_nested(:child).with_prefix(:OMG)') { it { should eq 'parent does nest validations for: :child with a prefix of :OMG' } }
       end
 
-      context 'nested: {only: :attribute1}' do
-        describe('validate_nested(:child1).only(:attribute1)') { it { should eq 'parent does nest :child1 validations for: :attribute1' } }
+      context '{only: :attribute}' do
+        describe('validate_nested(:child).only(:attribute)') { it { should eq 'parent does nest :child validations for: :attribute' } }
       end
 
-      context 'nested: {only: [:attribute1, :attribute2]}' do
-        describe('validate_nested(:child1).only(:attribute1)')              { it { should eq 'parent does nest :child1 validations for: :attribute1' } }
-        describe('validate_nested(:child1).only(:attribute1, :attribute2)') { it { should eq 'parent does nest :child1 validations for: :attribute1, :attribute2' } }
+      context '{only: [:attribute, :attribute2]}' do
+        describe('validate_nested(:child).only(:attribute)')              { it { should eq 'parent does nest :child validations for: :attribute' } }
+        describe('validate_nested(:child).only(:attribute, :attribute2)') { it { should eq 'parent does nest :child validations for: :attribute, :attribute2' } }
       end
 
-      context 'nested: {except: :attribute1}' do
-        describe('validate_nested(:child1).except(:attribute1)') { it { should eq "parent doesn't nest :child1 validations for: :attribute1" } }
+      context '{except: :attribute}' do
+        describe('validate_nested(:child).except(:attribute)') { it { should eq "parent doesn't nest :child validations for: :attribute" } }
       end
 
-      context 'nested: {except: [:attribute1, :attribute2]}' do
-        describe('validate_nested(:child1).except(:attribute1)')              { it { should eq "parent doesn't nest :child1 validations for: :attribute1" } }
-        describe('validate_nested(:child1).except(:attribute1, :attribute2)') { it { should eq "parent doesn't nest :child1 validations for: :attribute1, :attribute2" } }
+      context '{except: [:attribute, :attribute2]}' do
+        describe('validate_nested(:child).except(:attribute)')              { it { should eq "parent doesn't nest :child validations for: :attribute" } }
+        describe('validate_nested(:child).except(:attribute, :attribute2)') { it { should eq "parent doesn't nest :child validations for: :attribute, :attribute2" } }
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nested_validator
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.5
 platform: ruby
 authors:
 - Declan Whelan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-26 00:00:00.000000000 Z
+date: 2015-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -129,6 +129,7 @@ files:
 - lib/nested_validator/validate_nested_matcher.rb
 - lib/nested_validator/version.rb
 - nested_validator.gemspec
+- spec/lib/nested_validator/nested_validator_context.rb
 - spec/lib/nested_validator/nested_validator_spec.rb
 - spec/lib/nested_validator/usage_spec.rb
 - spec/lib/nested_validator/validate_nested_matcher_spec.rb
@@ -158,6 +159,7 @@ signing_key:
 specification_version: 4
 summary: A validator that supports nesting.
 test_files:
+- spec/lib/nested_validator/nested_validator_context.rb
 - spec/lib/nested_validator/nested_validator_spec.rb
 - spec/lib/nested_validator/usage_spec.rb
 - spec/lib/nested_validator/validate_nested_matcher_spec.rb