validates_formatting_of 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 252aa1819d51863c3f14259517c47693e15cc0e9
-  data.tar.gz: 1b77589cba97bc4bd7b5f1620254f005d3199b68
+  metadata.gz: b287c47de58a743ad0e3bbcd926418f177d8a612
+  data.tar.gz: edab15de4ab01ee66ca38c98a18e22f87a0a4ca3
 SHA512:
-  metadata.gz: 78f53eaef519be439ad5cec07dc7b508a093edc0de77f7df0bc87f52b5b0a4d3996c260208900fb597c11e8830ffb319fece4e6f051e4ce15d3a97a9737ced5d
-  data.tar.gz: 0cfbe50ae8897a4126f7fe37748d7267db315aeb02142c2a569fe725df136f4edcef3c0496074c6707313931a623b2b52fbe2ac18fe7bd3d5d545a088b928ca4
+  metadata.gz: ae394a30bb518a12b6f3ac1e3a72ef0cd5638d85cdd0e569b18c7f77e0c533235df5bb6766921be4d30de34b6b1390247548aaf065ef0fb0ea1bc005b6b024c0
+  data.tar.gz: 716d98e86d5a2782f180a571ef4a772f015d07cebbed209854edf7f7b8c2f9cbd61b9c7d579861252ff8a9ea2c82687b0e07c08c7d78918c39ef15b3d61b5a45

data/.gitignore

@@ -15,3 +15,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.ruby-version
+.overcommit.yml

data/.travis.yml

@@ -2,5 +2,6 @@ script: bundle exec rspec spec
 rvm:
   - 1.9.3
   - 2.0.0
-  - rbx-19mode
+  - 2.1.0
+  - 2.2.2
   - jruby-19mode

data/Gemfile

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

data/README.markdown

@@ -6,12 +6,12 @@
 
 The `validates_formatting_of` gem adds several convenient methods to validate things such as emails, urls, and phone numbers in a Rails application.
 
-# Unsupported versions
+# Supported Ruby Versions
 
-Please note that this gem takes advantage of regular expression features which are newer features in Ruby. Because of this, certain versions are not supported:
-
-* 1.8.7
-* Ruby Enterprise Edition (REE)
+* 1.9.3
+* 2.0.0
+* 2.1.0
+* 2.2.0
 
 # Installation
 
@@ -61,7 +61,7 @@ Say, for example, you have identical plain-old regex validations for different c
 While very unrealistic, these examples should serve their purpose in demonstrating this ability.
 
 ```ruby
-# config/initializers/validates_foramatting_of.rb
+# config/initializers/validates_formatting_of.rb
 ValidatesFormattingOf::Method.add :loweralpha, /[a-z]/, "must be lowercase and no spaces"
 ValidatesFormattingOf::Method.add :upperalpha, /[A-Z]/, "must be uppercase and no spaces"
 ValidatesFormattingOf::Method.add :weak_password, /[a-zA-Z0-9]{8,}/, "must contain only letters and numbers and be at least 8 characters long".
@@ -71,20 +71,23 @@ Keep in mind, since this gem is only ActiveModel-dependent, you should be able t
 
 # Built-in Validations
 
-`validates_formatting_of` has the following build-in validations:
-
-### Email
+`validates_formatting_of` has the following built-in validations:
 
 ```ruby
-# non ActiveRecord::Base example. This is the least you need to get validations running.
-class User
-
-  include ActiveModel::Validations
-  extend ValidatesFormattingOf::ModelAdditions
-
-  attr_accessor :email
+class ExampleModel < ActiveRecord::Base
+  validates_formatting_of :email, :using => :email      # Email
+  validates_formatting_of :first_name, :using => :alpha # Letters
+  validates_formatting_of :website, :using => :url      # URLs
+  validates_formatting_of :text, :using => :alphanum    # Alpha-numeric
+  validates_formatting_of :zipcode, :using => :us_zip   # US Zip Code
+  validates_formatting_of :phone, :using => :us_phone   # US Phone Numbers
+  validates_formatting_of :ip, :using => :ip_address_v4 # IPv4
+  validates_formatting_of :ssn, :using => :ssn          # Social Security Numbers
+  validates_formatting_of :color, :using => :hex_color  # Hexadecimal Colors
+  validates_formatting_of :amount, :using => :dollars   # Dollars
 
-  validates_formatting_of :email, :using => :email
+  # Credit Card (Visa, Mastercard, Discover, and American Express)
+  validates_formatting_of :cc, :using => :credit_card
 end
 ```
 
@@ -96,83 +99,18 @@ class User < ActiveRecord::Base
 end
 ```
 
-### URL
-
-```ruby
-class Sites < ActiveRecord::Base
-  validates_formatting_of :website, :using => :url
-end
-```
-
-### Alpha
-
-```ruby
-class Name < ActiveRecord::Base
-  validates_formatting_of :first_name, :using => :alpha
-end
-```
-
-### Alphanumeric
-
-```ruby
-class Sites < ActiveRecord::Base
-  validates_formatting_of :text, :using => :alphanum
-end
-```
-
-### Credit Card (Visa, Mastercard, Discover, and American Express)
-
-```ruby
-class Purchases < ActiveRecord::Base
-  validates_formatting_of :cc, :using => :credit_card
-end
-```
+### Plain Old Ruby Objects
 
-### US Zipcodes
+If you are not using ActiveRecord or want to use it on some other type of object, this is the least you need to get validations running.
 
 ```ruby
-class Location < ActiveRecord::Base
-  validates_formatting_of :zipcode, :using => :us_zip
-end
-```
-
-### US Phone numbers
-
-```ruby
-class Phones < ActiveRecord::Base
-  validates_formatting_of :phone, :using => :us_phone
-end
-```
-
-### IPv4
-
-```ruby
-class Location < ActiveRecord::Base
-  validates_formatting_of :ip, :using => :ip_address_v4
-end
-```
-
-### Social Security Number
-
-```ruby
-class User < ActiveRecord::Base
-  validates_formatting_of :ssn, :using => :ssn
-end
-```
-
-### Hex Colors
-
-```ruby
-class Color < ActiveRecord::Base
-  validates_formatting_of :color, :using => :hex_color
-end
-```
+class User
+  include ActiveModel::Validations
+  extend ValidatesFormattingOf::ModelAdditions
 
-### Dollar Amount
+  attr_accessor :email
 
-```ruby
-class Invoice < ActiveRecord::Base
-  validates_formatting_of :amount, :using => :dollars
+  validates_formatting_of :email, :using => :email
 end
 ```
 

data/lib/validates_formatting_of/method.rb

@@ -18,7 +18,7 @@ module ValidatesFormattingOf
     # (slightly revised to work on MRI 1.8.7 and ree)
     add :url, %r{\Ahttps?:\/\/([^\s:@]+:[^\s:@]*@)?[A-Za-z\d\-]+(\.[A-Za-z\d\-]+)+\.?(:\d{1,5})?([\/?]\S*)?\z}i, "is not a valid URL"
 
