rails_legit 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 855b56aca820aa680b2a95ec3572d28a617d06bf
-  data.tar.gz: 41482d5be38796fff7d213e38dd5c1d7e04958a7
+  metadata.gz: e68fe7cabdf5878a6f9deaf9d0e7f0c2efb3e11e
+  data.tar.gz: cd7bb79827297860febee58476ca90540573c883
 SHA512:
-  metadata.gz: e33a786477a8919de7133ed63008aa73e06050b143aeb285148c737a064ecb25fd86ce3de0d4afbd1aff8320ef4db3dc9173cd45b731bac618e5f88e02618ec3
-  data.tar.gz: 1a5dd6eb87d1847579fa906da2b1c22ef45ca74d01789391d68ac5c35364e8897079c6096c3926d608560675f505e6b0a20727fa0cd042074b4094475f8ca13a
+  metadata.gz: 2e4cb7d0d52ed1f427006ce9fc3f220777ef83fc772038a8d05aa3fe087453d31fcd3ec220a915c103bdcacb782694285fd708da0002846ff595bc9ebcb71c61
+  data.tar.gz: 7e6fc9d98bde417a6911ca836ebd1b97f0098d969d1618f84fe63e0cd4b07080fe10e1ca4b3de3f92983523b848e428b77ccca086e92e8e3e32c139711f9e3f7

data/README.md

@@ -44,23 +44,27 @@ can create events where they can specify the start times and the end times
 of the event. `EventForm` is such a class that is a non-persistent model of
 the event record.
 
-    class Event < ActiveRecord::Base
-      # has the following attributes:
-      # name
-      # description
-      # to
-      # from
-    end
+```ruby
+class Event < ActiveRecord::Base
+  # has the following attributes:
+  # name
+  # description
+  # to
+  # from
+end
+```
 
 The `to` and `from` are DateTime objects that get stored in the DB. And the
 corresponding ActiveModel form: (assuming Rails 4)
 
-    class EventForm
-      include ActiveModel::Model
-      attr_accessor :name, :description, :to, :from
-      attr_accessor :to_date, :to_time
-      attr_accessor :from_date, :from_time
-    end
+```ruby
+class EventForm 
+  include ActiveModel::Model
+  attr_accessor :name, :description, :to, :from
+  attr_accessor :to_date, :to_time
+  attr_accessor :from_date, :from_time
+end
+```
 
 The `:to_date`, `:to_time`, `:from_date`, `:from_time` are the attributes
 for the data that is returned from the UI where there are separate inputs
@@ -69,17 +73,21 @@ for start date, end date, start time and end time.
 To use the `DateValidator`, include the `RailsLegit` module in the
 `EventForm` class:
 
-    class EventForm
-      # unchanged from above
-      include RailsLegit
-    end
+```ruby
+class EventForm
+  # unchanged from above
+  include RailsLegit
+end
+```
 
 Adding validations is as simple as:
 
-    class EventForm
-      # unchanged from above
-      validates :from_date, :to_date, verify_date: true
-    end
+```ruby
+class EventForm
+  # unchanged from above
+  validates :from_date, :to_date, date: true
+end
+```
 
 Currently supported validation syntax elements are:
 
@@ -97,22 +105,127 @@ The valid options are `:before`, `:after`, `:on_or_before`, `:on_or_after`, `:on
 You can pass in a method as a symbol, string or a `Date` object. By default, all symbols except
 `:current`, `:today`, `:now` are sent to the object under validation.
 
-    validates :from_date, verify_date: { before: :current } # Date.current is used
-    validates :from_date, verify_date: { before: :today   } # Date.current is used
-    validates :from_date, verify_date: { before: :now     } # Date.current is used
+```ruby
+validates :from_date, date: { greater_than: :current } # Date.current is used
+validates :from_date, date: { greater_than: :today   } # Date.current is used 
+validates :from_date, date: { greater_than: :now     } # Date.current is used
 
-    validates :from_date, verify_date: { before: :end_date } # <EventForm Object>.end_date is used
+validates :from_date, date: { greater_than: :end_date } # <EventForm Object>.end_date is used
+```
 
 Finally,
 
-    class EventForm
-      attr_accessor :to_date, :from_date
-      include ActiveModel::Model
-      include RailsLegit
-      validates :from_date, verify_date: { before: :today }
-      validates :to_date, verify_date: { before: :from_date }
+```ruby
+class EventForm
+  attr_accessor :to_date, :from_date
+  include ActiveModel::Model
+  include RailsLegit
+  validates :from_date, date: { greater_than: :today }
+  validates :to_date, date: { greater_than: :from_date }
+end
+```
+
+### Array Validator
+
+It is quite common to check whether an array of attributes is a subset
+of another array -- a list of valid IDs, for example. The `VerifyArray`
+validator handles the three cases of `:in`, :not_in` and `:eq`. The
+abstract functionality is as follows:
+
+    # The simplest case would be to verify if a record attribute is an
+    # Array
+    validates [1, 2], verify_array: true                    # => true
+
+    # Or, you could specify options. Supported options are :in, :not_in,
+    # :eq
+
+    validates [1, 2, 3], verify_array: { in: [1, 2, 3, 4] } # => true
+    # Note: The :in and :not_in validators are not strict. That is, the
+    # following will work as expected. This is similar to :eq in this
+    # case
+    validates [1, 2, 3], verify_array: { in: [1, 2, 3] }    # => true
+    validates [1, 2, 3], verify_array: { in: [1, 2] }       # => false
+
+    # The ordering is not a factor
+    validates [3, 2, 1], verify_array: { in: [1, 2, 3, 4] } # => true
+
+    validates [1, 2], verify_array: { not_in: [4, 5] }      # => true
+    validates [1, 2], verify_array: { not_in: [1, 5] }      # => true
+
+    # :eq is a strict validator which will result true only if the given
+    # array contains the exact same elements (irrespective of order)
+    # compared to the verification array.
+
+    validates [1, 2], verify_array: { eq: [2, 1] }          # => true
+    validates [1, 2], verify_array: { eq: [3, 1] }          # => false
+
+Use this in validating your models like so:
+
+    # Specify a Symbol which is a method defined on the model
+    class EventInvitees < ActiveRecord::Base
+      validates :invited_users, verify_array: { in: :valid_users_in_db }
+
+      def valid_users_in_db
+        User.all.pluck(:id).map(&:to_s)
+      end
+    end
+
+    # or, specify an Array
+    class EventInvitees < ActiveRecord::Base
+      validates :invited_users, verify_array: { in: [1, 25, 155] }
+    end
+
+    # or, specify a Proc that returns an array
+    class EventInvitees < ActiveRecord::Base
+      validates :invited_users, verify_array: { in: ->{ [1, 25, 155] } }
+    end
+
+
+The only caveat here is that the verification item (symbol/proc) should
+return an Array.
+
+### Hash Validator
+
+To validate a hash, you can do like so:
+
+    # some_hash = { one: 1, two: 2, three: 3 }
+    validates some_hash, verify_hash: { keys: [:one, :two, :three] } # => true
+    validates some_hash, verify_hash: { values: [1, 2, 3] }          # => true
+
+The valid options are `:keys` and `:values`. You can pass in an Array or
+a Proc that evaluates to an array or a method that is defined inside the
+class.
+
+    # You can use an Array as the option's value
+
+    class User < ActiveRecord::Base
+      validates :settings, verify_hash: { keys: ['public_email', 'public_profile'] }
     end
 
+    # You can use a Proc
+
+    class User < ActiveRecord::Base
+      validates :settings, verify_hash: { keys: -> { ['public_email', 'public_profile'] } }
+    end
+
+    # Or, you can use a Symbol if a method with that name is defined
+
+    class User < ActiveRecord::Base
+      validates :settings, verify_hash: { keys: :accepted_settings }
+
+      # The method can be private or a visible one
+      private
+
+      def accepted_settings
+        ['public_email', 'public_profile']
+      end
+    end
+
+The keys or values are checked for existence and not for equality. In
+other words even if the hash in the first example in Hash section was `{
+one: 1, two: 2 }`, it would still validate to true. To add to that, the
+ordering is not significant.
+
 ## Contributing
 
 1. Fork it

data/lib/rails_legit/verify_array_validator.rb

@@ -0,0 +1,88 @@
+module RailsLegit
+  class VerifyArrayValidator < ActiveModel::EachValidator
+
+    VALID_COMPARISIONS = [
+      :in, :not_in, :eq
+    ].freeze
+
+    attr_accessor :comparisions
+
+    def initialize(options)
+      super
+      @comparisions = {}
+      process_options!
+    end
+
+    def validate_each(record, attribute, value)
+      unless value.is_a?(Array)
+        record.errors.add(attribute, "Not an Array")
+        return
+      end
+
+      comparisions.each do |k, v|
+        if v.nil?
+          raise ArgumentError, "Cannot compare an array with nil"
+        elsif v.is_a?(Symbol)
+          if record.respond_to?(v, true)
+            array_to_be_compared_with = record.send(v)
+            if array_to_be_compared_with && array_to_be_compared_with.is_a?(Array)
+              compare_both_arrays(value, array_to_be_compared_with, attribute, k, record)
+            else
+              raise ArgumentError, "The comparision value was not an Array or didn't evaluate to an Array. It was #{array_to_be_compared_with}"
+            end
+          else
+            raise NoMethodError, "No method named #{v} on the record supplied"
+          end
+        elsif v.is_a?(Array)
+          compare_both_arrays(value, v, attribute, k, record)
+        else
+          raise ArgumentError, "The comparision can be done against an array or a Proc that evaluates to an array"
+        end
+      end
+    end
+
+    def check_validity!
+      options.keys.each do |key|
+        unless VALID_COMPARISIONS.member?(key)
+          raise ArgumentError, "Valid keys for options are #{VALID_COMPARISIONS.join(', ')}"
+        end
+      end
+    end
+
+    private
+
+    def compare_both_arrays(record_array, verification_array, attribute, type_of_comparision, record)
+      record_array_set = SortedSet.new(record_array)
+      verification_array_set = SortedSet.new(verification_array)
+
+      case type_of_comparision
+      when :in
+        unless record_array_set.subset?(verification_array_set)
+          record.errors.add(attribute, "The given array is not a subset of #{verification_array}. Expected it to not be one")
+        end
+      when :not_in
+        if record_array_set.subset?(verification_array_set)
+          record.errors.add(attribute, "The given array is a subset of #{verification_array}. Expected it to not be one")
+        end
+      when :eq
+        unless record_array_set == verification_array_set
+          record.errors.add(attribute, "The given array is not equal to #{verification_array}. Expected it to be equal")
+        end
+      end
+    end
+
+    def process_options!
+      options.each do |k, v|
+        unless v.is_a?(Proc) || v.is_a?(Symbol) || v.is_a?(Array)
+          raise ArgumentError, "Valid values for options are a Proc or Symbol or an Array"
+        end
+
+        if v.is_a?(Proc)
+          comparisions[k] = v.call
+        elsif v.is_a?(Array) || v.is_a?(Symbol)
+          comparisions[k] = v
+        end
+      end
+    end
+  end
+end

data/lib/rails_legit/verify_hash_validator.rb

@@ -0,0 +1,85 @@
+module RailsLegit
+  class VerifyHashValidator < ActiveModel::EachValidator
+
+    VALID_COMPARISIONS = [
+      :keys,
+      :values
+    ].freeze
+
+    attr_accessor :comparisions
+
+    def initialize(options)
+      super
+      @comparisions = {}
+      process_options!
+    end
+
+    def validate_each(record, attribute, value)
+      unless value.is_a?(Hash)
+        record.errors.add(attribute, "Not a Hash")
+        return
+      end
+
+
+      comparisions.each do |k, v|
+        if v.nil?
+          raise ArgumentError, "Cannot compare with nil"
+        elsif v.is_a?(Symbol)
+          if record.respond_to?(v, true)
+            array_to_be_compared_with = record.send(v)
+            if array_to_be_compared_with && array_to_be_compared_with.is_a?(Array)
+              compare_both_arrays(value, array_to_be_compared_with, attribute, k, record)
+            else
+              raise ArgumentError, "The comparision value was not an Array or didn't evaluate to an Array. It was #{array_to_be_compared_with}"
+           end
+          else
+            raise NoMethodError, "No method named #{v} on the record supplied"
+          end
+        elsif v.is_a?(Array)
+         compare_both_arrays(value, v, attribute, k, record)
+        else
+          raise ArgumentError, "The comparision can be done against an array or a Proc that evaluates to an array"
+        end
+      end
+    end
+
+    def check_validity!
+      options.keys.each do |key|
+        unless VALID_COMPARISIONS.member?(key)
+          raise ArgumentError, "Valid keys for options are #{VALID_COMPARISIONS.join(', ')}"
+        end
+      end
+    end
+
+    private
+
+    def compare_both_arrays(record_hash, verification_array, attribute, type_of_comparision, record)
+      case type_of_comparision
+      when :keys
+        record_array_set = SortedSet.new(record_hash.keys)
+        verification_array_set = SortedSet.new(verification_array)
+      when :values
+        record_array_set = SortedSet.new(record_hash.values)
+        verification_array_set = SortedSet.new(verification_array)
+      end
+
+      unless record_array_set.subset?(verification_array_set)
+        record.errors.add(attribute, "The given array is not a subset of #{verification_array}. Expected it to not be one")
+      end
+    end
+
+    def process_options!
+      options.each do |k, v|
+        unless v.is_a?(Proc) || v.is_a?(Symbol) || v.is_a?(Array)
+          raise ArgumentError, "You need to specify either an Array or a Symbol or a Proc that returns an Array as an option value"
+        end
+
+        if v.is_a?(Proc)
+          comparisions[k] = v.call
+        elsif v.is_a?(Array) || v.is_a?(Symbol)
+          comparisions[k] = v
+        end
+      end
+    end
+  end
+end

data/lib/rails_legit/version.rb

@@ -1,3 +1,3 @@
 module RailsLegit
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/rails_legit.rb

@@ -5,4 +5,6 @@ module RailsLegit
   extend ActiveSupport::Autoload
 
   autoload :VerifyDateValidator
+  autoload :VerifyArrayValidator
+  autoload :VerifyHashValidator
 end

data/rails_legit.gemspec

@@ -20,6 +20,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rails"
   spec.add_development_dependency "rspec"
+  spec.add_dependency "activemodel", "~> 4.0.0"
 end

data/spec/spec_helper.rb

@@ -6,7 +6,7 @@
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 
 require File.expand_path("../../lib/rails_legit.rb", __FILE__)
-Dir["spec/support/**/*.rb"].each { |f| require File.expand_path(f) }
+#Dir["spec/support/**/*.rb"].each { |f| require File.expand_path(f) }
 
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true

data/spec/support/array.rb

@@ -0,0 +1,89 @@
+require "active_model"
+
+# Setup Classes
+
+class NoOptionsSingleAttribute
+  include ActiveModel::Validations
+  include RailsLegit
+
+  validates :array, verify_array: true
+
+  attr_accessor :array
+  def initialize(array)
+    @array = array
+  end
+end
+
+class BaseRecord
+  include ActiveModel::Validations
+  include RailsLegit
+
+  attr_accessor :array, :anotherarray
+
+  def initialize(array, anotherarray)
+    @array = array
+    @anotherarray = anotherarray
+  end
+end
+
+class NoOptionsMultipleAttributes < BaseRecord
+  validates :array, :anotherarray, verify_array: true
+end
+
+class MultipleAttributesInOptionArray < BaseRecord
+  validates :array, :anotherarray, verify_array: { in: [1, 2, 3, 4] }
+end
+
+class MultipleAttributesNotInOptionArray < BaseRecord
+  validates :array, :anotherarray, verify_array: { not_in: [1, 2, 3, 4] }
+end
+
+class MultipleAttributesInOptionProc < BaseRecord
+  validates :array, :anotherarray, verify_array: { in: ->{ [1, 2, 3, 4] } }
+end
+
+class MultipleAttributesNotInOptionProc < BaseRecord
+  validates :array, :anotherarray, verify_array: { not_in: ->{ [1, 2, 3, 4] } }
+end
+
+class MultipleAttributesInOptionSymbol < BaseRecord
+  validates :array, :anotherarray, verify_array: { in: :some_other_array }
+
+  private
+
+  def some_other_array
+    [1, 2, 3, 4]
+  end
+end
+
+class MultipleAttributesNotInOptionSymbol < BaseRecord
+  validates :array, :anotherarray, verify_array: { not_in: :some_other_array }
+
+  private
+
+  def some_other_array
+    [1, 2, 3, 4]
+  end
+end
+
+class MultipleAttributesBothOptionsSymbol < BaseRecord
+  validates :array, :anotherarray, verify_array: { in: :some_array, not_in: :some_other_array }
+
+  private
+
+  def some_array
+    [1, 2, 3, 4]
+  end
+
+  def some_other_array
+    [5, 6, 7, 8]
+  end
+end
+
+class MultipleAttributesBothOptionsProc < BaseRecord
+  validates :array, :anotherarray, verify_array: { in: ->{ [1, 2, 3, 4] }, not_in: ->{ [5, 6, 7, 8] } }
+end
+
+class MultipleAttributesBothOptionsArray < BaseRecord
+  validates :array, :anotherarray, verify_array: { in: [1, 2, 3, 4], not_in: [5, 6, 7, 8] }
+end

data/spec/support/date.rb

@@ -1,3 +1,5 @@
+require "active_model"
+
 shared_examples "basic date validations" do
 
   context "Invalid Date" do
@@ -25,3 +27,71 @@ shared_examples "basic date validations" do
     it { should be_valid }
   end
 end
+
+# Setup Classes
+
+class TestRecordWithNoExtraOptions
+  include ActiveModel::Validations
+  include RailsLegit
+
+  validates :date, verify_date: true
+
+  attr_accessor :date
+  def initialize(date)
+    @date = date
+  end
+end
+
+class TestRecordWithNoExtraOptionsMultipleAttributes
+  include ActiveModel::Validations
+  include RailsLegit
+
+  validates :date, :anotherdate, verify_date: true
+
+  attr_accessor :date, :anotherdate
+  def initialize(date, anotherdate)
+    @date = date
+    @anotherdate = anotherdate
+  end
+end
+
+class TestRecordWithMultipleAttributesBeforeOption
+  include ActiveModel::Validations
+  include RailsLegit
+
+  validates :date, :anotherdate, verify_date: { before: :before_date }
+
+  attr_accessor :date, :anotherdate, :before_date
+  def initialize(date, anotherdate, before_date)
+    @date = date
+    @anotherdate = anotherdate
+    @before_date = before_date
+  end
+end
+
+class TestRecordWithMultipleAttributesBeforeOptionCurrentSymbol
+  include ActiveModel::Validations
+  include RailsLegit
+
+  validates :date, :anotherdate, verify_date: { before: :today }
+
+  attr_accessor :date, :anotherdate, :before_date
+  def initialize(date, anotherdate, before_date)
+    @date = date
+    @anotherdate = anotherdate
+    @before_date = before_date
+  end
+end
+
+class TestRecordWithMultipleAttributesBeforeOptionProc
+  include ActiveModel::Validations
+  include RailsLegit
+
+  validates :date, :anotherdate, verify_date: { before: ->{ Date.today + 1 } }
+
+  attr_accessor :date, :anotherdate
+  def initialize(date, anotherdate)
+    @date = date
+    @anotherdate = anotherdate
+  end
+end

data/spec/support/hash.rb

@@ -0,0 +1,90 @@
+require "active_model"
+
+# Setup Classes
+
+class NoExtraOptionsHash
+  include ActiveModel::Validations
+  include RailsLegit
+
+  validates :hash, verify_hash: true
+
+  attr_accessor :hash
+  def initialize(hash)
+    @hash = hash
+  end
+end
+
+class BaseRecordHashValidator
+  include ActiveModel::Validations
+  include RailsLegit
+
+
+  attr_accessor :hash, :anotherhash
+  def initialize(hash, anotherhash)
+    @hash = hash
+    @anotherhash = anotherhash
+  end
+
+end
+
+class NoOptionsMultipleAttributesHash < BaseRecordHashValidator
+  validates :hash, :anotherhash, verify_hash: true
+end
+
+class MultipleAttributesKeysOptionSymbol < BaseRecordHashValidator
+  validates :hash, :anotherhash, verify_hash: { keys: :some_other_array }
+
+  private
+
+  def some_other_array
+    [:one, :two, :three, :four, :five]
+  end
+end
+
+class MultipleAttributesValuesOptionSymbol < BaseRecordHashValidator
+  validates :hash, :anotherhash, verify_hash: { values: :some_other_array }
+
+  private
+
+  def some_other_array
+    [1, 2, 3, 4, 5]
+  end
+end
+
+class MultipleAttributesKeysOptionArray < BaseRecordHashValidator
+  validates :hash, :anotherhash, verify_hash: { keys: [:one, :two, :three, :four] }
+end
+
+class MultipleAttributesValuesOptionArray < BaseRecordHashValidator
+  validates :hash, :anotherhash, verify_hash: { values: [1, 2, 3, 4] }
+end
+
+class MultipleAttributesKeysOptionProc < BaseRecordHashValidator
+  validates :hash, :anotherhash, verify_hash: { keys: ->{ [:one, :two, :three, :four] } }
+end
+
+class MultipleAttributesValuesOptionProc < BaseRecordHashValidator
+  validates :hash, :anotherhash, verify_hash: { values: ->{ [1, 2, 3, 4] } }
+end
+
+class MultipleAttributesKeysValuesOptionProc < BaseRecordHashValidator
+  validates :hash, :anotherhash, verify_hash: { keys: ->{ [:one, :two, :three, :four] }, values: ->{ [1, 2, 3, 4] } }
+end
+
+class MultipleAttributesKeysValuesOptionArray < BaseRecordHashValidator
+  validates :hash, :anotherhash, verify_hash: { keys: [:one, :two, :three, :four], values: [1, 2, 3, 4] }
+end
+
+class MultipleAttributesKeysValuesOptionSymbol < BaseRecordHashValidator
+  validates :hash, :anotherhash, verify_hash: { keys: :some_array, values: :some_other_array }
+
+  def some_array
+    [:one, :two, :three, :four]
+  end
+
+  private
+
+  def some_other_array
+    [1, 2, 3, 4]
+  end
+end

data/spec/verify_array_validator_spec.rb

@@ -0,0 +1,186 @@
+require "spec_helper"
+require "support/array"
+
+describe RailsLegit::VerifyArrayValidator do
+  subject { record }
+
+  describe "No Extra Options provided" do
+    let(:record) { NoOptionsSingleAttribute.new(array) }
+
+    context "Valid Array" do
+      let(:array) { [1, 2, 3] }
+      it { should be_valid }
+    end
+
+    context "Invalid Array" do
+      let(:array) { "Invalid Array" }
+
+      it { should_not be_valid }
+      it "should attach error on appropriate method" do
+        record.valid?
+        expect(record.errors[:array]).to include("Not an Array")
+      end
+    end
+  end
+
+  describe "No Extra Options provided and multiple attributes" do
+    let(:record) { NoOptionsMultipleAttributes.new(array, anotherarray) }
+    let(:anotherarray) { [1, 2, 3] }
+
+    context "Valid Array" do
+      let(:array) { [1, 2, 3] }
+      it { should be_valid }
+    end
+
+    context "Invalid Array on comparision method" do
+      let(:anotherarray) { "Invalid Array" }
+      let(:array) { [1, 2, 3] }
+
+      it { should_not be_valid }
+      it "should attach error on appropriate method" do
+        record.valid?
+        expect(record.errors[:anotherarray]).to include("Not an Array")
+      end
+    end
+  end
+
+  describe "Multiple attributes, Valid case" do
+    let(:array) { [1, 2, 3] }
+    let(:anotherarray) { [4, 3] }
+
+    context "In validator" do
+      context "comparision object is a Proc" do
+        let(:record) { MultipleAttributesInOptionProc.new(array, anotherarray) }
+
+        it { should be_valid }
+      end
+
+      context "comparision object is a Symbol" do
+        let(:record) { MultipleAttributesInOptionSymbol.new(array, anotherarray) }
+
+        it { should be_valid }
+      end
+
+      context "comparision object is Array" do
+        let(:record) { MultipleAttributesInOptionArray.new(array, anotherarray) }
+
+        it { should be_valid }
+      end
+    end
+
+    context "NotIn validator" do
+      context "comparision object is a Proc" do
+        let(:record) { MultipleAttributesNotInOptionProc.new(array, anotherarray) }
+
+        it { should_not be_valid }
+      end
+
+      context "comparision object is a Symbol" do
+        let(:record) { MultipleAttributesNotInOptionSymbol.new(array, anotherarray) }
+
+        it { should_not be_valid }
+      end
+
+      context "comparision object is Array" do
+        let(:record) { MultipleAttributesNotInOptionArray.new(array, anotherarray) }
+
+        it { should_not be_valid }
+      end
+    end
+  end
+
+  describe "Multiple attributes, Invalid case" do
+    let(:array) { [4, 1, 5] }
+    let(:anotherarray) { [8, 9] }
+
+    context "In validator" do
+      context "comparision object is a Proc" do
+        let(:record) { MultipleAttributesInOptionProc.new(array, anotherarray) }
+
+        it { should_not be_valid }
+      end
+
+      context "comparision object is a Symbol" do
+        let(:record) { MultipleAttributesInOptionSymbol.new(array, anotherarray) }
+
+        it { should_not be_valid }
+      end
+
+      context "comparision object is Array" do
+        let(:record) { MultipleAttributesInOptionArray.new(array, anotherarray) }
+
+        it { should_not be_valid }
+      end
+    end
+
+    context "NotIn validator" do
+      context "comparision object is a Proc" do
+        let(:record) { MultipleAttributesNotInOptionProc.new(array, anotherarray) }
+
+        it { should be_valid }
+      end
+
+      context "comparision object is a Symbol" do
+        let(:record) { MultipleAttributesNotInOptionSymbol.new(array, anotherarray) }
+
+        it { should be_valid }
+      end
+
+      context "comparision object is Array" do
+        let(:record) { MultipleAttributesNotInOptionArray.new(array, anotherarray) }
+
+        it { should be_valid }
+      end
+    end
+  end
+
+  describe "Both Options, Valid case" do
+    let(:array) { [1, 2] }
+    let(:anotherarray) { [1, 2, 3, 4] }
+
+    context "In validator" do
+      context "comparision against Proc" do
+        let(:record) { MultipleAttributesBothOptionsProc.new(array, anotherarray) }
+
+        it { should be_valid }
+      end
+
+      context "comparision against Symbol" do
+        let(:record) { MultipleAttributesBothOptionsSymbol.new(array, anotherarray) }
+
+        it { should be_valid }
+      end
+
+      context "comparision against Array" do
+        let(:record) { MultipleAttributesBothOptionsArray.new(array, anotherarray) }
+
+        it { should be_valid }
+      end
+    end
+  end
+
+  describe "Both Options, Invalid case" do
+    let(:array) { [5, 6] }
+    let(:anotherarray) { [3, 4] }
+
+    context "In validator" do
+      context "comparision against Proc" do
+        let(:record) { MultipleAttributesBothOptionsProc.new(array, anotherarray) }
+
+        it { should_not be_valid }
+      end
+
+      context "comparision against Symbol" do
+        let(:record) { MultipleAttributesBothOptionsSymbol.new(array, anotherarray) }
+
+        it { should_not be_valid }
+      end
+
+      context "comparision against Array" do
+        let(:record) { MultipleAttributesBothOptionsArray.new(array, anotherarray) }
+
+        it { should_not be_valid }
+      end
+    end
+  end
+end

data/spec/verify_date_validator_spec.rb

@@ -1,71 +1,5 @@
 require "spec_helper"
-require "active_model"
-
-class TestRecordWithNoExtraOptions
-  include ActiveModel::Validations
-  include RailsLegit
-
-  validates :date, verify_date: true
-
-  attr_accessor :date
-  def initialize(date)
-    @date = date
-  end
-end
-
-class TestRecordWithNoExtraOptionsMultipleAttributes
-  include ActiveModel::Validations
-  include RailsLegit
-
-  validates :date, :anotherdate, verify_date: true
-
-  attr_accessor :date, :anotherdate
-  def initialize(date, anotherdate)
-    @date = date
-    @anotherdate = anotherdate
-  end
-end
-
-class TestRecordWithMultipleAttributesBeforeOption
-  include ActiveModel::Validations
-  include RailsLegit
-
-  validates :date, :anotherdate, verify_date: { before: :before_date }
-
-  attr_accessor :date, :anotherdate, :before_date
-  def initialize(date, anotherdate, before_date)
-    @date = date
-    @anotherdate = anotherdate
-    @before_date = before_date
-  end
-end
-
-class TestRecordWithMultipleAttributesBeforeOptionCurrentSymbol
-  include ActiveModel::Validations
-  include RailsLegit
-
-  validates :date, :anotherdate, verify_date: { before: :today }
-
-  attr_accessor :date, :anotherdate, :before_date
-  def initialize(date, anotherdate, before_date)
-    @date = date
-    @anotherdate = anotherdate
-    @before_date = before_date
-  end
-end
-
-class TestRecordWithMultipleAttributesBeforeOptionProc
-  include ActiveModel::Validations
-  include RailsLegit
-
-  validates :date, :anotherdate, verify_date: { before: ->{ Date.today + 1 } }
-
-  attr_accessor :date, :anotherdate
-  def initialize(date, anotherdate)
-    @date = date
-    @anotherdate = anotherdate
-  end
-end
+require "support/date"
 
 describe RailsLegit::VerifyDateValidator do
   describe "No Extra Options provided" do

data/spec/verify_hash_validator_spec.rb

@@ -0,0 +1,186 @@
+require "spec_helper"
+require "support/hash"
+
+describe RailsLegit::VerifyHashValidator do
+  describe "No Extra Options provided" do
+    let(:record) { NoExtraOptionsHash.new(hash) }
+    subject { record }
+
+    context "Valid Hash" do
+      let(:hash) { { one: 1, two: 2, three: 3, four: 4 } }
+      it { should be_valid }
+    end
+
+    context "Invalid Hash" do
+      let(:hash) { "Invalid Hash" }
+
+      it { should_not be_valid }
+      it "should attach error on appropriate method" do
+        record.valid?
+        expect(record.errors[:hash]).to include("Not a Hash")
+      end
+    end
+  end
+
+  describe "No Extra Options provided and multiple attributes" do
+    let(:record) { NoOptionsMultipleAttributesHash.new(hash, anotherhash) }
+    let(:anotherhash) { {one: 1, two: 2} }
+    subject { record }
+
+    context "Valid Hash" do
+      let(:hash) { {one: 1, two: 2, three: 3} }
+      it { should be_valid }
+    end
+
+    context "Invalid Hash on comparision method" do
+      let(:anotherhash) { "Invalid Hash" }
+      let(:hash) { { one: 1, two: 2, three: 3 } }
+
+      it { should_not be_valid }
+      it "should attach error on appropriate method" do
+        record.valid?
+        expect(record.errors[:anotherhash]).to include("Not a Hash")
+      end
+    end
+  end
+
+  describe "Individual Keys and Values options, Multiple attributes, Valid case" do
+    let(:hash) { { one: 1, two: 2, three: 3 } }
+    let(:anotherhash) { { four: 4, three: 3 } }
+    subject { record }
+
+    context "Keys as the option" do
+      context "comparision object is a Proc" do
+        let(:record) { MultipleAttributesKeysOptionProc.new(hash, anotherhash) }
+
+        it { should be_valid }
+      end
+
+      context "comparision object is a Symbol" do
+        let(:record) { MultipleAttributesKeysOptionSymbol.new(hash, anotherhash) }
+
+        it { should be_valid }
+      end
+
+      context "comparision object is Array" do
+        let(:record) { MultipleAttributesKeysOptionArray.new(hash, anotherhash) }
+
+        it { should be_valid }
+      end
+    end
+
+    context "Values as the option" do
+      context "comparision object is a Proc" do
+        let(:record) { MultipleAttributesValuesOptionProc.new(hash, anotherhash) }
+
+        it { should be_valid }
+      end
+
+      context "comparision object is a Symbol" do
+        let(:record) { MultipleAttributesValuesOptionSymbol.new(hash, anotherhash) }
+
+        it { should be_valid }
+      end
+
+      context "comparision object is Array" do
+        let(:record) { MultipleAttributesValuesOptionArray.new(hash, anotherhash) }
+
+        it { should be_valid }
+      end
+    end
+  end
+
+  describe "Individual Keys and Values options, Multiple attributes, Invalid case" do
+    let(:hash) { { seven: 7, eight: 8, nine: 9 } }
+    let(:anotherhash) { { ten: 10, eleven: 11 } }
+    subject { record }
+
+    context "Keys as the option" do
+      context "comparision object is a Proc" do
+        let(:record) { MultipleAttributesKeysOptionProc.new(hash, anotherhash) }
+
+        it { should_not be_valid }
+      end
+
+      context "comparision object is a Symbol" do
+        let(:record) { MultipleAttributesKeysOptionSymbol.new(hash, anotherhash) }
+
+        it { should_not be_valid }
+      end
+
+      context "comparision object is Array" do
+        let(:record) { MultipleAttributesKeysOptionArray.new(hash, anotherhash) }
+
+        it { should_not be_valid }
+      end
+    end
+
+    context "Values as the option" do
+      context "comparision object is a Proc" do
+        let(:record) { MultipleAttributesValuesOptionProc.new(hash, anotherhash) }
+
+        it { should_not be_valid }
+      end
+
+      context "comparision object is a Symbol" do
+        let(:record) { MultipleAttributesValuesOptionSymbol.new(hash, anotherhash) }
+
+        it { should_not be_valid }
+      end
+
+      context "comparision object is Array" do
+        let(:record) { MultipleAttributesValuesOptionArray.new(hash, anotherhash) }
+
+        it { should_not be_valid }
+      end
+    end
+  end
+
+  describe "Both Keys and Values options, Multiple attributes, Valid case" do
+    let(:hash) { { one: 1, two: 2, three: 3 } }
+    let(:anotherhash) { { four: 4, three: 3 } }
+    subject { record }
+
+      context "comparision object is a Proc" do
+        let(:record) { MultipleAttributesKeysValuesOptionProc.new(hash, anotherhash) }
+
+        it { should be_valid }
+      end
+
+      context "comparision object is a Symbol" do
+        let(:record) { MultipleAttributesKeysValuesOptionSymbol.new(hash, anotherhash) }
+
+        it { should be_valid }
+      end
+
+      context "comparision object is Array" do
+        let(:record) { MultipleAttributesKeysValuesOptionArray.new(hash, anotherhash) }
+
+        it { should be_valid }
+      end
+  end
+
+  describe "Both Keys and Values options, Multiple attributes, Invalid case" do
+    let(:hash) { { five: 5, six: 6, seven: 7 } }
+    let(:anotherhash) { { nine: 9, ten: 10 } }
+    subject { record }
+
+      context "comparision object is a Proc" do
+        let(:record) { MultipleAttributesKeysValuesOptionProc.new(hash, anotherhash) }
+
+        it { should_not be_valid }
+      end
+
+      context "comparision object is a Symbol" do
+        let(:record) { MultipleAttributesKeysValuesOptionSymbol.new(hash, anotherhash) }
+
+        it { should_not be_valid }
+      end
+
+      context "comparision object is Array" do
+        let(:record) { MultipleAttributesKeysValuesOptionArray.new(hash, anotherhash) }
+
+        it { should_not be_valid }
+      end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_legit
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Kashyap
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-07 00:00:00.000000000 Z
+date: 2014-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -53,19 +53,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: 4.0.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.0.0
 description: Provides a DSL for common validation formats like Date, Array, DateTime
   etc.
 email:
@@ -80,12 +80,18 @@ files:
 - README.md
 - Rakefile
 - lib/rails_legit.rb
+- lib/rails_legit/verify_array_validator.rb
 - lib/rails_legit/verify_date_validator.rb
+- lib/rails_legit/verify_hash_validator.rb
 - lib/rails_legit/version.rb
 - rails_legit.gemspec
 - spec/spec_helper.rb
+- spec/support/array.rb
 - spec/support/date.rb
+- spec/support/hash.rb
+- spec/verify_array_validator_spec.rb
 - spec/verify_date_validator_spec.rb
+- spec/verify_hash_validator_spec.rb
 homepage: ''
 licenses:
 - MIT
@@ -112,5 +118,10 @@ specification_version: 4
 summary: Provides a DSL for common validation formats like Date, Array, DateTime etc.
 test_files:
 - spec/spec_helper.rb
+- spec/support/array.rb
 - spec/support/date.rb
+- spec/support/hash.rb
+- spec/verify_array_validator_spec.rb
 - spec/verify_date_validator_spec.rb
+- spec/verify_hash_validator_spec.rb
+has_rdoc: