nested_validator 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MDVlMmQxNWU4MjFkZjYxMmZkY2I2OGVlNzM0YzE4NzcwMGMwMjExYw==
+  data.tar.gz: !binary |-
+    MTk5MmQ5MmRmMWE4NGZjMzQxOGU2ZWUwNWRiMWMyMDI3NTAwNWZmMA==
+SHA512:
+  metadata.gz: !binary |-
+    YjNiNDNhNjc0YTBkYzQzN2ViMzViNDY4M2YzODZmYWMyYzQ2ZTY2NWI2M2Yy
+    YTQ3NWE3OGRmNjA4YmIzNGNlMTY5NDgyMzJiYWQyNDQwYzE1MTIyMmY3MmM5
+    NzA3M2E0YjczMDk5N2Y2NzA1Mjg1OGU0MDE2M2NhODVjMDkxM2U=
+  data.tar.gz: !binary |-
+    OGJjZDAyOTMzYWNjNzgwZmY2YzYzMWNkYTA3OTIxNWVhNDM0MDVhNjk0OGVk
+    MDU0YWJmY2FkMGI5MTdlZTcyM2ExMjBlNWQ1NjllYTI3MmQyN2IxZjc0OWM5
+    OTE2MGI3ZWU0MjkyNzAyZTQ0Y2M0ZWYyMzQzOWMyYWE0MjJlZWI=

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+  - ruby-head

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,73 @@
+PATH
+  remote: .
+  specs:
+    nested_validator (1.0.0)
+      activemodel
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.1.0)
+      activesupport (= 4.1.0)
+      builder (~> 3.1)
+    activesupport (4.1.0)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    builder (3.2.2)
+    coveralls (0.7.2)
+      multi_json (~> 1.3)
+      rest-client (= 1.6.7)
+      simplecov (>= 0.7)
+      term-ansicolor (= 1.2.2)
+      thor (= 0.18.1)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    i18n (0.6.11)
+    json (1.8.1)
+    mime-types (2.4.3)
+    minitest (5.3.3)
+    multi_json (1.10.1)
+    rake (10.4.2)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-its (1.1.0)
+      rspec-core (>= 3.0.0)
+      rspec-expectations (>= 3.0.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    simplecov (0.9.1)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    term-ansicolor (1.2.2)
+      tins (~> 0.8)
+    thor (0.18.1)
+    thread_safe (0.3.3)
+    tins (0.13.2)
+    tzinfo (1.1.0)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.6)
+  coveralls
+  nested_validator!
+  rake
+  rspec (~> 3.0)
+  rspec-its

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Eric Roberts
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,194 @@
+[![Gem Version](https://badge.fury.io/rb/percentable.png)](http://badge.fury.io/rb/percentable)
+[![Build Status](https://travis-ci.org/ericroberts/percentable.png?branch=master)](https://travis-ci.org/ericroberts/percentable)
+[![Code Climate](https://codeclimate.com/github/ericroberts/percentable.png)](https://codeclimate.com/github/ericroberts/percentable)
+[![Coverage Status](https://coveralls.io/repos/ericroberts/percentable/badge.png?branch=master)](https://coveralls.io/r/ericroberts/percentable?branch=master)
+
+# Nested Validator
+
+Nested validations allow a parent's class validity to include those of child
+attributes. Errors messages will be copied from the child attribute to the parent.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'nested_validator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nested_validator
+
+## Usage
+
+Assume we have a parent object and we want its validaty to depend on its child validity:
+
+``` ruby
+class ParentBase
+  include ActiveModel::Validations
+
+  attr_accessor :child
+
+  def initialize
+    self.child = Child.new
+  end
+end
+
+class Child
+  include ActiveModel::Validations
+
+  attr_accessor :attribute1, :attribute2
+  
+  validates :attribute1, presence: true
+  validates :attribute2, presence: true
+end
+```
+
+Well, we can use a nested validation to do just that:
+
+``` ruby
+class Parent < ParentBase
+  validates :child, nested: true
+end
+
+parent = Parent.new
+parent.valid?
+puts parent.errors.messages
+
+ # => {:"child attribute1"=>["can't be blank"], :"child attribute2"=>["can't be blank"]}
+```
+### What if I want to validate with just some of the child attributes?
+
+You can use an ```only``` option like this:
+
+``` ruby
+class ParentOnly < ParentBase
+  validates :child, nested: { only: :attribute1 }
+end
+
+parent = ParentOnly.new
+parent.valid?
+puts parent.errors.messages
+
+ # => {:"child attribute1"=>["can't be blank"]}
+```
+
+You can also provide an array of attributes to ```only``` if you want to include more than one.
+
+### OK, is there a way to exclude some child attributes?
+
+Sure thing. You can use the ```except``` option:
+
+``` ruby
+class ParentExcept < ParentBase
+  validates :child, nested: { except: :attribute2 }
+end
+
+parent = ParentExcept.new
+parent.valid?
+puts parent.errors.messages
+
+ # => {:"child attribute1"=>["can't be blank"]}
+```
+
+### Alright, what if I want a custom message?
+
+You can specify a ```prefix``` instead of the child's attribute name:
+
+``` ruby
+class ParentPrefix < ParentBase
+  validates :child, nested: { only: :attribute1, prefix: 'OMG'}
+end
+
+parent = ParentPrefix.new
+parent.valid?
+puts parent.errors.messages
+
+ # => {:"OMG attribute1"=>["can't be blank"]}
+```
+
+### What happens if the child is an Array or Hash?
+
+In this case, each value in the array or hash will be validated and the error message will
+include the index or key of the value.
+
+For an array:
+
+``` ruby
+class ParentArray < ParentBase
+  validates :child, nested: { only: :attribute1 }
+end
+
+parent = ParentArray.new
+parent.child = [Child.new] * 2
+parent.valid?
+puts parent.errors.messages
+
+ # => {:"child[0] attribute1"=>["can't be blank"], :"child[1] attribute1"=>["can't be blank"]}
+```
+
+For a hash:
+
+``` ruby
+class ParentHash < ParentBase
+  validates :child, nested: { only: :attribute1 }
+end
+
+parent = ParentHash.new
+parent.child = { thing1: Child.new, thing2: Child.new }
+parent.valid?
+puts parent.errors.messages
+
+ # => {:"child[thing1] attribute1"=>["can't be blank"], :"child[thing2] attribute1"=>["can't be blank"]}
+```
+
+### Can I easily use this for multiple child attributes?
+
+You can use the ```validates_nested``` method:
+
+``` ruby
+class ParentMultiple < ParentBase
+  attr_accessor :child2
+
+  validates_nested :child, :child2, only: :attribute1
+
+  def initialize
+    self.child  = Child.new
+    self.child2 = Child.new
+  end
+end
+
+parent = ParentMultiple.new
+parent.valid?
+puts parent.errors.messages
+
+ # => {:"child attribute1"=>["can't be blank"], :"child2 attribute1"=>["can't be blank"]}
+```
+
+## Testing With RSpec
+
+When you ```require nested_validator``` you will have access to the RSpec matcher ```validate_nested```
+that you can use in your specs.
+
+Here are some examples:
+
+``` ruby
+describe Parent do
+  it { should validate_nested(:child) }
+  it { should validate_nested(:child).with_prefix(:thing1) }
+  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).except(:attribute1, :attribute2) }
+end
+```
+## Contributing
+
+1. Fork it ( https://github.com/dwhelan/nested_validator/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/nested_validator.rb

@@ -0,0 +1,3 @@
+require_relative 'nested_validator/version'
+require_relative 'nested_validator/nested_validator'
+require_relative 'nested_validator/validate_nested_matcher'

data/lib/nested_validator/nested_validator.rb

@@ -0,0 +1,71 @@
+require 'active_model'
+require 'active_support/core_ext/array'
+
+module ActiveModel
+  module Validations
+    class NestedValidator < EachValidator
+
+      private
+
+      def validate_each(record, attribute, values)
+        with_each_value(values) do |index, value|
+          prefix = prefix(attribute, index, include_index?(values))
+          record_error(record, prefix, value) if value.invalid?
+        end
+      end
+
+      def with_each_value(values, &block)
+        case values
+          when Hash
+            values.each { |key, value| block.call key, value }
+          else
+            Array.wrap(values).each_with_index { |value, index| block.call index, value}
+        end
+      end
+
+      def include_index?(values)
+        values.respond_to? :each
+      end
+
+      def prefix(attribute, index, include_index)
+        prefix = (options.has_key?(:prefix) ? options[:prefix] : attribute).to_s
+        prefix << "[#{index}]" if include_index
+        prefix
+      end
+
+      def record_error(record, prefix, value)
+        value.errors.each do |key, error|
+          record.errors.add(nested_key(prefix, key), error) if include?(key)
+        end
+      end
+
+      def nested_key(prefix, key)
+        "#{prefix} #{key}".strip.to_sym
+      end
+
+      def include?(key)
+        if options[:only]
+          only.any?{|k| key =~ /^#{k}/}
+        elsif options[:except]
+          except.none?{|k| key =~ /^#{k}/}
+        else
+          true
+        end
+      end
+
+      def only
+        @only ||= Array.wrap(options[:only])
+      end
+
+      def except
+        @except ||= Array.wrap(options[:except])
+      end
+    end
+
+    module HelperMethods
+      def validates_nested(*attributes)
+        validates_with NestedValidator, _merge_attributes(attributes)
+      end
+    end
+  end
+end

data/lib/nested_validator/validate_nested_matcher.rb

@@ -0,0 +1,135 @@
+# RSpec matcher to spec nested validations.
+#
+# You can use symbols or strings for any values.
+#
+# Usage:
+#
+#     describe Parent do
+#       it { should validate_nested(:child) }
+#       it { should validate_nested(:child).with_prefix(:thing1) }
+#       it { should validate_nested(:child).only(:attribute1) }
+#       it { should validate_nested(:child).only(:attribute1, :attribute2) }
+#       it { should validate_nested(:child).except(:attribute1) }
+#     end
+
+RSpec::Matchers.define :validate_nested do |child_name|
+
+  attr_accessor :child_name, :prefix, :only_keys, :except_keys # inputs
+  attr_accessor :parent, :actual_keys
+
+  TEST_KEY ||= :__test_key__
+
+  match do |parent|
+    self.prefix      ||= ''
+    self.only_keys   ||= []
+    self.except_keys ||= []
+
+    self.child_name  = child_name
+    self.parent      = parent
+
+    return false unless parent.respond_to? child_name
+
+    self.actual_keys = (error_keys_when_child_validity_is(false) - error_keys_when_child_validity_is(true))
+
+    actual_keys == expected_keys
+  end
+
+  chain(:with_prefix) { |prefix|  self.prefix      = prefix }
+  chain(:only)        { |*only|   self.only_keys   = only   }
+  chain(:except)      { |*except| self.except_keys = except }
+
+  def child
+    parent.send child_name
+  end
+
+  def error_keys_when_child_validity_is(valid)
+    child_error_keys = combine TEST_KEY, only_keys, except_keys
+    child_errors = child_error_keys.inject({}){|result, key| result[key] = ['error message'];result }
+
+    allow(child).to receive(:valid?) { valid }
+    allow(child).to receive(:errors) { valid ? [] : child_errors }
+
+    parent.valid?
+    parent.errors.keys
+  end
+
+  def expected_keys
+    expected_child_keys.map{|key| :"#{expected_prefix} #{key}"}
+  end
+
+  def expected_prefix
+    prefix.present? ? prefix : child_name
+  end
+
+  def actual_prefix
+    :"#{actual_keys.first.to_s.split.first}"
+  end
+
+  def expected_child_keys
+    expected_keys = only_keys.present? ? only_keys : [TEST_KEY]
+    unique_except_keys = except_keys - only_keys
+    combine expected_keys - unique_except_keys
+  end
+
+  def actual_child_keys
+    actual_keys.map{|key| key.to_s.sub(/^.*\s+/, '').to_sym }
+  end
+
+  def invalid_child_keys
+    (only_keys + except_keys).reject{|key| child.respond_to? key}
+  end
+
+  description do
+    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 << " with prefix #{show prefix}"   if prefix.present?
+    message
+  end
+
+  failure_message do
+    case
+      when !parent.respond_to?(child_name)
+        "#{parent} doesn't respond to #{show child_name}"
+      when invalid_child_keys.present?
+        "#{child_name} doesn't respond to #{show invalid_child_keys}"
+      when (missing_child_keys = expected_child_keys - actual_child_keys - invalid_child_keys - [TEST_KEY]).present?
+        "#{parent} doesn't nest validations for: #{show missing_child_keys}"
+      when actual_keys.empty?
+        "parent doesn't nest validations for #{show child_name}"
+      when actual_prefix != expected_prefix
+        if prefix.present?
+          "parent uses a prefix of #{show actual_prefix} rather than #{show expected_prefix}"
+        else
+          "parent has a prefix of #{show actual_prefix}. Are you missing '.with_prefix(#{show actual_prefix})'?"
+        end
+      else
+        "parent does nest validations for: #{show except_keys & actual_child_keys}"
+    end
+  end
+
+  failure_message_when_negated do
+    case
+      when !parent.respond_to?(child_name)
+        "#{parent} doesn't respond to #{show child_name}"
+      when (extras = only_keys & actual_child_keys).present?
+          "#{parent} does nest #{show child_name} validations for: #{show extras}"
+      when invalid_child_keys.present?
+          "#{child_name} doesn't respond to #{show invalid_child_keys}"
+      when except_keys.present?
+          "#{parent} doesn't nest #{show child_name} validations for: #{show except_keys - actual_child_keys}"
+      when prefix.present?
+        "#{parent} does nest validations for: #{show child_name} with a prefix of #{show prefix}"
+      else
+        "#{parent} does nest validations for: #{show child_name}"
+    end
+  end
+
+  def show(value)
+    Array.wrap(value).map{|key| key.is_a?(Symbol) ? ":#{key}" : key.to_s}.join(', ')
+  end
+
+  def combine(*keys)
+    keys.flatten.compact
+  end
+end

data/lib/nested_validator/version.rb

@@ -0,0 +1,3 @@
+module NestedValidator
+  VERSION = '1.0.0'
+end

data/nested_validator.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'nested_validator/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'nested_validator'
+  spec.version       = NestedValidator::VERSION
+  spec.authors       = ['Declan Whelan']
+  spec.email         = ['declanpwhelan@gmail.com']
+  spec.summary       = 'A validator that supports nesting.'
+  spec.description   = "Nested validations allow a parent's class validity to include those of child attributes. Errors messages will be copied from the child attribute to the parent."
+  spec.homepage      = 'https://github.com/dwhelan/nested_validator'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activemodel'
+
+  #spec.add_development_dependency 'awesome_print'
+  #spec.add_development_dependency 'pry'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rspec-its'
+  spec.add_development_dependency 'coveralls'
+end

data/spec/lib/nested_validator/nested_validator_spec.rb

@@ -0,0 +1,212 @@
+require 'spec_helper'
+require 'nested_validator'
+
+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
+    }
+  end
+
+  let(:parent_class) do
+    Class.new(base_class) {
+      attr_accessor :child1, :child2
+    }
+  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
+    }
+  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
+  end
+
+  def with_nested_options(options)
+    parent_with { validates :child1, nested: options }
+  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
+  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
+  end
+
+  describe 'with "nested: true"' do
+    subject { with_nested_options true }
+
+    it_should_validate_nested 'invalid:', :child1, :attribute1, :attribute2, :attribute3
+  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 }
+
+        its('errors.messages') { should eq :'child1 attribute1' => ["can't be blank"] }
+      end
+
+      describe 'with "prefix: "OMG""' do
+        subject { with_nested_options prefix: 'OMG' }
+
+        its('errors.messages') { should eq :'OMG attribute1' => ["can't be blank"] }
+      end
+    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 'with single invalid value' do
+        its('errors.messages') { should eq :'child1[0] attribute1' => ["can't be blank"] }
+      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"] }
+      end
+
+      context 'with a prefix' do
+        subject { with_nested_options prefix: 'OMG' }
+
+        its('errors.messages') { should eq :'OMG[0] attribute1' => ["can't be blank"] }
+      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"] }
+    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"] }
+    end
+
+    context 'with a prefix' do
+      subject { with_nested_options prefix: 'OMG' }
+
+      its('errors.messages') { should eq :'OMG[first] attribute1' => ["can't be blank"] }
+    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
+    end
+
+    describe 'with "only: [:atnested_validator_spec.rbtribute1, :attribute2]"' do
+
+      subject { parent_with { validates :child1, nested: { only: [:attribute1, :attribute2] } } }
+
+      it_should_validate_nested 'invalid:', :child1, :attribute1, :attribute2
+      it_should_validate_nested 'valid:',   :child1, :attribute3
+    end
+  end
+
+  describe '"validates :child1, nested: {except: ...}"' do
+    describe 'with "except: :attribute1"' do
+      subject { with_nested_options except: :attribute1 }
+
+      it_should_validate_nested 'invalid:', :child1, :attribute2, :attribute3
+      it_should_validate_nested 'valid:',   :child1, :attribute1
+    end
+
+    describe 'with "except: [:attribute1, :attribute2"' do
+      subject { with_nested_options except: [:attribute1, :attribute2] }
+
+      it_should_validate_nested 'invalid:', :child1, :attribute3
+      it_should_validate_nested 'valid:',   :child1, :attribute1, :attribute2
+    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 }
+
+      it_should_validate_nested 'invalid:', :child1, :attribute1
+      it_should_validate_nested 'valid:',   :child1, :attribute2, :attribute3
+    end
+  end
+
+  describe 'validates_nested' do
+
+    describe 'validates_nested :child1' do
+      subject { parent_with { validates_nested :child1 } }
+
+      it_should_validate_nested 'invalid:', :child1,  :attribute1, :attribute2, :attribute3
+      it_should_validate_nested 'valid:',   :child2,  :attribute1, :attribute2, :attribute3
+    end
+
+    describe 'validates_nested :child1, :child2' do
+      subject { parent_with { validates_nested :child1, :child2 } }
+
+      it_should_validate_nested 'invalid:', :child1, :attribute1, :attribute2, :attribute3
+      it_should_validate_nested 'invalid:', :child2, :attribute1, :attribute2, :attribute3
+    end
+
+    describe 'validates_nested :child1, :child2, only: :attribute1' do
+      subject { parent_with { validates_nested :child1, :child2, only: :attribute1 } }
+
+      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
+    end
+  end
+end

data/spec/lib/nested_validator/usage_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require 'nested_validator'
+
+
+describe 'Typical usage' do
+  class Child
+    include ActiveModel::Validations
+
+    attr_accessor :attribute1, :attribute2
+    validates :attribute1, presence: true
+    validates :attribute2, presence: true
+  end
+
+  class ParentBase
+    include ActiveModel::Validations
+
+    attr_accessor :child
+
+    def initialize
+      self.child = Child.new
+    end
+  end
+
+  specify 'simple example' do
+    class Parent < ParentBase
+      validates :child, nested: true
+    end
+
+    parent = Parent.new
+    parent.valid?
+    puts parent.errors.messages
+  end
+
+  specify 'only certain child attributes' do
+    class ParentOnly < ParentBase
+      validates :child, nested: { only: :attribute1 }
+    end
+
+    parent = ParentOnly.new
+    parent.valid?
+    puts parent.errors.messages
+  end
+
+  specify 'except certain child attributes' do
+    class ParentExcept < ParentBase
+      validates :child, nested: { except: :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'}
+    end
+
+    parent = ParentPrefix.new
+    parent.valid?
+    puts parent.errors.messages
+  end
+
+  specify 'array of values' do
+    class ParentArray < ParentBase
+      validates :child, nested: { only: :attribute1 }
+    end
+
+    parent = ParentArray.new
+    parent.child = [Child.new] * 2
+    parent.valid?
+    puts parent.errors.messages
+  end
+
+  specify 'hash of values' do
+    class ParentHash < ParentBase
+      validates :child, nested: { only: :attribute1 }
+    end
+
+    parent = ParentHash.new
+    parent.child = { thing1: Child.new, thing2: Child.new }
+    parent.valid?
+    puts parent.errors.messages
+  end
+
+  specify 'multiple children' do
+    class ParentMultiple < ParentBase
+      attr_accessor :child2
+
+      validates_nested :child, :child2, only: :attribute1
+
+      def initialize
+        self.child  = Child.new
+        self.child2 = Child.new
+      end
+    end
+
+    parent = ParentMultiple.new
+    parent.valid?
+    puts parent.errors.messages
+  end
+end

data/spec/lib/nested_validator/validate_nested_matcher_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+require 'nested_validator'
+
+describe 'validates_nested with [parent class with "validates, child1]"' do
+  let(:parent_class) do
+    Class.new {
+      include ActiveModel::Validations
+
+      attr_accessor :child1, :child2
+
+      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(:options) { { presence: true } }
+
+  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') }
+
+      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) }
+
+      it { should_not validate_nested(:child1) }
+      it { should_not validate_nested(:child1).with_prefix('WTF') }
+      it { should_not validate_nested(:child1).with_prefix(:WTF) }
+    end
+
+    context 'nested: {only: :attribute1}' do
+      it { should validate_nested(:child1).only(:attribute1) }
+      it { should validate_nested(:child1).only('attribute1') }
+
+      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) }
+    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') }
+
+      it { should_not validate_nested(:child1).only(:attribute2, :attribute3) }
+      it { should_not validate_nested(:child1).only(:invalid_attribute_name) }
+    end
+
+    context 'nested: {except: :attribute1}' do
+      it { should validate_nested(:child1).except(:attribute1) }
+      it { should validate_nested(:child1).except('attribute1') }
+
+      it { should_not validate_nested(:child1).except(:attribute2) }
+    end
+
+    context 'nested: {except: [:attribute1, :attribute2]}' do
+      it { should validate_nested(:child1).except(:attribute1, :attribute2) }
+    end
+  end
+
+  describe 'its description for:' do
+    let(:validator) { instance_eval self.class.description }
+
+    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' } }
+  end
+
+  describe 'its error messages:' do
+    let(:options)   { self.class.parent.description }
+    let(:validator) { instance_eval self.class.description }
+
+    describe 'should failure messages for' do
+      before { expect(validator.matches? parent).to be false }
+
+      subject { validator.failure_message }
+
+      context 'nested: true' do
+        describe('validate_nested(:child2)')             { it { should eq "parent doesn't nest validations for :child2" } }
+        describe('validate_nested(:invalid_child_name)') { it { should eq "parent doesn't respond to :invalid_child_name" } }
+      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' } }
+      end
+
+      context 'nested: {only: :attribute1}' do
+        describe('validate_nested(:child1).only(:invalid_attribute_name)')  { it { should eq "child1 doesn't respond to :invalid_attribute_name" } }
+        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"  } }
+      end
+
+      context 'nested: {except: :attribute1}' do
+        describe('validate_nested(:child1).except(:invalid_attribute_name)')  { it { should eq "child1 doesn't respond to :invalid_attribute_name"  } }
+        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' } }
+      end
+    end
+
+    describe 'should_not failure messages for' do
+      before { expect(validator.matches? parent).to be true }
+
+      subject { validator.failure_message_when_negated }
+
+      context 'nested: true' do
+        describe('validate_nested(:child1)') { it { should eq 'parent does nest validations for: :child1' } }
+      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' } }
+      end
+
+      context 'nested: {only: :attribute1}' do
+        describe('validate_nested(:child1).only(:attribute1)') { it { should eq 'parent does nest :child1 validations for: :attribute1' } }
+      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' } }
+      end
+
+      context 'nested: {except: :attribute1}' do
+        describe('validate_nested(:child1).except(:attribute1)') { it { should eq "parent doesn't nest :child1 validations for: :attribute1" } }
+      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" } }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'i18n'
+require 'rspec/its'
+require 'coveralls'
+
+#require 'pry'
+#require 'awesome_print'
+
+I18n.enforce_available_locales = true
+Coveralls.wear!
+
+RSpec.configure do |config|
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+
+  config.alias_it_should_behave_like_to :it_should_validate_nested, 'the parent object should be'
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: nested_validator
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Declan Whelan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Nested validations allow a parent's class validity to include those of
+  child attributes. Errors messages will be copied from the child attribute to the
+  parent.
+email:
+- declanpwhelan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/nested_validator.rb
+- lib/nested_validator/nested_validator.rb
+- lib/nested_validator/validate_nested_matcher.rb
+- lib/nested_validator/version.rb
+- nested_validator.gemspec
+- spec/lib/nested_validator/nested_validator_spec.rb
+- spec/lib/nested_validator/usage_spec.rb
+- spec/lib/nested_validator/validate_nested_matcher_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/dwhelan/nested_validator
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.10
+signing_key: 
+specification_version: 4
+summary: A validator that supports nesting.
+test_files:
+- spec/lib/nested_validator/nested_validator_spec.rb
+- spec/lib/nested_validator/usage_spec.rb
+- spec/lib/nested_validator/validate_nested_matcher_spec.rb
+- spec/spec_helper.rb