-    # No numbers of symbols. allows "-"
+    # No numbers or symbols. allows "-"
     add :alpha, %r{\A([^\d\W]|[-])*\Z}, "must be only letters or dashes"
 
     # Letters, numbers, and spaces

data/lib/validates_formatting_of/version.rb

@@ -1,3 +1,3 @@
 module ValidatesFormattingOf
-  VERSION = "0.8.1"
+  VERSION = "0.9.0"
 end

data/spec/spec_helper.rb

@@ -6,6 +6,10 @@ if ENV["RUN_SIMPLECOV"] == 'true'
   end
 end
 
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+end
+
 require 'validates_formatting_of'
 require 'active_model'
 

data/spec/validates_formatting_of/model_additions_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ValidatesFormattingOf::ModelAdditions do
+RSpec.describe ValidatesFormattingOf::ModelAdditions do
 
   describe "email" do
     class Email < TestActiveRecord
@@ -8,17 +8,17 @@ describe ValidatesFormattingOf::ModelAdditions do
       validates_formatting_of :email
     end
     it "validates that the email provided is valid" do
-      Email.new(:email => "example@example.com").should be_valid
-      Email.new(:email => "badexample.com").should_not be_valid
-      Email.new(:email => "mbridges.91@gmail.com").should be_valid
-      Email.new(:email => "some-random%%%strangely-formatted-email@lots.of.subdomains.com").should be_valid
-      Email.new(:email => "this__???{}|__should@be-valid.com").should be_valid
-      Email.new(:email => "visitorservices@vmfa.museum").should be_valid
-      Email.new(:email => "info@samoa.travel").should be_valid
-      Email.new(:email => "info@-samoa.travel").should_not be_valid
-      Email.new(:email => "info@samoa-.travel").should_not be_valid
-      Email.new(:email => "info@123-samoa.travel").should be_valid
-      Email.new(:email => "info@123-samoa.travel\n").should_not be_valid
+      expect(Email.new(:email => "example@example.com")).to be_valid
+      expect(Email.new(:email => "badexample.com")).not_to be_valid
+      expect(Email.new(:email => "mbridges.91@gmail.com")).to be_valid
+      expect(Email.new(:email => "some-random%%%strangely-formatted-email@lots.of.subdomains.com")).to be_valid
+      expect(Email.new(:email => "this__???{}|__should@be-valid.com")).to be_valid
+      expect(Email.new(:email => "visitorservices@vmfa.museum")).to be_valid
+      expect(Email.new(:email => "info@samoa.travel")).to be_valid
+      expect(Email.new(:email => "info@-samoa.travel")).not_to be_valid
+      expect(Email.new(:email => "info@samoa-.travel")).not_to be_valid
+      expect(Email.new(:email => "info@123-samoa.travel")).to be_valid
+      expect(Email.new(:email => "info@123-samoa.travel\n")).not_to be_valid
     end
   end
 
@@ -28,17 +28,17 @@ describe ValidatesFormattingOf::ModelAdditions do
       validates_formatting_of :email, :using => :simple_email
     end
     it "validates that the email provided is valid" do
-      SimpleEmail.new(:email => "example@example.com").should be_valid
-      SimpleEmail.new(:email => "badexample.com").should_not be_valid
-      SimpleEmail.new(:email => "mbridges.91@gmail.com").should be_valid
-      SimpleEmail.new(:email => "some-random%%%strangely-formatted-email@lots.of.subdomains.com").should be_valid
-      SimpleEmail.new(:email => "this__???{}|__should@be-valid.com").should be_valid
-      SimpleEmail.new(:email => "visitorservices@vmfa.museum").should be_valid
-      SimpleEmail.new(:email => "info@samoa.travel").should be_valid
-      SimpleEmail.new(:email => "info@-samoa.travel").should be_valid
-      SimpleEmail.new(:email => "info@samoa-.travel").should be_valid
-      SimpleEmail.new(:email => "info@123-samoa.travel").should be_valid
-      SimpleEmail.new(:email => "info@123-samoa.travel\n").should_not be_valid
+      expect(SimpleEmail.new(:email => "example@example.com")).to be_valid
+      expect(SimpleEmail.new(:email => "badexample.com")).not_to be_valid
+      expect(SimpleEmail.new(:email => "mbridges.91@gmail.com")).to be_valid
+      expect(SimpleEmail.new(:email => "some-random%%%strangely-formatted-email@lots.of.subdomains.com")).to be_valid
+      expect(SimpleEmail.new(:email => "this__???{}|__should@be-valid.com")).to be_valid
+      expect(SimpleEmail.new(:email => "visitorservices@vmfa.museum")).to be_valid
+      expect(SimpleEmail.new(:email => "info@samoa.travel")).to be_valid
+      expect(SimpleEmail.new(:email => "info@-samoa.travel")).to be_valid
+      expect(SimpleEmail.new(:email => "info@samoa-.travel")).to be_valid
+      expect(SimpleEmail.new(:email => "info@123-samoa.travel")).to be_valid
+      expect(SimpleEmail.new(:email => "info@123-samoa.travel\n")).not_to be_valid
     end
   end
   describe "url" do
@@ -47,12 +47,12 @@ describe ValidatesFormattingOf::ModelAdditions do
       validates_formatting_of :url
     end
     it "validates that the url provided is valid" do
-      Webpage.new(:url => 'http://something.com').should be_valid
-      Webpage.new(:url => 'http://something-else.com').should be_valid
-      Webpage.new(:url => 'http://sub.domains.something-else.com').should be_valid
-      Webpage.new(:url => 'http://username:password@something-else.com').should be_valid
-      Webpage.new(:url => "http://username:password@something-else.com\n").should_not be_valid
-      Webpage.new(:url => "something else").should_not be_valid
+      expect(Webpage.new(:url => 'http://something.com')).to be_valid
+      expect(Webpage.new(:url => 'http://something-else.com')).to be_valid
+      expect(Webpage.new(:url => 'http://sub.domains.something-else.com')).to be_valid
+      expect(Webpage.new(:url => 'http://username:password@something-else.com')).to be_valid
+      expect(Webpage.new(:url => "http://username:password@something-else.com\n")).not_to be_valid
+      expect(Webpage.new(:url => "something else")).not_to be_valid
     end
   end
 
@@ -62,12 +62,12 @@ describe ValidatesFormattingOf::ModelAdditions do
       validates_formatting_of :zipcode, :using => :us_zip
     end
     it "validates that the zipcode provided is valid" do
