dl_validator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1c05229f64b822fccb05d6bde7ee27eab8bb9174
+  data.tar.gz: d40fe53c6d599829a8efba5456b853bfba5854fb
+SHA512:
+  metadata.gz: 0ad7df42dd1b12b1d5bf82b5a4bf773cffd49ebec00eed152608c5e926b834af5053b752e3c483ed0c589b18dfce70576664ab1e8aa8b3a22073a54505f0a1a4
+  data.tar.gz: 9fc7b0dabe5031269375451e2516ef8f8e4f14f4b8ddfe30698664512ea46357fa8bc25f9260da6307f6a88d8dfd6dcdaacdca477dd37fc97cfe63ab5e64ed1e

data/.gitignore

@@ -0,0 +1,9 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.ruby-gemset
+.ruby-version
+.idea
+pkg/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dl_validator.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    dl_validator (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.0.0)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    atomic (1.1.10)
+    i18n (0.6.4)
+    minitest (4.3.2)
+    multi_json (1.7.7)
+    rake (10.0.4)
+    shoulda (3.5.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (>= 1.4.1, < 3.0)
+    shoulda-context (1.1.4)
+    shoulda-matchers (2.2.0)
+      activesupport (>= 3.0.0)
+    thread_safe (0.1.0)
+      atomic
+    tzinfo (0.3.37)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  dl_validator!
+  rake
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Andrew Medeiros
+
+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,43 @@
+# DlValidator
+
+DlValidator is a small gem that performs soft checks against a drivers license number and state. This is used only to flag a drivers license as being invalid, and is not intended to be considered true denial on a drivers license number.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'dl_validator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dl_validator
+
+## Usage
+
+With a drivers license number and drivers license state
+
+```ruby
+DlValidator.invalid?('F123456789012', 'FL') => false
+DlValidator.invalid?('F7834', 'FL') => true
+```
+
+Inside your rails model. Dependent on fields :drivers_license_number and :drivers_license_state
+```ruby
+class DriversLicense < ActiveRecord::Base
+  attr_accessible :drivers_license_number, :drivers_license_state
+  validates :drivers_license_number, :drivers_license_state, :drivers_license_invalid => true
+end
+```
+
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |task|
+  task.libs << 'test'
+end
+
+task :default => [:test]

data/dl_validator.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dl_validator/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dl_validator'
+  spec.version       = DlValidator::VERSION
+  spec.authors       = ['Andrew Medeiros']
+  spec.email         = ['amedeiros0920@gmail.com']
+  spec.description   = %q{DlValidator is a small gem that performs soft checks against a drivers license number and state. This is used only to flag a drivers license as being invalid, and is not intended to be considered true denial on a drivers license number.}
+  spec.summary       = %q{DlValidator is a small gem that performs soft checks against a drivers license number and state. This is used only to flag a drivers license as being invalid, and is not intended to be considered true denial on a drivers license number.}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  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_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'shoulda'
+end

data/lib/config/config.rb

@@ -0,0 +1,113 @@
+module DlValidator
+  class Config
+    # Constant frozen hash of states and abbreviations
+    STATES = {
+        'AL' =>	'ALABAMA',
+        'AK' =>	'ALASKA',
+        'AZ' =>	'ARIZONA',
+        'AR' =>	'ARKANSAS',
+        'CA' =>	'CALIFORNIA',
+        'CO' =>	'COLORADO',
+        'CT' =>	'CONNECTICUT',
+        'DE' =>	'DELAWARE',
+        'DC' =>	'DISTRICT OF COLUMBIA',
+        'FL' =>	'FLORIDA',
+        'GA' =>	'GEORGIA',
+        'HI' =>	'HAWAII',
+        'ID' =>	'IDAHO',
+        'IL' =>	'ILLINOIS',
+        'IN' =>	'INDIANA',
+        'IA' =>	'IOWA',
+        'KS' =>	'KANSAS',
+        'KY' =>	'KENTUCKY',
+        'LA' =>	'LOUISIANA',
+        'ME' =>	'MAINE',
+        'MD' =>	'MARYLAND',
+        'MA' =>	'MASSACHUSETTS',
+        'MI' =>	'MICHIGAN',
+        'MN' =>	'MINNESOTA',
+        'MS' =>	'MISSISSIPPI',
+        'MO' =>	'MISSOURI',
+        'MT' =>	'MONTANA',
+        'NE' =>	'NEBRASKA',
+        'NV' =>	'NEVADA',
+        'NH' =>	'NEW HAMPSHIRE',
+        'NJ' =>	'NEW JERSEY',
+        'NY' =>	'NEW YORK',
+        'NM' =>	'NEW MEXICO',
+        'NC' =>	'NORTH CAROLINA',
+        'ND' =>	'NORTH DAKOTA',
+        'OH' =>	'OHIO',
+        'OK' =>	'OKLAHOMA',
+        'OR' =>	'OREGON',
+        'PA' =>	'PENNSYLVANIA',
+        'RI' =>	'RHODE ISLAND',
+        'SC' =>	'SOUTH CAROLINA',
+        'SD' =>	'SOUTH DAKOTA',
+        'TN' =>	'TENNESSEE',
+        'TX' =>	'TEXAS',
+        'UT' =>	'UTAH',
+        'VT' =>	'VERMONT',
+        'VA' =>	'VIRGINIA',
+        'WA' =>	'WASHINGTON',
+        'WV' =>	'WEST VIRGINIA',
+        'WI' =>	'WISCONSIN',
+        'WY' =>	'WYOMING' }.freeze
+
+
+
+    # Constant frozen hash of regular expressions to validate a drivers license by state
+    STATES_REGEX = {
+        'AL' =>	/^([0-9]{7})$/,                                # Format: 7 numeric
+        'AK' => /^([0-9]{7})$/,                                # Format: 7 numeric
+        'AZ' => /^([A-Z][0-9]{8})$/,                           # Format: 1 Alpha 8 numeric
+        'AR' => /^([0-9]{8})$/,                                # Format: 8 Numeric
+        'CA' => /^([A-Z][0-9]{7})$/,                           # Format: 1 Alpha 7 Numeric
+        'CO' => /^([0-9]{9})$/,                                # Format: 9 Numeric
+        'CT' => /^((01|02|03|04|05|06|07|08|09|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24)[0-9]{7})$/, # Format: 9 Numeric; The first 2 digits can not be less than 01 or greater than 24.
+        'DE' => /^([0-9]{7})$/,                                # Format: 7 Numeric
+        'DC' => /^([0-9]{7})$/,                                # Format: 7 Numeric
+        'FL' => /^([A-Z][0-9]{12})$/,                          # Format: 1 Alpha 12 Numeric
+        'GA' => /^([0-9]{7,9})$/,                              # Format: 7-9 Numeric
+        'HI' => /^([H][0-9]{8})$/,                             # Format: H followed by 8 numeric
+        'ID' => /^([A-Z]{2}[0-9]{6}[A-Z])$/,                   # Format: 2 Alpha 6 Numeric 1 Alpha (example LS123456C)
+        'IL' => /^([A-Z][0-9]{11})$/,                          # Format: 1 alpha 11 numeric
+        'IN' => /^([0-9]{10})$/,                               # Format: 10 Numeric
+        'IA' => /^([0-9]{3}[A-Z]{2}[0-9]{4})$/,                # Format: 3 Numeric 2 Alpha 4 Numeric (example 123SL4567)
+        'KS' => /^([A-Z][0-9]{8})$/,                           # Format: 1 Alpha 8 Numeric
+        'KY' => /^([A-Z][0-9]{8})$/,                           # Format: 1 Alpha 8 Numeric
+        'LA' => /^((00|01)[0-9]{7})$/,                         # Format: 9 Numeric (First two numbers are 00 or 01)
+        'ME' => /^([0-9]{7})$/,                                # Format: 7 Numeric
+        'MD' => /^([A-Z][0-9]{12})$/,                          # Format: 1 Alpha 12 Numeric
+        'MA' => /^([A-Z][0-9]{8})$/,                           # Format: 1 Alpha 8 Numeric
+        'MI' => /^([A-Z][0-9]{12})$/,                          # Format: 1 Alpha 12 Numeric
+        'MN' => /^([A-Z][0-9]{12})$/,                          # Format: 1 Alpha 12 Numeric
+        'MS' => /^([0-9]{9})$/,                                # Format: 9 Numeric
+        'MO' => /^([A-Z][0-9]{5,9})$/,                         # Format: 1 Alpha 5-9 Numeric
+        'MT' => /^(([A-Z]|[0-9]){9})$/,                        # Format: 9 Alpha And Numeric Combination
+        'NE' => /^([A-Z][0-9]{3,8})$/,                         # Format: 1 Alpha 3-8 Numeric
+        'NV' => /^([0-9]{10}|[0-9]{12}|[X][0-9]{8})$/,         # Format: 10 Numeric; or 12 Numeric; or X Followed By 8 Numeric
+        'NH' => /^([0-9]{2}[A-Z]{3}[0-9]{5})$/,                # Format: 2 Numeric 3 Alpha 5 Numeric
+        'NJ' => /^([A-Z][0-9]{14})$/,                          # Format: 1 Alpha 14 Numeric
+        'NY' => /^([0-9]{9})$/,                                # Format: 9 Numeric
+        'NM' => /^([0-9]{9})$/,                                # Format: 9 Numeric
+        'NC' => /^([0-9]{6,9})$/,                              # Format: 6-9 Numeric
+        'ND' => /^([0-9]{9})$/,                                # Format: 9 Numeric
+        'OH' => /^([A-Z]{2}[0-9]{6})$/,                        # Format: 2 Alpha 6 Numeric
+        'OK' => /^([0-9]{9})$/,                                # Format: 9 Numeric
+        'OR' => /^([0-9]{5,7})$/,                              # Format: 5-7 Numeric
+        'PA' => /^([0-9]{8})$/,                                # Format: 8 Numeric
+        'RI' => /^([0-9]{7})$/,                                # Format: 7 Numeric
+        'SC' => /^([0-9]{9})$/,                                # Format: 9 Numeric
+        'SD' => /^([0-9]{8})$/,                                # Format: 8 Numeric
+        'TN' => /^([0-9]{7}|[0-9]{8}|[0-9]{9})$/,              # Format: 7,8 or 9 Numeric
+        'TX' => /^([0-9]{8})$/,                                # Format: 8 Numeric
+        'UT' => /^([0-9]{6,10})$/,                             # Format: 6-10 Numeric
+        'VT' => /^([0-9]{8}|[0-9]{7}[A-Z])$/,                  # Format: 8 Numeric; or 7 Numeric 1 Alpha
+        'VA' => /^([A-Z][0-9]{8})$/,                             # Format: 1 Alpha 8 Numeric
+        'WA' => /^(([A-Z]|[0-9]){12})$/,                       # Format: 12 Alpha And Numeric Combination
+        'WV' => /^([0-9]{7}|[A-Z][0-9]{6})$/,                    # Format: 7 Numeric; or 1 Alpha 6 Numeric
+        'WI' => /^([A-Z][0-9]{13})$/,                          # Format: 1 Alpha 13 Numeric
+        'WY' => /^([0-9]{9,10})$/ }.freeze                     # Format: 9-10 Numeric
+  end
+end

data/lib/dl_validator/version.rb

@@ -0,0 +1,3 @@
+module DlValidator
+  VERSION = "0.0.1"
+end

data/lib/dl_validator.rb

@@ -0,0 +1,38 @@
+require 'dl_validator/version'
+require 'config/config'
+require  'extensions/drivers_license_invalid_validator' if defined?(Rails)
+
+module DlValidator
+  def self.invalid?(dl_number, dl_state)
+    # Stop and return true if either dl_number or dl_state are nil
+    return true if dl_number.nil? or dl_state.nil?
+
+    # Downcase and remove non-word characters
+    dl_number = dl_number.to_s.upcase.gsub(/(\W|_)*/, '')
+    dl_state  = dl_state.to_s.upcase.gsub(/(\W|\d|_)*/, '')
+
+    # Stop here and return true if the state does not exist
+    return true if !Config::STATES.include?(dl_state) and !Config::STATES.values.include?(dl_state)
+
+    # Find the state abbreviation key we need to access our regex hash.
+    key = get_abbreviation_key(dl_state)
+
+    # Regular expression match to validate the drivers license is invalid or not
+    return false if Config::STATES_REGEX[key].match(dl_number)
+    true
+  end
+
+  # This is moved out into a method to make unit testing easier.
+  def self.get_abbreviation_key(dl_state)
+    # If the dl_state is greater than 2 then it is a full state name and we need to find the corresponding abbreviation for that state.
+    key = ''
+    if dl_state.length > 2
+      Config::STATES.each do |k, v|
+        key = k if v == dl_state
+      end
+    else
+      key = dl_state # The dl_state is already an abbreviated state
+    end
+    key
+  end
+end

data/lib/extensions/drivers_license_invalid_validator.rb

@@ -0,0 +1,17 @@
+class DriversLicenseInvalidValidator < ActiveModel::Validator
+  def validate(record)
+    if !@options[:attributes].include?(:drivers_license_number)
+      record.errors.add(:base, 'Missing required attribute drivers_license_number')
+    elsif !@options[:attributes].include?(:drivers_license_state)
+      record.errors.add(:base, 'Missing required attribute drivers_license_state')
+    elsif record.drivers_license_number.blank?
+      record.errors.add(:drivers_license_number, 'cannot be blank.')
+    elsif record.drivers_license_state.blank?
+      record.errors.add(:drivers_license_state, 'cannot be blank.')
+    else
+      invalid = DlValidator.invalid?(record.drivers_license_number, record.drivers_license_state)
+      record.errors.add(:base, 'Drivers license is invalid.') if invalid
+    end
+  end
+end
+

data/test/test_dl_validator.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+class DlValidatorTest < Test::Unit::TestCase
+  context DlValidator do
+    context '#invalid?' do
+
+      Helper::VALID_DRIVERS_LICENSES.each do |key, licenses_array|
+        licenses_array.each_with_index do |license, index|
+          should "be a valid drivers license #{license} - #{key} index: #{index}" do
+            assert !DlValidator.invalid?(license, key), key.inspect + ' ' + license.inspect
+          end
+        end
+      end
+
+      Helper::VALID_DRIVERS_LICENSES.each do |key, licenses_array|
+        licenses_array.each_with_index do |license, index|
+          should "not be a valid drivers license #{license} - #{key} index: #{index}" do
+            assert DlValidator.invalid?(license + '123ABC', key), key.inspect + ' ' + license + '123ABC'
+          end
+        end
+      end
+
+      should 'return true for an undefined state abbreviation' do
+        invalid = DlValidator.invalid?('123', 'QQ')
+        assert invalid
+      end
+
+      should 'return true for an undefined full state name' do
+        invalid = DlValidator.invalid?('123', 'BadState')
+        assert invalid
+      end
+
+      should 'handle a state abbreviation with non-word characters' do
+        state = '12}3 F (** __)L @ 5674``' # FL
+        assert !DlValidator.invalid?(Helper::VALID_DRIVERS_LICENSES['FL'].first, state)
+      end
+
+      should 'handle a full state name with non-word characters' do
+        state = '12_3 F (** )L o # R ^ I !!!! DA @   907' # FLORIDA
+        assert !DlValidator.invalid?(Helper::VALID_DRIVERS_LICENSES['FL'].first, state)
+      end
+
+      should 'handle a state license with non-word characters' do
+        license = 'F / @!!()_-=123  45%$#67  898?.,;76' # F123456789876
+        assert !DlValidator.invalid?(license, 'FL')
+      end
+
+      should 'return true for a nil drivers_license_number' do
+        assert DlValidator.invalid?(drivers_license_number=nil, 'FL')
+      end
+
+      should 'return true for a nil drivers_license_state' do
+        assert DlValidator.invalid?('123456', drivers_license_state=nil)
+      end
+    end
+
+    context '#get_abbreviation_key' do
+      DlValidator::Config::STATES.each do |state_abbreviation, state_name|
+        should "return the correct state abbreviation #{state_abbreviation}" do
+          assert_equal state_abbreviation, DlValidator.get_abbreviation_key(state_name)
+        end
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,59 @@
+require 'test/unit'
+require 'dl_validator'
+require 'shoulda'
+
+class Helper
+
+  VALID_DRIVERS_LICENSES = {
+      'AL' =>	['1234567'],                                                         # Format: 7 numeric
+      'AK' => ['1234567'],                                                         # Format: 7 numeric
+      'AZ' => ['A12345678'],                                                       # Format: 1 Alpha 8 numeric
+      'AR' => ['12345678'],                                                        # Format: 8 Numeric
+      'CA' => ['c1234567'],                                                        # Format: 1 Alpha 7 Numeric
+      'CO' => ['123456789'],                                                       # Format: 9 Numeric
+      'CT' => ['201234567', '241234567'],                                          # Format: 9 Numeric; The first 2 digits can not be less than 01 or greater than 24.
+      'DE' => ['1234567'],                                                         # Format: 7 Numeric
+      'DC' => ['1234567'],                                                         # Format: 7 Numeric
+      'FL' => ['F123456789876'],                                                   # Format: 1 Alpha 12 Numeric
+      'GA' => ['1234567', '1234567', '123456789'],                                 # Format: 7-9 Numeric
+      'HI' => ['h12345678'],                                                       # Format: H followed by 8 numeric
+      'ID' => ['LS123456C'],                                                       # Format: 2 Alpha 6 Numeric 1 Alpha (example LS123456C)
+      'IL' => ['J12345678901'],                                                    # Format: 1 alpha 11 numeric
+      'IN' => ['1234567890'],                                                      # Format: 10 Numeric
+      'IA' => ['123SL4567'],                                                       # Format: 3 Numeric 2 Alpha 4 Numeric (example 123SL4567)
+      'KS' => ['K12345678'],                                                       # Format: 1 Alpha 8 Numeric
+      'KY' => ['Y12345678'],                                                       # Format: 1 Alpha 8 Numeric
+      'LA' => ['001234567', '012345678'],                                          # Format: 9 Numeric (First two numbers are 00 or 01)
+      'ME' => ['1234567'],                                                         # Format: 7 Numeric
+      'MD' => ['M123456789012'],                                                   # Format: 1 Alpha 12 Numeric
+      'MA' => ['A12345678'],                                                       # Format: 1 Alpha 8 Numeric
+      'MI' => ['h123456789012'],                                                   # Format: 1 Alpha 12 Numeric
+      'MN' => ['L123456789012'],                                                   # Format: 1 Alpha 12 Numeric
+      'MS' => ['123456789'],                                                       # Format: 9 Numeric
+      'MO' => ['M12345678', 'M12345678' , 'M12345679'],                            # Format: 1 Alpha 5-9 Numeric
+      'MT' => ['J9G4n6E8a'],                                                       # Format: 9 Alpha And Numeric Combination
+      'NE' => ['A123', 'A1234', 'A12345', 'A123456', 'A1234567', 'A12345678'],     # Format: 1 Alpha 3-8 Numeric
+      'NV' => ['1234567890', '123456789123', 'X12345678'],                         # Format: 10 Numeric; or 12 Numeric; or X Followed By 8 Numeric
+      'NH' => ['12ADF12345'],                                                      # Format: 2 Numeric 3 Alpha 5 Numeric
+      'NJ' => ['F12345678901234'],                                                 # Format: 1 Alpha 14 Numeric
+      'NY' => ['123456789'],                                                       # Format: 9 Numeric
+      'NM' => ['123456789'],                                                       # Format: 9 Numeric
+      'NC' => ['123456', '1234567', '12345678', '123456789'],                      # Format: 6-9 Numeric
+      'ND' => ['123456789'],                                                       # Format: 9 Numeric
+      'OH' => ['LK123456'],                                                        # Format: 2 Alpha 6 Numeric
+      'OK' => ['123456789'],                                                       # Format: 9 Numeric
+      'OR' => ['12345', '123456', '1234567'],                                      # Format: 5-7 Numeric
+      'PA' => ['12345678'],                                                        # Format: 8 Numeric
+      'RI' => ['1234567'],                                                         # Format: 7 Numeric
+      'SC' => ['123456789'],                                                       # Format: 9 Numeric
+      'SD' => ['12345678'],                                                        # Format: 8 Numeric
+      'TN' => ['1234567', '12345678', '123456789'],                                # Format: 7,8 or 9 Numeric
+      'TX' => ['12345678'],                                                        # Format: 8 Numeric
+      'UT' => ['123456', '1234567', '12345678', '123456789', '1234567890'],        # Format: 6-10 Numeric
+      'VT' => ['12345678', '1234567K'],                                            # Format: 8 Numeric; or 7 Numeric 1 Alpha
+      'VA' => ['K12345678'],                                                       # Format: 1 Alpha 8 Numeric
+      'WA' => ['123ghk456QWE'],                                                    # Format: 12 Characters
+      'WV' => ['1234567', 'E123456'],                                              # Format: 7 Numeric; or 1 Alpha 6 Numeric
+      'WI' => ['W1234567890123'],                                                  # Format: 1 Alpha 13 Numeric
+      'WY' => ['123456789', '1234567890'] }                                        # Format: 9-10 Numeric
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: dl_validator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrew Medeiros
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-08 00:00:00.000000000 Z
+dependencies:
+- !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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  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: DlValidator is a small gem that performs soft checks against a drivers
+  license number and state. This is used only to flag a drivers license as being invalid,
+  and is not intended to be considered true denial on a drivers license number.
+email:
+- amedeiros0920@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- dl_validator.gemspec
+- lib/config/config.rb
+- lib/dl_validator.rb
+- lib/dl_validator/version.rb
+- lib/extensions/drivers_license_invalid_validator.rb
+- test/test_dl_validator.rb
+- test/test_helper.rb
+homepage: ''
+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.0.3
+signing_key: 
+specification_version: 4
+summary: DlValidator is a small gem that performs soft checks against a drivers license
+  number and state. This is used only to flag a drivers license as being invalid,
+  and is not intended to be considered true denial on a drivers license number.
+test_files:
+- test/test_dl_validator.rb
+- test/test_helper.rb