validates_subset 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6ac3e5de7a80d20cdddb2d41527f9228a767cc5f
+  data.tar.gz: 7fbf538b71f54145550823de261b4ac6fb356b7e
+SHA512:
+  metadata.gz: 4f8b260d9e133cd883f4bede331137c57aa51a68ea7883a026e5c6c5306cc2c822584b6c2d4870cb02f0027f1d6fba8d739025e6ba3592a8effc62751ebf5ccb
+  data.tar.gz: aec647c12952a02a976d09fd4c84c4c2b6629b66a40db0dd45eea4d74cd23fa6b616b59c8005680ebfb7ce5949893cc5777623a6310739b05f969b4511e753aa

data/.gitignore

@@ -0,0 +1 @@
+.ruby-*

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm: 2.2.1
+script: bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'activemodel'
+
+group :test do
+  gem 'rspec'
+  gem 'pry'
+  gem 'guard-rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,84 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.2.1)
+      activesupport (= 4.2.1)
+      builder (~> 3.1)
+    activesupport (4.2.1)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    builder (3.2.2)
+    celluloid (0.16.0)
+      timers (~> 4.0.0)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    ffi (1.9.8)
+    formatador (0.2.5)
+    guard (2.12.5)
+      formatador (>= 0.2.4)
+      listen (~> 2.7)
+      lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.5.2)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    hitimes (1.2.2)
+    i18n (0.7.0)
+    json (1.8.3)
+    listen (2.10.0)
+      celluloid (~> 0.16.0)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.9)
+    method_source (0.8.2)
+    minitest (5.7.0)
+    nenv (0.2.0)
+    notiffany (0.0.6)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rb-fsevent (0.9.5)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.3)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    shellany (0.0.1)
+    slop (3.6.0)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    timers (4.0.1)
+      hitimes
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel
+  guard-rspec
+  pry
+  rspec

data/Guardfile

@@ -0,0 +1,5 @@
+guard :rspec, cmd: 'rspec', notification: false do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})    { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { "spec" }
+end

data/README.md

@@ -0,0 +1,124 @@
+## validates_subset
+
+![Build Status](https://travis-ci.org/yez/validates_subset.svg?branch=master)
+
+### Subset validator for Rails
+
+#### Purpose
+
+Validate that an attribute is a subset of another. If an attribute saved to the database (or simply kept in memory) needs to be a subset of another, this is the way to go.
+
+#### Usage
+
+##### With ActiveRecord
+
+```ruby
+class Foo < ActiveRecord::Base
+  attr_accessor :bar
+
+  # validate that the attribute :bar is a subset of the set [2, 4, 5]
+  validates_subset :bar, [2, 4, 5]
+end
+
+# Example usage:
+foo = Foo.new(bar: [2])
+foo.valid?
+# => true
+
+foo = Foo.new(bar: [7])
+foo.valid?
+# => false
+
+foo = Foo.new(bar: 'banana')
+foo.valid?
+# => false
+```
+
+##### With ActiveModel
+
+```ruby
+class Bar
+  include ActiveModel
+
+  attr_accessor :foo
+
+  # validate that the attribute :foo is a subset of the set ['a', 'b', 'c']
+  validates_subset :foo, ['a', 'b', 'c']
+end
+
+# Example usage:
+bar = Bar.new(foo: ['a'])
+bar.valid?
+# => true
+
+bar = Bar.new(foo: ['q'])
+bar.valid?
+# => false
+
+bar = Bar.new(foo: 123)
+bar.valid?
+# => false
+```
+
+##### With `validates` syntax
+
+```ruby
+class Banana < ActiveRecord::Base
+
+  attr_accessor :peel
+
+  # validate that the attribute :peel is a subset of the set ['yellow', 'green']
+  validates :peel, subset: ['yellow', 'green']
+end
+
+# Example usage:
+banana = Banana.new(peel: ['yellow'])
+banana.valid?
+# => true
+
+banana = Banana.new(peel: ['brown']) # Who wants a brown peel? No one.
+banana.valid?
+# => false
+
+banana = Banana.new(peel: 123)
+banana.valid?
+# => false
+```
+
+##### With multiple modifiers
+
+```ruby
+class Foo < ActiveRecord::Base
+  attr_accessor :baz
+
+  # validate that attribute :baz is a subset of [1, 2, 3] with a custom error message
+  #   only if :conditional_method evaluates to true
+  validates_subset :baz, [1, 2, 3],
+                  message: 'Baz is not a subset of [1, 2, 3], make it so!',
+                  if: :conditional_method
+
+  def conditional_method
+    # some kind of logic that is important to pass
+  end
+end
+
+# Example usage:
+foo = Foo.new(baz: [1])
+
+foo.valid?
+# => true
+
+foo = Foo.new(baz: [99999])
+
+# When the conditional method is true
+foo.conditional_method
+# => true
+foo.valid?
+# => false
+
+# When the conditional method is false
+foo.conditional_method
+# => false
+foo.valid?
+# => true
+```

data/lib/arguments.rb

@@ -0,0 +1,44 @@
+module ValidatesSubset
+  # Wrapper class for arguments consumed by validates_with
+  class Arguments
+    # @initialize
+    #   param: attribute_name <Symbol> - Name of attribute that will be validated
+    #   param: superset <Array>        - Superset of attributes to validate set against
+    #   param: options <Hash>          - Extra options to pass along to the validator
+    #                                    i.e. allow_nil: true, message: 'my custom message'
+    #   return: nil
+    def initialize(attribute_name, superset, options)
+      @attribute_name = attribute_name
+      @superset       = superset
+      @options        = options.is_a?(Hash) ? options : {}
+    end
+
+    # format expected by _merge_attributes
+    #
+    # @to_validation_attributes
+    # return: <Array> - cardinality of 2
+    def to_validation_attributes
+      [@attribute_name, merged_options]
+    end
+
+    private
+
+    # helper method to compact all the options together along
+    #   with the subset for validation
+    #
+    # @merged_options
+    #   return: <Hash>
+    def merged_options
+      subset.merge(@options)
+    end
+
+    # helper method to impose the subset for validation into an option
+    #  that will be merged later
+    #
+    # @subset
+    #   return: <Hash>
+    def subset
+      { :subset => @superset }
+    end
+  end
+end

data/lib/validates_subset.rb

@@ -0,0 +1,98 @@
+require 'active_model'
+
+require_relative './arguments'
+
+module ActiveModel
+  module Validations
+    class SubsetValidator < ActiveModel::EachValidator
+      # @initialize
+      #   param: options <Hash> - options hash of how to validate this attribute
+      #                           including custom messaging due to failures, specifying
+      #                           the subset the attribute to validate against, etc.
+      #   return: result of ActiveModel::Validations::EachValidator initialize
+      def initialize(options)
+        options[:superset] = options.delete(:subset)
+
+        merged_options = {
+          :message => "is expected to be a subset of #{ options[:superset] } and is not."
+        }.merge(options)
+
+        super(merged_options)
+      end
+
+      # Validate that the array is a subset of what we expect
+      #
+      # @validate_each
+      #   param: record <Object>    - subject containing attribute to validate
+      #   param: attribute <Symbol> - name of attribute to validate
+      #   param: value <Variable>   - value of attribute to validate
+      #   return: nil
+      def validate_each(record, attribute, value)
+        add_errors_or_raise(options, record, attribute) unless is_subset?(value, options[:superset])
+      end
+
+      private
+
+      def is_subset?(set, superset)
+        set.is_a?(Array) && (set & superset) == set
+      end
+
+      # Helper method to either add messages to the errors object
+      # or raise an exception in :strict mode
+      #
+      # @add_errors_or_raise
+      #   param: options <Hash>     - options hash with strict flag or class
+      #   param: record <Object>    - subject containg attribute to validate
+      #   param: attribute <Symbol> - name of attribute under validation
+      #   return: nil
+      def add_errors_or_raise(options, record, attribute)
+        error = options_error(options[:strict])
+
+        raise error unless error.nil?
+
+        record.errors.add(attribute, options[:message])
+      end
+
+      # Helper method to return the base expected error:
+      # ActiveModel::StrictValidationFailed, a custom error, or nil
+      #
+      # @options_error
+      #   param: strict_error <true or subclass of Exception> - either the flag
+      #           to raise an error or the actual error to raise
+      #   return: custom error, ActiveModel::StrictValidationFailed, or nil
+      def options_error(strict_error)
+        return if strict_error.nil?
+
+        if strict_error == true
+          ActiveModel::StrictValidationFailed
+        elsif strict_error.ancestors.include?(Exception)
+          strict_error
+        end
+      end
+    end
+
+    module ClassMethods
+      # Validates that an attribute is a subset of an expected set:
+      #
+      # class Foo
+      #   include ActiveModel::Validations
+      #
+      #   attr_accessor :thing, :something
+      #
+      #   validates_subset :thing, ['something', 'another thing', 'a third thing']
+      #   validates_subset :something, [:foo, :bar]
+      # end
+      #
+      # @validates_subset
+      #   param: attribute_name <Symbol> - name of attribute to validate
+      #   param: set <Array>             - superset of all desired members
+      #   param: options <Hash>          - other common options to validate methods calls
+      #                                    i.e. message: 'my custom error message'
+      #   return: nil
+      def validates_subset(attribute_name, superset, options = {})
+        args = ValidatesSubset::Arguments.new(attribute_name, superset, options)
+        validates_with SubsetValidator, _merge_attributes(args.to_validation_attributes)
+      end
+    end
+  end
+end

data/spec/integration/modifiers/allow_blank_spec.rb

@@ -0,0 +1,63 @@
+require_relative '../../../lib/validates_subset'
+
+class TestAllowBlank
+  include ActiveModel::Validations
+
+  attr_accessor :foo
+
+  validates_subset :foo, [1, 2, 3], allow_blank: true
+end
+
+describe 'allow blank' do
+  subject { sub = TestAllowBlank.new; sub.foo = value; sub }
+
+  context 'value is not blank' do
+    context 'value is a valid subset' do
+      let(:value) { [1] }
+
+      specify do
+        expect(subject).to be_valid
+      end
+    end
+
+    context 'value is not a valid subset' do
+      let(:value) { %i[a b c] }
+
+      specify do
+        expect(subject).to_not be_valid
+      end
+    end
+
+    context 'value is not an array' do
+      let(:value) { 'bar' }
+
+      specify do
+        expect(subject).to_not be_valid
+      end
+    end
+  end
+
+  context 'value is blank' do
+    let(:value) { nil }
+
+    specify do
+      expect(subject).to be_valid
+    end
+
+    context 'an empty array' do
+      let(:value) { [] }
+
+      specify do
+        expect(subject).to be_valid
+      end
+    end
+
+    context 'an empty hash' do
+      let(:value) { {} }
+
+      specify do
+        expect(subject).to be_valid
+      end
+    end
+  end
+end

data/spec/integration/modifiers/allow_nil_spec.rb

@@ -0,0 +1,63 @@
+require_relative '../../../lib/validates_subset'
+
+class TestAllowNil
+  include ActiveModel::Validations
+
+  attr_accessor :foo
+
+  validates_subset :foo, [1, 2, 3], allow_nil: true
+end
+
+describe 'allow nil' do
+  subject { sub = TestAllowNil.new; sub.foo = value; sub }
+
+  context 'value is not nil' do
+    context 'value is a valid subset' do
+      let(:value) { [1] }
+
+      specify do
+        expect(subject).to be_valid
+      end
+    end
+
+    context 'value is not a valid subset' do
+      let(:value) { %i[a b c] }
+
+      specify do
+        expect(subject).to_not be_valid
+      end
+    end
+
+    context 'value is not an array' do
+      let(:value) { 'bar' }
+
+      specify do
+        expect(subject).to_not be_valid
+      end
+    end
+  end
+
+  context 'value is nil' do
+    let(:value) { nil }
+
+    specify do
+      expect(subject).to be_valid
+    end
+  end
+
+  context 'an empty array' do
+    let(:value) { [] }
+
+    specify do
+      expect(subject).to be_valid
+    end
+  end
+
+  context 'an empty hash' do
+    let(:value) { {} }
+
+    specify do
+      expect(subject).to_not be_valid
+    end
+  end
+end

data/spec/integration/modifiers/if_spec.rb

@@ -0,0 +1,58 @@
+require_relative '../../../lib/validates_subset'
+
+describe 'if condition' do
+  subject { sub = TestIfTrue.new; sub.foo = value; sub }
+
+  context 'if condition results in true' do
+
+    class TestIfTrue
+      include ActiveModel::Validations
+
+      attr_accessor :foo
+
+      validates_subset :foo, [1, 2, 3], if: -> { true }
+    end
+
+    context 'value is a valid subset' do
+      let(:value) { [1] }
+
+      specify do
+        expect(subject).to be_valid
+      end
+    end
+
+    context 'value is not a valid subset' do
+      let(:value) { %i[a b c] }
+
+      specify do
+        expect(subject).to_not be_valid
+      end
+    end
+
+    context 'value is not an array' do
+      let(:value) { 'bar' }
+
+      specify do
+        expect(subject).to_not be_valid
+      end
+    end
+  end
+
+  context 'condition results is not true' do
+    class TestIfFalse
+      include ActiveModel::Validations
+
+      attr_accessor :foo
+
+      validates_subset :foo, [1, 2, 3], if: -> { false }
+    end
+
+    subject { sub = TestIfFalse.new; sub.foo = value; sub }
+
+    let(:value) { anything }
+
+    specify do
+      expect(subject).to be_valid
+    end
+  end
+end

data/spec/integration/modifiers/message_spec.rb

@@ -0,0 +1,47 @@
+require_relative '../../../lib/validates_subset'
+
+class TestMessage
+  include ActiveModel::Validations
+
+  attr_accessor :foo
+
+  validates_subset :foo, [1, 2, 3], message: 'Oh no spaghettios'
+end
+
+describe 'custom messaging' do
+  subject { sub = TestMessage.new; sub.foo = value; sub }
+
+  context 'value is a valid subset' do
+    let(:value) { [1] }
+
+    specify do
+      expect(subject).to be_valid
+    end
+  end
+
+  context 'value is not a valid subset' do
+    let(:value) { %i[a b c] }
+
+    specify do
+      expect(subject).to_not be_valid
+    end
+
+    it 'sets the custom error message' do
+      subject.validate
+      expect(subject.errors[:foo].first).to match(/Oh no spaghettios/)
+    end
+  end
+
+  context 'value is not an array' do
+    let(:value) { 'bar' }
+
+    specify do
+      expect(subject).to_not be_valid
+    end
+
+    it 'sets the custom error message' do
+      subject.validate
+      expect(subject.errors[:foo].first).to match(/Oh no spaghettios/)
+    end
+  end
+end

data/spec/integration/modifiers/multiple_spec.rb

@@ -0,0 +1,73 @@
+require_relative '../../../lib/validates_subset'
+
+class TestMultiple
+  include ActiveModel::Validations
+
+  attr_accessor :foo
+
+  validates_subset :foo, [1, 2, 3], allow_blank: true, message: 'oh no spaghettios'
+end
+
+describe 'multiple validations' do
+  subject { sub = TestMultiple.new; sub.foo = value; sub }
+
+  context 'value is not blank' do
+    context 'value is a valid subset' do
+      let(:value) { [1] }
+
+      specify do
+        expect(subject).to be_valid
+      end
+    end
+
+    context 'value is not a valid subset' do
+      let(:value) { %i[a b c] }
+
+      specify do
+        expect(subject).to_not be_valid
+      end
+
+      it 'has the specified error message' do
+        subject.validate
+        expect(subject.errors.full_messages.to_s).to match(/oh no spaghettios/)
+      end
+    end
+
+    context 'value is not an array' do
+      let(:value) { 'bar' }
+
+      specify do
+        expect(subject).to_not be_valid
+      end
+
+      it 'has the specified error message' do
+        subject.validate
+        expect(subject.errors.full_messages.to_s).to match(/oh no spaghettios/)
+      end
+    end
+  end
+
+  context 'value is blank' do
+    let(:value) { nil }
+
+    specify do
+      expect(subject).to be_valid
+    end
+
+    context 'an empty array' do
+      let(:value) { [] }
+
+      specify do
+        expect(subject).to be_valid
+      end
+    end
+
+    context 'an empty hash' do
+      let(:value) { {} }
+
+      specify do
+        expect(subject).to be_valid
+      end
+    end
+  end
+end

data/spec/integration/modifiers/on_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../../../lib/validates_subset'
+
+describe 'on' do
+  class TestOn
+    include ActiveModel::Validations
+
+    attr_accessor :foo
+
+    validates_subset :foo, [1, 2, 3], on: :special_method
+
+    def special_method; end
+  end
+
+  subject { sub = TestOn.new; sub.foo = value; sub }
+
+  it 'adds the options to the validation' do
+    options = TestOn.validators_on(:foo).first.options
+    expect(options).to include(:on)
+    expect(options[:on]).to eq(:special_method)
+  end
+end

data/spec/integration/modifiers/strict_spec.rb

@@ -0,0 +1,77 @@
+require_relative '../../../lib/validates_subset'
+
+describe 'strict' do
+  context 'default exception for strict validation' do
+    class TestStrictDefault
+      include ActiveModel::Validations
+
+      attr_accessor :foo
+
+      validates_subset :foo, [1, 2, 3], strict: true
+    end
+
+    subject { sub = TestStrictDefault.new; sub.foo = value; sub }
+
+    context 'input is valid' do
+      let(:value) { [1] }
+
+      it 'is valid' do
+        expect(subject).to be_valid
+      end
+
+      it 'does not raise any errors' do
+        expect do
+          subject.valid?
+        end.to_not raise_error
+      end
+    end
+
+    context 'input is invalid' do
+      let(:value) { 'banana' }
+
+      it 'raises an error' do
+        expect do
+          subject.valid?
+        end.to raise_error
+      end
+    end
+  end
+
+  context 'specific exception for strict validation' do
+    class TestStrictSpecific
+      class SomeStrictError < StandardError; end
+
+      include ActiveModel::Validations
+
+      attr_accessor :foo
+
+      validates_subset :foo, [1, 2, 3], strict: SomeStrictError
+    end
+
+    subject { sub = TestStrictSpecific.new; sub.foo = value; sub }
+
+    context 'input is valid' do
+      let(:value) { [1] }
+
+      it 'is valid' do
+        expect(subject).to be_valid
+      end
+
+      it 'does not raise any errors' do
+        expect do
+          subject.valid?
+        end.to_not raise_error
+      end
+    end
+
+    context 'input is invalid' do
+      let(:value) { 'banana' }
+
+      it 'raises the custom error' do
+        expect do
+          subject.valid?
+        end.to raise_error(TestStrictSpecific::SomeStrictError)
+      end
+    end
+  end
+end

data/spec/integration/modifiers/unless_spec.rb

@@ -0,0 +1,76 @@
+require_relative '../../../lib/validates_subset'
+
+describe 'unless condition' do
+  subject { sub = TestUnlessTrue.new; sub.foo = value; sub }
+
+  context 'if condition results in true' do
+
+    class TestUnlessTrue
+      include ActiveModel::Validations
+
+      attr_accessor :foo
+
+      validates_subset :foo, [1, 2, 3], unless: -> { true }
+    end
+
+    context 'value is a valid subset' do
+      let(:value) { [1] }
+
+      specify do
+        expect(subject).to be_valid
+      end
+    end
+
+    context 'value is not a valid subset' do
+      let(:value) { %i[a b c] }
+
+      specify do
+        expect(subject).to be_valid
+      end
+    end
+
+    context 'value is not an array' do
+      let(:value) { 'bar' }
+
+      specify do
+        expect(subject).to be_valid
+      end
+    end
+  end
+
+  context 'condition results is not true' do
+    class TestUnlessFalse
+      include ActiveModel::Validations
+
+      attr_accessor :foo
+
+      validates_subset :foo, [1, 2, 3], unless: -> { false }
+    end
+
+    subject { sub = TestUnlessFalse.new; sub.foo = value; sub }
+
+    context 'value is a valid subset' do
+      let(:value) { [1] }
+
+      specify do
+        expect(subject).to be_valid
+      end
+    end
+
+    context 'value is not a valid subset' do
+      let(:value) { %i[a b c] }
+
+      specify do
+        expect(subject).to_not be_valid
+      end
+    end
+
+    context 'value is not an array' do
+      let(:value) { 'bar' }
+
+      specify do
+        expect(subject).to_not be_valid
+      end
+    end
+  end
+end

data/spec/integration/validations_spec.rb

@@ -0,0 +1,46 @@
+require_relative '../../lib/validates_subset'
+
+class ActiveModelTestClass
+  include ActiveModel::Validations
+
+  attr_accessor :foo
+
+  validates_subset :foo, [1, 2, 3]
+
+  def initialize(foo)
+    @foo = foo
+  end
+end
+
+describe ValidatesSubset do
+  subject { ActiveModelTestClass.new(attribute_value) }
+
+  context 'attribute is a valid subset' do
+    let(:attribute_value) { [1, 2] }
+
+    it 'is valid' do
+      expect(subject).to be_valid
+    end
+  end
+
+  context 'attribute is not a valid subset' do
+    context 'value is still an array' do
+      let(:attribute_value) { [5, 6] }
+
+      it 'does not error' do
+        expect do
+          subject.validate
+        end.to_not raise_error
+      end
+
+      it 'is not valid' do
+        expect(subject).to_not be_valid
+      end
+
+      it 'has an error message with the key of the validated attribute' do
+        subject.validate
+        expect(subject.errors).to have_key(:foo)
+      end
+    end
+  end
+end

data/spec/lib/arguments_spec.rb

@@ -0,0 +1,84 @@
+require_relative '../../lib/arguments'
+
+module ValidatesSubset
+  describe Arguments do
+
+    let(:attribute_name) { :foo }
+    let(:superset)       { %w(bar qux) }
+    let(:options)        { { extra: :options } }
+
+    subject { described_class.new(attribute_name, superset, options) }
+
+    describe '#to_validation_attributes' do
+      context 'all pertinent attributes are present' do
+        specify do
+          expect(subject.to_validation_attributes).to eq([attribute_name, { subset: superset }.merge(options)])
+        end
+      end
+
+      context 'superset is nil' do
+        let(:superset) { nil }
+
+        specify do
+          expect(subject.to_validation_attributes).to eq([attribute_name, { subset: superset }.merge(options)])
+        end
+      end
+
+      context 'attribute_name is nil' do
+        let(:attribute_name) { nil }
+
+        specify do
+          expect(subject.to_validation_attributes).to eq([attribute_name, { subset: superset }.merge(options)])
+        end
+      end
+
+      context 'options is nil' do
+        let(:options) { nil }
+
+        specify do
+          expect(subject.to_validation_attributes).to eq([attribute_name, { subset: superset }])
+        end
+      end
+    end
+
+    describe '#subset' do
+      context 'subset is given' do
+        specify do
+          expect(subject.send(:subset)).to eq({ subset: superset })
+        end
+      end
+
+      context 'subset is nil' do
+        let(:superset) { nil }
+
+        specify do
+          expect(subject.send(:subset)).to eq({ subset: nil })
+        end
+      end
+    end
+
+    describe '#merged_options' do
+      context 'options are present' do
+        specify do
+          expect(subject.send(:merged_options)).to eq({ subset: superset }.merge(options))
+        end
+      end
+
+      context 'options is nil' do
+        let(:options) { nil }
+
+        specify do
+          expect(subject.send(:merged_options)).to eq({ subset: superset })
+        end
+      end
+
+      context 'options is a blank hash' do
+        let(:options) { {} }
+
+        specify do
+          expect(subject.send(:merged_options)).to eq({ subset: superset })
+        end
+      end
+    end
+  end
+end

data/spec/lib/validates_subset_spec.rb

@@ -0,0 +1,77 @@
+require_relative '../../lib/validates_subset'
+
+module ActiveModel
+  module Validations
+    describe SubsetValidator do
+      describe '#initialize' do
+        let(:options) { { attributes: [:thing], foo: :bar, subset: [] } }
+        subject { described_class.new(options) }
+
+        it 'sets the options instance variable' do
+          expect(subject.instance_variable_get(:@options)).to_not be_nil
+        end
+
+        it 'removes the attributes from the options' do
+          expect(subject.instance_variable_get(:@options)).to_not have_key(:attributes)
+        end
+
+        it 'adds a message to the options' do
+          expect(subject.instance_variable_get(:@options)).to have_key(:message)
+          expect(subject.instance_variable_get(:@options)[:message]).to_not be_blank
+        end
+      end
+
+      describe '#validate_each' do
+        let(:return_value) { nil }
+        subject { described_class.new(attributes: [:foo]) }
+
+        before do
+          allow(subject).to receive(:is_subset?)          { return_value }
+          allow(subject).to receive(:add_errors_or_raise) { nil }
+        end
+
+        it 'calls the validation logic' do
+          expect(subject).to receive(:is_subset?)
+          subject.validate_each(anything, anything, anything)
+        end
+
+        context 'validation passes' do
+          let(:return_value) { true }
+
+          it 'does not add errors on the validated model' do
+            expect(subject).to_not receive(:add_errors_or_raise)
+            subject.validate_each(anything, anything, anything)
+          end
+
+          it 'does not throw any errors' do
+            expect do
+              subject.validate_each(anything, anything, anything)
+            end.to_not raise_error
+          end
+        end
+
+        context 'validation fails' do
+          let(:return_value) { false }
+
+          it 'adds values to the errors on the validated model' do
+            expect(subject).to receive(:add_errors_or_raise)
+            subject.validate_each(anything, anything, anything)
+          end
+        end
+      end
+    end
+
+    describe '.validate_subset' do
+      class IncludedClass
+        include ActiveModel::Validations
+      end
+
+      it 'validates with SubsetValidator' do
+        included_class = IncludedClass
+        expect(included_class).to receive(:validates_with)
+          .with(SubsetValidator, anything)
+        included_class.validates_subset(anything, anything)
+      end
+    end
+  end
+end

data/validates_subset.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+require_relative './version'
+
+Gem::Specification.new do |s|
+  s.name          = 'validates_subset'
+  s.version       = ValidatesSubset::VERSION
+  s.summary       = %q{Subset validation for ActiveModel/ActiveRecord models}
+  s.description   = %q{This library helps validate that an attribute is a subset of a specified set}
+  s.authors       = ['Jake Yesbeck']
+  s.email         = 'yesbeckjs@gmail.com'
+  s.homepage      = 'http://rubygems.org/gems/validates_subset'
+  s.license       = 'MIT'
+
+  s.require_paths = ['lib']
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = s.files.grep(/^spec\//)
+
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.add_dependency 'activemodel', '>= 3.0'
+
+  s.add_development_dependency 'bundler', '~> 1.3'
+  s.add_development_dependency 'rake', '~> 10.0'
+  s.add_development_dependency 'rspec', '~> 3.0'
+end

data/version.rb

@@ -0,0 +1,3 @@
+module ValidatesSubset
+  VERSION = '1.0.2'.freeze
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: validates_subset
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+platform: ruby
+authors:
+- Jake Yesbeck
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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'
+description: This library helps validate that an attribute is a subset of a specified
+  set
+email: yesbeckjs@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- README.md
+- lib/arguments.rb
+- lib/validates_subset.rb
+- spec/integration/modifiers/allow_blank_spec.rb
+- spec/integration/modifiers/allow_nil_spec.rb
+- spec/integration/modifiers/if_spec.rb
+- spec/integration/modifiers/message_spec.rb
+- spec/integration/modifiers/multiple_spec.rb
+- spec/integration/modifiers/on_spec.rb
+- spec/integration/modifiers/strict_spec.rb
+- spec/integration/modifiers/unless_spec.rb
+- spec/integration/validations_spec.rb
+- spec/lib/arguments_spec.rb
+- spec/lib/validates_subset_spec.rb
+- validates_subset.gemspec
+- version.rb
+homepage: http://rubygems.org/gems/validates_subset
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Subset validation for ActiveModel/ActiveRecord models
+test_files:
+- spec/integration/modifiers/allow_blank_spec.rb
+- spec/integration/modifiers/allow_nil_spec.rb
+- spec/integration/modifiers/if_spec.rb
+- spec/integration/modifiers/message_spec.rb
+- spec/integration/modifiers/multiple_spec.rb
+- spec/integration/modifiers/on_spec.rb
+- spec/integration/modifiers/strict_spec.rb
+- spec/integration/modifiers/unless_spec.rb
+- spec/integration/validations_spec.rb
+- spec/lib/arguments_spec.rb
+- spec/lib/validates_subset_spec.rb