-      USZip.new(:zipcode => '92348').should be_valid
-      USZip.new(:zipcode => '23434-2348').should be_valid
-      USZip.new(:zipcode => "23434-2348\n").should_not be_valid
-      USZip.new(:zipcode => '234').should_not be_valid
-      USZip.new(:zipcode => '23408234').should_not be_valid
-      USZip.new(:zipcode => 'invalid').should_not be_valid
+      expect(USZip.new(:zipcode => '92348')).to be_valid
+      expect(USZip.new(:zipcode => '23434-2348')).to be_valid
+      expect(USZip.new(:zipcode => "23434-2348\n")).not_to be_valid
+      expect(USZip.new(:zipcode => '234')).not_to be_valid
+      expect(USZip.new(:zipcode => '23408234')).not_to be_valid
+      expect(USZip.new(:zipcode => 'invalid')).not_to be_valid
     end
   end
 
@@ -77,10 +77,10 @@ describe ValidatesFormattingOf::ModelAdditions do
       validates_formatting_of :alpha
     end
     it "validates that the letters provided is valid" do
-      Alpha.new(:alpha => 'abscdsofjsdpfahdsofkajlsdfaspdhjfads').should be_valid
-      Alpha.new(:alpha => 'asdfalskdfjhas-dlfhasdksdfaldhfadsfasdfa').should be_valid
-      Alpha.new(:alpha => 'adsufasodfksadjfskjdfha98').should_not be_valid
-      Alpha.new(:alpha => 'asdf ausdpf98hasdfo alsdf ja8 sd').should_not be_valid
+      expect(Alpha.new(:alpha => 'abscdsofjsdpfahdsofkajlsdfaspdhjfads')).to be_valid
+      expect(Alpha.new(:alpha => 'asdfalskdfjhas-dlfhasdksdfaldhfadsfasdfa')).to be_valid
+      expect(Alpha.new(:alpha => 'adsufasodfksadjfskjdfha98')).not_to be_valid
+      expect(Alpha.new(:alpha => 'asdf ausdpf98hasdfo alsdf ja8 sd')).not_to be_valid
     end
   end
 
@@ -90,10 +90,10 @@ describe ValidatesFormattingOf::ModelAdditions do
       validates_formatting_of :letters_and_numbers, :using => :alphanum
     end
     it "validates that the letters provided is valid" do
-      Alphanum.new(:letters_and_numbers => 'numbersandlettersarevalid1234567890').should be_valid
-      Alphanum.new(:letters_and_numbers => 'justletters').should be_valid
-      Alphanum.new(:letters_and_numbers => 'letters and numbers 123 with spaces').should be_valid
-      Alphanum.new(:letters_and_numbers => 'adding ; some special ** chars').should_not be_valid
+      expect(Alphanum.new(:letters_and_numbers => 'numbersandlettersarevalid1234567890')).to be_valid
+      expect(Alphanum.new(:letters_and_numbers => 'justletters')).to be_valid
+      expect(Alphanum.new(:letters_and_numbers => 'letters and numbers 123 with spaces')).to be_valid
+      expect(Alphanum.new(:letters_and_numbers => 'adding ; some special ** chars')).not_to be_valid
     end
   end
 
@@ -103,14 +103,14 @@ describe ValidatesFormattingOf::ModelAdditions do
       validates_formatting_of :phone_number, :using => :us_phone
     end
     it "validates that the phone number provided is valid" do
-      USPhone.new(:phone_number => '(234) 234-3456').should be_valid
-      USPhone.new(:phone_number => '123 123 3456').should be_valid
-      USPhone.new(:phone_number => '1231233456').should be_valid
-      USPhone.new(:phone_number => '123.123.3456').should be_valid
-      USPhone.new(:phone_number => '(223)123-2347').should be_valid
-      USPhone.new(:phone_number => "(223)123-2347\n").should_not be_valid
-      USPhone.new(:phone_number => '(223 123-2347').should_not be_valid
-      USPhone.new(:phone_number => '12349870238').should_not be_valid
+      expect(USPhone.new(:phone_number => '(234) 234-3456')).to be_valid
+      expect(USPhone.new(:phone_number => '123 123 3456')).to be_valid
+      expect(USPhone.new(:phone_number => '1231233456')).to be_valid
+      expect(USPhone.new(:phone_number => '123.123.3456')).to be_valid
+      expect(USPhone.new(:phone_number => '(223)123-2347')).to be_valid
+      expect(USPhone.new(:phone_number => "(223)123-2347\n")).not_to be_valid
+      expect(USPhone.new(:phone_number => '(223 123-2347')).not_to be_valid
+      expect(USPhone.new(:phone_number => '12349870238')).not_to be_valid
     end
   end
 
@@ -120,13 +120,13 @@ describe ValidatesFormattingOf::ModelAdditions do
       validates_formatting_of :ipv4, :using => :ip_address_v4
     end
     it "validates that the IP address provided is valid" do
-      IPAddress.new(:ipv4 => '10.10.10').should_not be_valid
-      IPAddress.new(:ipv4 => '999.10.10.20').should_not be_valid
-      IPAddress.new(:ipv4 => '2222.22.22.22').should_not be_valid
-      IPAddress.new(:ipv4 => '22.2222.22.2').should_not be_valid
-      IPAddress.new(:ipv4 => '127.0.0.1').should be_valid
-      IPAddress.new(:ipv4 => '132.254.111.10').should be_valid
-      IPAddress.new(:ipv4 => "132.254.111.10\n").should_not be_valid
+      expect(IPAddress.new(:ipv4 => '10.10.10')).not_to be_valid
+      expect(IPAddress.new(:ipv4 => '999.10.10.20')).not_to be_valid
+      expect(IPAddress.new(:ipv4 => '2222.22.22.22')).not_to be_valid
+      expect(IPAddress.new(:ipv4 => '22.2222.22.2')).not_to be_valid
+      expect(IPAddress.new(:ipv4 => '127.0.0.1')).to be_valid
+      expect(IPAddress.new(:ipv4 => '132.254.111.10')).to be_valid
+      expect(IPAddress.new(:ipv4 => "132.254.111.10\n")).not_to be_valid
     end
   end
 
@@ -138,11 +138,11 @@ describe ValidatesFormattingOf::ModelAdditions do
       validates_formatting_of :cc, :using => :credit_card
     end
     it "validates that the credit card number provided is valid" do
-      Client.new(:cc => '4264-2879-1230-0000').should be_valid # Visa style
-      Client.new(:cc => '6011-1111-0000-2391').should be_valid # Discover style
-      Client.new(:cc => '5422434400828888').should be_valid # Mastercard style
-      Client.new(:cc => "5422434400828889\n").should_not be_valid # Mastercard style
-      Client.new(:cc => '1233444444444444').should_not be_valid # fake
+      expect(Client.new(:cc => '4264-2879-1230-0000')).to be_valid # Visa style
+      expect(Client.new(:cc => '6011-1111-0000-2391')).to be_valid # Discover style
+      expect(Client.new(:cc => '5422434400828888')).to be_valid # Mastercard style
+      expect(Client.new(:cc => "5422434400828889\n")).not_to be_valid # Mastercard style
+      expect(Client.new(:cc => '1233444444444444')).not_to be_valid # fake
     end
   end
 
@@ -152,13 +152,13 @@ describe ValidatesFormattingOf::ModelAdditions do
       validates_formatting_of :ssn
     end
     it "validates that the social security number provided is valid" do
-      AnotherPerson.new(:ssn => "145.47.0191").should be_valid
-      AnotherPerson.new(:ssn => "223-43-2343").should be_valid
-      AnotherPerson.new(:ssn => "999.55.8888").should be_valid
-      AnotherPerson.new(:ssn => "999.55.8888\n").should_not be_valid
-      AnotherPerson.new(:ssn => "28934").should_not be_valid
-      AnotherPerson.new(:ssn => "228934828934934").should_not be_valid
-      AnotherPerson.new(:ssn => "23498.7234").should_not be_valid
+      expect(AnotherPerson.new(:ssn => "145.47.0191")).to be_valid
+      expect(AnotherPerson.new(:ssn => "223-43-2343")).to be_valid
+      expect(AnotherPerson.new(:ssn => "999.55.8888")).to be_valid
+      expect(AnotherPerson.new(:ssn => "999.55.8888\n")).not_to be_valid
+      expect(AnotherPerson.new(:ssn => "28934")).not_to be_valid
+      expect(AnotherPerson.new(:ssn => "228934828934934")).not_to be_valid
+      expect(AnotherPerson.new(:ssn => "23498.7234")).not_to be_valid
     end
   end
 
@@ -168,16 +168,16 @@ describe ValidatesFormattingOf::ModelAdditions do
       validates_formatting_of :color, :using => :hex_color
     end
     it "validates that the hex color value provided is valid" do
-      Color.new(:color => "efefef").should be_valid
-      Color.new(:color => "98de89").should be_valid
-      Color.new(:color => "000011").should be_valid
-      Color.new(:color => "132").should be_valid
-      Color.new(:color => "eef").should be_valid
-      Color.new(:color => "eef\n").should_not be_valid
-      Color.new(:color => "efefe").should_not be_valid
-      Color.new(:color => "zsdfsd").should_not be_valid
-      Color.new(:color => "p98hul;").should_not be_valid
-      Color.new(:color => "sdfsdfsf").should_not be_valid
+      expect(Color.new(:color => "efefef")).to be_valid
+      expect(Color.new(:color => "98de89")).to be_valid
+      expect(Color.new(:color => "000011")).to be_valid
+      expect(Color.new(:color => "132")).to be_valid
+      expect(Color.new(:color => "eef")).to be_valid
+      expect(Color.new(:color => "eef\n")).not_to be_valid
+      expect(Color.new(:color => "efefe")).not_to be_valid
+      expect(Color.new(:color => "zsdfsd")).not_to be_valid
+      expect(Color.new(:color => "p98hul;")).not_to be_valid
+      expect(Color.new(:color => "sdfsdfsf")).not_to be_valid
     end
   end
 
@@ -189,9 +189,9 @@ describe ValidatesFormattingOf::ModelAdditions do
     end
     it "validates the phone formatting only on creation" do
       option = Phony.new(:phone => "(123) 234-4567")
-      option.should be_valid
+      expect(option).to be_valid
       option.phone = "123123123"
-      option.should be_valid
+      expect(option).to be_valid
     end
 
     class Iffy < TestActiveRecord
@@ -200,8 +200,8 @@ describe ValidatesFormattingOf::ModelAdditions do
       validates_formatting_of :phone, :using => :us_phone, :if => lambda { |iffy| iffy.name == "Matthew" }
     end
     it "validates the phone formatting only if a name is specified" do
-      Iffy.new(:phone => "(123 345-4567", :name => "Bill").should be_valid
-      Iffy.new(:phone => "(123 345-4567", :name => "Matthew").should_not be_valid
+      expect(Iffy.new(:phone => "(123 345-4567", :name => "Bill")).to be_valid
+      expect(Iffy.new(:phone => "(123 345-4567", :name => "Matthew")).not_to be_valid
     end
 
     class Unlessy < TestActiveRecord
@@ -210,8 +210,8 @@ describe ValidatesFormattingOf::ModelAdditions do
       validates_formatting_of :phone, :using => :us_phone, :unless => lambda { |unlessy| unlessy.name == "Matthew" }
     end
     it "validates the phone formatting only if a name is specified" do
-      Unlessy.new(:phone => "(123 345-4567", :name => "Bill").should_not be_valid
-      Unlessy.new(:phone => "(123 345-4567", :name => "Matthew").should be_valid
+      expect(Unlessy.new(:phone => "(123 345-4567", :name => "Bill")).not_to be_valid
+      expect(Unlessy.new(:phone => "(123 345-4567", :name => "Matthew")).to be_valid
     end
   end
   describe "dollars" do
@@ -220,15 +220,15 @@ describe ValidatesFormattingOf::ModelAdditions do
       validates_formatting_of :amount, :using => :dollars
     end
     it "validates that the dollars amount provided is valid" do
-      Money.new(:amount => "$100.00").should be_valid
-      Money.new(:amount => "100.00").should be_valid
-      Money.new(:amount => "12,234,343").should be_valid
-      Money.new(:amount => "$12.34").should be_valid
-      Money.new(:amount => "120,123,232.32").should be_valid
-      Money.new(:amount => "$$1111111100").should_not be_valid
-      Money.new(:amount => "100;00").should_not be_valid
-      Money.new(:amount => "238,3423,42..99").should_not be_valid
-      Money.new(:amount => "$-233").should_not be_valid
+      expect(Money.new(:amount => "$100.00")).to be_valid
+      expect(Money.new(:amount => "100.00")).to be_valid
+      expect(Money.new(:amount => "12,234,343")).to be_valid
+      expect(Money.new(:amount => "$12.34")).to be_valid
+      expect(Money.new(:amount => "120,123,232.32")).to be_valid
+      expect(Money.new(:amount => "$$1111111100")).not_to be_valid
+      expect(Money.new(:amount => "100;00")).not_to be_valid
+      expect(Money.new(:amount => "238,3423,42..99")).not_to be_valid
+      expect(Money.new(:amount => "$-233")).not_to be_valid
     end
   end
   describe "custom messages" do
@@ -238,9 +238,9 @@ describe ValidatesFormattingOf::ModelAdditions do
     end
     it "are allowed and can be used in displaying error messages" do
       message = Message.new(:first_name => "invalid-first-name-123")
-      message.should_not be_valid
-      message.errors.keys.class.should eq Array
-      message.errors.full_messages.first.should =~ /is not a valid first name/
+      expect(message).not_to be_valid
+      expect(message.errors.keys.class).to eq Array
+      expect(message.errors.full_messages.first).to match(/is not a valid first name/)
     end
   end
 
@@ -251,11 +251,11 @@ describe ValidatesFormattingOf::ModelAdditions do
     end
     it "set a default error" do
       problems = Problems.new(:name => "sdfs12312dfsd")
-      problems.should_not be_valid
-      problems.errors.full_messages.first.should =~ /letters/i
+      expect(problems).not_to be_valid
+      expect(problems.errors.full_messages.first).to match(/letters/i)
       email = Email.new(:email => "not.an.email.address")
-      email.should_not be_valid
-      email.errors.full_messages.first.should =~ /email/i
+      expect(email).not_to be_valid
+      expect(email.errors.full_messages.first).to match(/email/i)
     end
   end
 
@@ -269,13 +269,13 @@ describe ValidatesFormattingOf::ModelAdditions do
     let(:people) { PeopleTest.new(:email => "mbridges.91@gmail.com", :email2 => "mbridges.91@gmail.com", :email3 => "mbridges.91@gmail.com") }
     it "should test nil and blank values correctly" do
       people.email = nil
-      people.should be_valid
+      expect(people).to be_valid
       people.email = "mbridges.91@gmail.com"
       people.email2 = ""
-      people.should be_valid
+      expect(people).to be_valid
       people.email2 = "mbridges.91@gmail.com"
       people.email3 = nil
-      people.should_not be_valid
+      expect(people).not_to be_valid
     end
   end
 

data/spec/validates_formatting_of/validation_addition_spec.rb

@@ -1,4 +1,5 @@
 require 'validates_formatting_of/validation_addition'
+require 'its'
 
 module ValidatesFormattingOf
 
@@ -9,43 +10,43 @@ module ValidatesFormattingOf
     end
   end
 
-  describe ValidationAddition do
+  RSpec.describe ValidationAddition do
     before do
       TestAdding.clear!
       TestAdding.add :email, /email/i
     end
     it "should be able to add new validations" do
       TestAdding.add :another, /another/i
-      TestAdding.validations.count.should == 2
-      TestAdding.validations['email'].should be_instance_of Validation
-      TestAdding.validations['another'].should be_instance_of Validation
+      expect(TestAdding.validations.count).to eq(2)
+      expect(TestAdding.validations['email']).to be_instance_of Validation
+      expect(TestAdding.validations['another']).to be_instance_of Validation
     end
     describe "find" do
       context "implicit validation method" do
         subject { TestAdding.find(:email) }
-        its(:name) { should == :email }
-        its(:regex) { should == /email/i }
+        its(:name) { is_expected.to eq(:email) }
+        its(:regex) { is_expected.to eq(/email/i) }
       end
       context "explicit validation method" do
         subject { TestAdding.find(:non_existent_validation, :using => :email) }
-        its(:name)  { should == :email   }
-        its(:regex) { should == /email/i }
+        its(:name)  { is_expected.to eq(:email)   }
+        its(:regex) { is_expected.to eq(/email/i) }
       end
     end
     it "should raise an error if the method does not exist" do
       expect { TestAdding.find(:fake) }.to raise_error MissingValidation
     end
     it "should be able to determine if the method does not exist" do
-      TestAdding.exists?(:email).should be_true
-      TestAdding.exists?(:non_existent).should be_false
+      expect(TestAdding.exists?(:email)).to be_truthy
+      expect(TestAdding.exists?(:non_existent)).to be_falsey
     end
     it "should be able to accept strings for validation names (for namespacing)" do
       TestAdding.add "namespace:phone", /namespace/i
-      TestAdding.exists?("namespace:phone").should be_true
+      expect(TestAdding.exists?("namespace:phone")).to be_truthy
     end
     it "should be able to determine if the method is missing" do
-      TestAdding.missing?(:non_existent).should be_true
-      TestAdding.missing?(:email).should be_false
+      expect(TestAdding.missing?(:non_existent)).to be_truthy
+      expect(TestAdding.missing?(:email)).to be_falsey
     end
   end
 end

data/spec/validates_formatting_of/validation_spec.rb

@@ -1,18 +1,19 @@
 require 'validates_formatting_of/validation'
+require 'its'
 
 module ValidatesFormattingOf
 
-  describe Validation do
+  RSpec.describe Validation do
     context "valid validation creation" do
       let(:validation) { Validation.new(:name, /something/i, "is an invalid value") }
       subject { validation }
-      its(:name) { should == :name }
-      its(:regex) { should == %r{something}i }
-      its(:message) { should == 'is an invalid value' }
-      its(:to_s) { should == "<Validation::name>" }
-      its(:inspect) { should =~ /Validation/ }
-      its(:inspect) { should =~ /\/something\/i/ }
-      its(:inspect) { should =~ /\:name/ }
+      its(:name) { is_expected.to eq(:name) }
+      its(:regex) { is_expected.to eq(%r{something}i) }
+      its(:message) { is_expected.to eq('is an invalid value') }
+      its(:to_s) { is_expected.to eq("<Validation::name>") }
+      its(:inspect) { is_expected.to match(/Validation/) }
+      its(:inspect) { is_expected.to match(/\/something\/i/) }
+      its(:inspect) { is_expected.to match(/\:name/) }
     end
     context "invalid validation creation" do
       it "should raise an error if the specified regex is not a Regexp objct" do

data/spec/validates_formatting_of/validator_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ValidatesFormattingOf::Validations do
+RSpec.describe ValidatesFormattingOf::Validations do
 
   describe "with 'sexy' validation style" do
     describe "email" do
@@ -10,17 +10,17 @@ describe ValidatesFormattingOf::Validations do
       end
 
       it "validates that the email provided is valid" do
-        Email.new(:email => "example@example.com").should be_valid
-        Email.new(:email => "badexample.com").should_not be_valid
-        Email.new(:email => "mbridges.91@gmail.com").should be_valid
-        Email.new(:email => "some-random%%%strangely-formatted-email@lots.of.subdomains.com").should be_valid
-        Email.new(:email => "this__???{}|__should@be-valid.com").should be_valid
-        Email.new(:email => "visitorservices@vmfa.museum").should be_valid
-        Email.new(:email => "info@samoa.travel").should be_valid
-        Email.new(:email => "info@-samoa.travel").should_not be_valid
-        Email.new(:email => "info@samoa-.travel").should_not be_valid
-        Email.new(:email => "info@123-samoa.travel").should be_valid
-        Email.new(:email => "info@123-samoa.travel\n").should_not be_valid
+        expect(Email.new(:email => "example@example.com")).to be_valid
+        expect(Email.new(:email => "badexample.com")).not_to be_valid
+        expect(Email.new(:email => "mbridges.91@gmail.com")).to be_valid
+        expect(Email.new(:email => "some-random%%%strangely-formatted-email@lots.of.subdomains.com")).to be_valid
+        expect(Email.new(:email => "this__???{}|__should@be-valid.com")).to be_valid
+        expect(Email.new(:email => "visitorservices@vmfa.museum")).to be_valid
+        expect(Email.new(:email => "info@samoa.travel")).to be_valid
+        expect(Email.new(:email => "info@-samoa.travel")).not_to be_valid
+        expect(Email.new(:email => "info@samoa-.travel")).not_to be_valid
+        expect(Email.new(:email => "info@123-samoa.travel")).to be_valid
+        expect(Email.new(:email => "info@123-samoa.travel\n")).not_to be_valid
       end
     end
 
@@ -30,17 +30,17 @@ describe ValidatesFormattingOf::Validations do
         validates :email, :simple_email => true
       end
       it "validates that the email provided is valid" do
-        SimpleEmail.new(:email => "example@example.com").should be_valid
-        SimpleEmail.new(:email => "badexample.com").should_not be_valid
-        SimpleEmail.new(:email => "mbridges.91@gmail.com").should be_valid
-        SimpleEmail.new(:email => "some-random%%%strangely-formatted-email@lots.of.subdomains.com").should be_valid
-        SimpleEmail.new(:email => "this__???{}|__should@be-valid.com").should be_valid
-        SimpleEmail.new(:email => "visitorservices@vmfa.museum").should be_valid
-        SimpleEmail.new(:email => "info@samoa.travel").should be_valid
-        SimpleEmail.new(:email => "info@-samoa.travel").should be_valid
-        SimpleEmail.new(:email => "info@samoa-.travel").should be_valid
-        SimpleEmail.new(:email => "info@123-samoa.travel").should be_valid
-        SimpleEmail.new(:email => "info@123-samoa.travel\n").should_not be_valid
+        expect(SimpleEmail.new(:email => "example@example.com")).to be_valid
+        expect(SimpleEmail.new(:email => "badexample.com")).not_to be_valid
+        expect(SimpleEmail.new(:email => "mbridges.91@gmail.com")).to be_valid
+        expect(SimpleEmail.new(:email => "some-random%%%strangely-formatted-email@lots.of.subdomains.com")).to be_valid
+        expect(SimpleEmail.new(:email => "this__???{}|__should@be-valid.com")).to be_valid
+        expect(SimpleEmail.new(:email => "visitorservices@vmfa.museum")).to be_valid
+        expect(SimpleEmail.new(:email => "info@samoa.travel")).to be_valid
+        expect(SimpleEmail.new(:email => "info@-samoa.travel")).to be_valid
+        expect(SimpleEmail.new(:email => "info@samoa-.travel")).to be_valid
+        expect(SimpleEmail.new(:email => "info@123-samoa.travel")).to be_valid
+        expect(SimpleEmail.new(:email => "info@123-samoa.travel\n")).not_to be_valid
       end
     end
     describe "url" do
@@ -49,12 +49,12 @@ describe ValidatesFormattingOf::Validations do
         validates :url, :url => true
       end
       it "validates that the url provided is valid" do
-        Webpage.new(:url => 'http://something.com').should be_valid
-        Webpage.new(:url => 'http://something-else.com').should be_valid
-        Webpage.new(:url => 'http://sub.domains.something-else.com').should be_valid
-        Webpage.new(:url => 'http://username:password@something-else.com').should be_valid
-        Webpage.new(:url => "http://username:password@something-else.com\n").should_not be_valid
-        Webpage.new(:url => "something else").should_not be_valid
+        expect(Webpage.new(:url => 'http://something.com')).to be_valid
+        expect(Webpage.new(:url => 'http://something-else.com')).to be_valid
+        expect(Webpage.new(:url => 'http://sub.domains.something-else.com')).to be_valid
+        expect(Webpage.new(:url => 'http://username:password@something-else.com')).to be_valid
+        expect(Webpage.new(:url => "http://username:password@something-else.com\n")).not_to be_valid
+        expect(Webpage.new(:url => "something else")).not_to be_valid
       end
     end
 
@@ -64,12 +64,12 @@ describe ValidatesFormattingOf::Validations do
         validates :zipcode, :us_zip => true
       end
       it "validates that the zipcode provided is valid" do
-        USZip.new(:zipcode => '92348').should be_valid
-        USZip.new(:zipcode => '23434-2348').should be_valid
-        USZip.new(:zipcode => "23434-2348\n").should_not be_valid
-        USZip.new(:zipcode => '234').should_not be_valid
-        USZip.new(:zipcode => '23408234').should_not be_valid
-        USZip.new(:zipcode => 'invalid').should_not be_valid
+        expect(USZip.new(:zipcode => '92348')).to be_valid
+        expect(USZip.new(:zipcode => '23434-2348')).to be_valid
+        expect(USZip.new(:zipcode => "23434-2348\n")).not_to be_valid
+        expect(USZip.new(:zipcode => '234')).not_to be_valid
+        expect(USZip.new(:zipcode => '23408234')).not_to be_valid
+        expect(USZip.new(:zipcode => 'invalid')).not_to be_valid
       end
     end
 
@@ -79,10 +79,10 @@ describe ValidatesFormattingOf::Validations do
         validates :alpha, :alpha => true
       end
       it "validates that the letters provided is valid" do
-        Alpha.new(:alpha => 'abscdsofjsdpfahdsofkajlsdfaspdhjfads').should be_valid
-        Alpha.new(:alpha => 'asdfalskdfjhas-dlfhasdksdfaldhfadsfasdfa').should be_valid
-        Alpha.new(:alpha => 'adsufasodfksadjfskjdfha98').should_not be_valid
-        Alpha.new(:alpha => 'asdf ausdpf98hasdfo alsdf ja8 sd').should_not be_valid
+        expect(Alpha.new(:alpha => 'abscdsofjsdpfahdsofkajlsdfaspdhjfads')).to be_valid
+        expect(Alpha.new(:alpha => 'asdfalskdfjhas-dlfhasdksdfaldhfadsfasdfa')).to be_valid
+        expect(Alpha.new(:alpha => 'adsufasodfksadjfskjdfha98')).not_to be_valid
+        expect(Alpha.new(:alpha => 'asdf ausdpf98hasdfo alsdf ja8 sd')).not_to be_valid
       end
     end
 
@@ -92,10 +92,10 @@ describe ValidatesFormattingOf::Validations do
         validates :letters_and_numbers, :alphanum => true
       end
       it "validates that the letters provided is valid" do
-        Alphanum.new(:letters_and_numbers => 'numbersandlettersarevalid1234567890').should be_valid
-        Alphanum.new(:letters_and_numbers => 'justletters').should be_valid
-        Alphanum.new(:letters_and_numbers => 'letters and numbers 123 with spaces').should be_valid
-        Alphanum.new(:letters_and_numbers => 'adding ; some special ** chars').should_not be_valid
+        expect(Alphanum.new(:letters_and_numbers => 'numbersandlettersarevalid1234567890')).to be_valid
+        expect(Alphanum.new(:letters_and_numbers => 'justletters')).to be_valid
+        expect(Alphanum.new(:letters_and_numbers => 'letters and numbers 123 with spaces')).to be_valid
+        expect(Alphanum.new(:letters_and_numbers => 'adding ; some special ** chars')).not_to be_valid
       end
     end
 
@@ -105,14 +105,14 @@ describe ValidatesFormattingOf::Validations do
         validates :phone_number, :us_phone => true
       end
       it "validates that the phone number provided is valid" do
-        USPhone.new(:phone_number => '(234) 234-3456').should be_valid
-        USPhone.new(:phone_number => '123 123 3456').should be_valid
-        USPhone.new(:phone_number => '1231233456').should be_valid
-        USPhone.new(:phone_number => '123.123.3456').should be_valid
-        USPhone.new(:phone_number => '(223)123-2347').should be_valid
-        USPhone.new(:phone_number => "(223)123-2347\n").should_not be_valid
-        USPhone.new(:phone_number => '(223 123-2347').should_not be_valid
-        USPhone.new(:phone_number => '12349870238').should_not be_valid
+        expect(USPhone.new(:phone_number => '(234) 234-3456')).to be_valid
+        expect(USPhone.new(:phone_number => '123 123 3456')).to be_valid
+        expect(USPhone.new(:phone_number => '1231233456')).to be_valid
+        expect(USPhone.new(:phone_number => '123.123.3456')).to be_valid
+        expect(USPhone.new(:phone_number => '(223)123-2347')).to be_valid
+        expect(USPhone.new(:phone_number => "(223)123-2347\n")).not_to be_valid
+        expect(USPhone.new(:phone_number => '(223 123-2347')).not_to be_valid
+        expect(USPhone.new(:phone_number => '12349870238')).not_to be_valid
       end
     end
 
@@ -122,13 +122,13 @@ describe ValidatesFormattingOf::Validations do
         validates :ipv4, :ip_address_v4 => true
       end
       it "validates that the IP address provided is valid" do
-        IPAddress.new(:ipv4 => '10.10.10').should_not be_valid
-        IPAddress.new(:ipv4 => '999.10.10.20').should_not be_valid
-        IPAddress.new(:ipv4 => '2222.22.22.22').should_not be_valid
-        IPAddress.new(:ipv4 => '22.2222.22.2').should_not be_valid
-        IPAddress.new(:ipv4 => '127.0.0.1').should be_valid
-        IPAddress.new(:ipv4 => '132.254.111.10').should be_valid
-        IPAddress.new(:ipv4 => "132.254.111.10\n").should_not be_valid
+        expect(IPAddress.new(:ipv4 => '10.10.10')).not_to be_valid
+        expect(IPAddress.new(:ipv4 => '999.10.10.20')).not_to be_valid
+        expect(IPAddress.new(:ipv4 => '2222.22.22.22')).not_to be_valid
+        expect(IPAddress.new(:ipv4 => '22.2222.22.2')).not_to be_valid
+        expect(IPAddress.new(:ipv4 => '127.0.0.1')).to be_valid
+        expect(IPAddress.new(:ipv4 => '132.254.111.10')).to be_valid
+        expect(IPAddress.new(:ipv4 => "132.254.111.10\n")).not_to be_valid
       end
     end
 
@@ -140,11 +140,11 @@ describe ValidatesFormattingOf::Validations do
         validates :cc, :credit_card => true
       end
       it "validates that the credit card number provided is valid" do
-        Client.new(:cc => '4264-2879-1230-0000').should be_valid # Visa style
-        Client.new(:cc => '6011-1111-0000-2391').should be_valid # Discover style
-        Client.new(:cc => '5422434400828888').should be_valid # Mastercard style
-        Client.new(:cc => "5422434400828889\n").should_not be_valid # Mastercard style
-        Client.new(:cc => '1233444444444444').should_not be_valid # fake
+        expect(Client.new(:cc => '4264-2879-1230-0000')).to be_valid # Visa style
+        expect(Client.new(:cc => '6011-1111-0000-2391')).to be_valid # Discover style
+        expect(Client.new(:cc => '5422434400828888')).to be_valid # Mastercard style
+        expect(Client.new(:cc => "5422434400828889\n")).not_to be_valid # Mastercard style
+        expect(Client.new(:cc => '1233444444444444')).not_to be_valid # fake
       end
     end
 
@@ -154,13 +154,13 @@ describe ValidatesFormattingOf::Validations do
         validates :ssn, :ssn => true
       end
       it "validates that the social security number provided is valid" do
-        AnotherPerson.new(:ssn => "145.47.0191").should be_valid
-        AnotherPerson.new(:ssn => "223-43-2343").should be_valid
-        AnotherPerson.new(:ssn => "999.55.8888").should be_valid
-        AnotherPerson.new(:ssn => "999.55.8888\n").should_not be_valid
-        AnotherPerson.new(:ssn => "28934").should_not be_valid
-        AnotherPerson.new(:ssn => "228934828934934").should_not be_valid
-        AnotherPerson.new(:ssn => "23498.7234").should_not be_valid
+        expect(AnotherPerson.new(:ssn => "145.47.0191")).to be_valid
+        expect(AnotherPerson.new(:ssn => "223-43-2343")).to be_valid
+        expect(AnotherPerson.new(:ssn => "999.55.8888")).to be_valid
+        expect(AnotherPerson.new(:ssn => "999.55.8888\n")).not_to be_valid
+        expect(AnotherPerson.new(:ssn => "28934")).not_to be_valid
+        expect(AnotherPerson.new(:ssn => "228934828934934")).not_to be_valid
+        expect(AnotherPerson.new(:ssn => "23498.7234")).not_to be_valid
       end
     end
 
@@ -170,16 +170,16 @@ describe ValidatesFormattingOf::Validations do
         validates :color, :hex_color => true
       end
       it "validates that the hex color value provided is valid" do
-        Color.new(:color => "efefef").should be_valid
-        Color.new(:color => "98de89").should be_valid
-        Color.new(:color => "000011").should be_valid
-        Color.new(:color => "132").should be_valid
-        Color.new(:color => "eef").should be_valid
-        Color.new(:color => "eef\n").should_not be_valid
-        Color.new(:color => "efefe").should_not be_valid
-        Color.new(:color => "zsdfsd").should_not be_valid
-        Color.new(:color => "p98hul;").should_not be_valid
-        Color.new(:color => "sdfsdfsf").should_not be_valid
+        expect(Color.new(:color => "efefef")).to be_valid
+        expect(Color.new(:color => "98de89")).to be_valid
+        expect(Color.new(:color => "000011")).to be_valid
+        expect(Color.new(:color => "132")).to be_valid
+        expect(Color.new(:color => "eef")).to be_valid
+        expect(Color.new(:color => "eef\n")).not_to be_valid
+        expect(Color.new(:color => "efefe")).not_to be_valid
+        expect(Color.new(:color => "zsdfsd")).not_to be_valid
+        expect(Color.new(:color => "p98hul;")).not_to be_valid
+        expect(Color.new(:color => "sdfsdfsf")).not_to be_valid
       end
     end
 
@@ -191,9 +191,9 @@ describe ValidatesFormattingOf::Validations do
       end
       it "validates the phone formatting only on creation" do
         option = Phony.new(:phone => "(123) 234-4567")
-        option.should be_valid
+        expect(option).to be_valid
         option.phone = "123123123"
-        option.should be_valid
+        expect(option).to be_valid
       end
 
       class Iffy < TestActiveRecord
@@ -202,8 +202,8 @@ describe ValidatesFormattingOf::Validations do
         validates :phone, :us_phone => true, :if => lambda { |iffy| iffy.name == "Matthew" }
       end
       it "validates the phone formatting only if a name is specified" do
-        Iffy.new(:phone => "(123 345-4567", :name => "Bill").should be_valid
-        Iffy.new(:phone => "(123 345-4567", :name => "Matthew").should_not be_valid
+        expect(Iffy.new(:phone => "(123 345-4567", :name => "Bill")).to be_valid
+        expect(Iffy.new(:phone => "(123 345-4567", :name => "Matthew")).not_to be_valid
       end
 
       class Unlessy < TestActiveRecord
@@ -212,8 +212,8 @@ describe ValidatesFormattingOf::Validations do
         validates :phone, :us_phone => true, :unless => lambda { |unlessy| unlessy.name == "Matthew" }
       end
       it "validates the phone formatting only if a name is specified" do
-        Unlessy.new(:phone => "(123 345-4567", :name => "Bill").should_not be_valid
-        Unlessy.new(:phone => "(123 345-4567", :name => "Matthew").should be_valid
+        expect(Unlessy.new(:phone => "(123 345-4567", :name => "Bill")).not_to be_valid
+        expect(Unlessy.new(:phone => "(123 345-4567", :name => "Matthew")).to be_valid
       end
     end
     describe "dollars" do
@@ -222,15 +222,15 @@ describe ValidatesFormattingOf::Validations do
         validates :amount, :dollars => true
       end
       it "validates that the dollars amount provided is valid" do
-        Money.new(:amount => "$100.00").should be_valid
-        Money.new(:amount => "100.00").should be_valid
-        Money.new(:amount => "12,234,343").should be_valid
-        Money.new(:amount => "$12.34").should be_valid
-        Money.new(:amount => "120,123,232.32").should be_valid
-        Money.new(:amount => "$$1111111100").should_not be_valid
-        Money.new(:amount => "100;00").should_not be_valid
-        Money.new(:amount => "238,3423,42..99").should_not be_valid
-        Money.new(:amount => "$-233").should_not be_valid
+        expect(Money.new(:amount => "$100.00")).to be_valid
+        expect(Money.new(:amount => "100.00")).to be_valid
+        expect(Money.new(:amount => "12,234,343")).to be_valid
+        expect(Money.new(:amount => "$12.34")).to be_valid
+        expect(Money.new(:amount => "120,123,232.32")).to be_valid
+        expect(Money.new(:amount => "$$1111111100")).not_to be_valid
+        expect(Money.new(:amount => "100;00")).not_to be_valid
+        expect(Money.new(:amount => "238,3423,42..99")).not_to be_valid
+        expect(Money.new(:amount => "$-233")).not_to be_valid
       end
     end
     describe "custom messages" do
@@ -240,9 +240,9 @@ describe ValidatesFormattingOf::Validations do
       end
       it "are allowed and can be used in displaying error messages" do
         message = Message.new(:first_name => "invalid-first-name-123")
-        message.should_not be_valid
-        message.errors.keys.class.should eq Array
-        message.errors.full_messages.first.should =~ /is not a valid first name/
+        expect(message).not_to be_valid
+        expect(message.errors.keys.class).to eq Array
+        expect(message.errors.full_messages.first).to match(/is not a valid first name/)
       end
     end
 
@@ -253,11 +253,11 @@ describe ValidatesFormattingOf::Validations do
       end
       it "set a default error" do
         problems = Problems.new(:name => "sdfs12312dfsd")
-        problems.should_not be_valid
-        problems.errors.full_messages.first.should =~ /letters/i
+        expect(problems).not_to be_valid
+        expect(problems.errors.full_messages.first).to match(/letters/i)
         email = Email.new(:email => "not.an.email.address")
-        email.should_not be_valid
-        email.errors.full_messages.first.should =~ /email/i
+        expect(email).not_to be_valid
+        expect(email.errors.full_messages.first).to match(/email/i)
       end
     end
 
@@ -271,13 +271,13 @@ describe ValidatesFormattingOf::Validations do
       let(:people) { PeopleTest.new(:email => "mbridges.91@gmail.com", :email2 => "mbridges.91@gmail.com", :email3 => "mbridges.91@gmail.com") }
       it "should test nil and blank values correctly" do
         people.email = nil
-        people.should be_valid
+        expect(people).to be_valid
         people.email = "mbridges.91@gmail.com"
         people.email2 = ""
-        people.should be_valid
+        expect(people).to be_valid
         people.email2 = "mbridges.91@gmail.com"
         people.email3 = nil
-        people.should_not be_valid
+        expect(people).not_to be_valid
       end
     end
   end

data/validates_formatting_of.gemspec

@@ -15,9 +15,10 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = ValidatesFormattingOf::VERSION
 
-  gem.add_dependency "activemodel", "~> 4.0"
+  gem.add_dependency "activemodel"
 
   gem.add_development_dependency "rake"
   gem.add_development_dependency "rspec"
   gem.add_development_dependency "simplecov"
+  gem.add_development_dependency "its"
 end

metadata

@@ -1,69 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: validates_formatting_of
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.9.0
 platform: ruby
 authors:
 - Matt Bridges
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-01 00:00:00.000000000 Z
+date: 2015-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   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: its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Common Rails validations wrapped in a gem.
@@ -73,9 +87,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -104,17 +118,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.1
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Adds several convenient methods to validate things such as emails, urls,
@@ -125,4 +139,3 @@ test_files:
 - spec/validates_formatting_of/validation_addition_spec.rb
 - spec/validates_formatting_of/validation_spec.rb
 - spec/validates_formatting_of/validator_spec.rb
-has_rdoc: