phony_rails 0.12.10 → 0.12.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 894a8528687a58ddd856bcf0225701de847e88db
-  data.tar.gz: c87a623b7bf8c990bfd6d1dd89d1e8a4df3349a5
+  metadata.gz: fcd21433ed37b73d7a13e4a968426fe495824be7
+  data.tar.gz: c6906d6e411bbae10ecdacbe4ba6f571f0a11dae
 SHA512:
-  metadata.gz: 128e21023c5b47ccb822d8153f0b188b8196e0fb9ec6f3e989207e64be8f2ddcf43206f9c3347a8f6b307827fad4cfd15995f4ba4b89b08575e2eb29fe055297
-  data.tar.gz: 44f28ddfb2efacae5d67e61f6a08bc9bd14a5d491b493472b801f4fdda875b887b19bb7e3f5bc9d7feb57d974fb197858e22fc0dba6339b04fa0cd14cde8d7b1
+  metadata.gz: 67e23bae153edccc3e21d6392a0d9d38394646ba3008701db2565d6c77842a0ad5156802a173b9d34eeb5a4408d5f7c220ff0c0ecb54f3516cf94f4b685ae2c9
+  data.tar.gz: bdb52a58cf910d0918f5b088178fea408fe8915affe747cbdc67e5fa3045082162c6e4df409f8b9d55fd5693b4061d166fcfb5ab375dc8ca44f9e022d45719f6

data/Gemfile.lock

@@ -8,33 +8,33 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (4.2.3)
-      activesupport (= 4.2.3)
+    activemodel (4.2.5)
+      activesupport (= 4.2.5)
       builder (~> 3.1)
-    activerecord (4.2.3)
-      activemodel (= 4.2.3)
-      activesupport (= 4.2.3)
+    activerecord (4.2.5)
+      activemodel (= 4.2.5)
+      activesupport (= 4.2.5)
       arel (~> 6.0)
-    activesupport (4.2.3)
+    activesupport (4.2.5)
       i18n (~> 0.7)
       json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
       thread_safe (~> 0.3, >= 0.3.4)
       tzinfo (~> 1.1)
     arel (6.0.3)
-    bson (3.2.1)
+    bson (3.2.6)
     builder (3.2.2)
     coderay (1.1.0)
-    connection_pool (2.2.0)
-    coveralls (0.8.2)
+    coveralls (0.8.8)
       json (~> 1.8)
       rest-client (>= 1.6.8, < 2)
       simplecov (~> 0.10.0)
       term-ansicolor (~> 1.3)
       thor (~> 0.19.1)
+      tins (~> 1.6.0)
     diff-lcs (1.2.5)
     docile (1.1.5)
-    domain_name (0.5.24)
+    domain_name (0.5.25)
       unf (>= 0.0.5, < 1.0.0)
     ffi (1.9.10)
     formatador (0.2.5)
@@ -60,55 +60,52 @@ GEM
       domain_name (~> 0.5)
     i18n (0.7.0)
     json (1.8.3)
-    listen (3.0.3)
+    listen (3.0.4)
       rb-fsevent (>= 0.9.3)
       rb-inotify (>= 0.9)
     lumberjack (1.0.9)
     method_source (0.8.2)
-    mime-types (2.6.1)
-    minitest (5.8.0)
-    mongoid (4.0.2)
+    mime-types (2.6.2)
+    minitest (5.8.2)
+    mongo (2.1.2)
+      bson (~> 3.0)
+    mongoid (5.0.1)
       activemodel (~> 4.0)
-      moped (~> 2.0.0)
+      mongo (~> 2.1)
       origin (~> 2.1)
       tzinfo (>= 0.3.37)
-    moped (2.0.7)
-      bson (~> 3.0)
-      connection_pool (~> 2.0)
-      optionable (~> 0.2.0)
     nenv (0.2.0)
-    netrc (0.10.3)
-    notiffany (0.0.7)
+    netrc (0.11.0)
+    notiffany (0.0.8)
       nenv (~> 0.1)
       shellany (~> 0.0)
-    optionable (0.2.0)
     origin (2.1.1)
-    phony (2.14.14)
-    pry (0.10.1)
+    phony (2.15.8)
+    pry (0.10.3)
       coderay (~> 1.1.0)
       method_source (~> 0.8.1)
       slop (~> 3.4)
     rake (10.4.2)
-    rb-fsevent (0.9.5)
+    rb-fsevent (0.9.6)
     rb-inotify (0.9.5)
       ffi (>= 0.5.0)
     rest-client (1.8.0)
       http-cookie (>= 1.0.2, < 2.0)
       mime-types (>= 1.16, < 3.0)
       netrc (~> 0.7)
-    rspec (3.3.0)
-      rspec-core (~> 3.3.0)
-      rspec-expectations (~> 3.3.0)
-      rspec-mocks (~> 3.3.0)
-    rspec-core (3.3.2)
-      rspec-support (~> 3.3.0)
-    rspec-expectations (3.3.1)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.0)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.3.0)
-    rspec-mocks (3.3.2)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.3.0)
-    rspec-support (3.3.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.0)
     shellany (0.0.1)
     simplecov (0.10.0)
       docile (~> 1.1.0)
@@ -116,7 +113,7 @@ GEM
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.0)
     slop (3.6.0)
-    sqlite3 (1.3.10)
+    sqlite3 (1.3.11)
     term-ansicolor (1.3.2)
       tins (~> 1.0)
     thor (0.19.1)

data/README.md

@@ -9,15 +9,21 @@ Find version information in the [CHANGELOG](CHANGELOG.md).
 
 Add this line to your application's Gemfile:
 
-    gem 'phony_rails' # Include phony_rails after mongoid (if you use mongoid, see issue #66 on github).
+```ruby
+gem 'phony_rails' # Include phony_rails after mongoid (if you use mongoid, see issue #66 on github).
+```
 
 And then execute:
 
-    $ bundle
+```
+$ bundle
+```
 
 Or install it yourself as:
 
-    $ gem install phony_rails
+```
+$ gem install phony_rails
+```
 
 ## Usage
 
@@ -27,28 +33,31 @@ Or install it yourself as:
 
 For **ActiveRecord**, in your model add:
 
-    class SomeModel < ActiveRecord::Base
-      # Normalizes the attribute itself before validation
-      phony_normalize :phone_number, :default_country_code => 'US'
+```ruby
+class SomeModel < ActiveRecord::Base
+  # Normalizes the attribute itself before validation
+  phony_normalize :phone_number, default_country_code: 'US'
 
-      # Normalizes attribute before validation and saves into other attribute
-      phony_normalize :phone_number, :as => :phone_number_normalized_version, :default_country_code => 'US'
+  # Normalizes attribute before validation and saves into other attribute
+  phony_normalize :phone_number, as: :phone_number_normalized_version, default_country_code: 'US'
 
-      # Creates method normalized_fax_number that returns the normalized version of fax_number
-      phony_normalized_method :fax_number
-    end
+  # Creates method normalized_fax_number that returns the normalized version of fax_number
+  phony_normalized_method :fax_number
+end
+```
 
 #### Mongoid
 
 For **Mongoid**, in keeping with Mongoid plug-in conventions you must include the `Mongoid::Phony` module:
 
-    class SomeModel
-      include Mongoid::Document
-      include Mongoid::Phony
-
-      # methods are same as ActiveRecord usage
-    end
+```ruby
+class SomeModel
+  include Mongoid::Document
+  include Mongoid::Phony
 
+  # methods are same as ActiveRecord usage
+end
+```
 #### General info
 
 The `:default_country_code` options is used to specify a country_code when normalizing.
@@ -57,14 +66,16 @@ PhonyRails will also check your model for a country_code method to use when norm
 
 You can also do-it-yourself and call:
 
-    # Options:
-    #   :country_code => The country code we should use (forced).
-    #   :default_country_code => Some fallback code (eg. 'NL') that can be used as default (comes from phony_normalize_numbers method).
+```ruby
+# Options:
+#   :country_code => The country code we should use (forced).
+#   :default_country_code => Some fallback code (eg. 'NL') that can be used as default (comes from phony_normalize_numbers method).
 
-    PhonyRails.normalize_number('some number', :country_code => 'NL')
+PhonyRails.normalize_number('some number', country_code: 'NL')
 
-    PhonyRails.normalize_number('+4790909090', :country_code => 'SE') # => '+464790909090' (forced to +46)
-    PhonyRails.normalize_number('+4790909090', :default_country_code => 'SE') # => '+4790909090' (still +47 so not changed)
+PhonyRails.normalize_number('+4790909090', country_code: 'SE') # => '+464790909090' (forced to +46)
+PhonyRails.normalize_number('+4790909090', default_country_code: 'SE') # => '+4790909090' (still +47 so not changed)
+```
 
 The country_code should always be a ISO 3166-1 alpha-2 (http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
 
@@ -72,11 +83,14 @@ The country_code should always be a ISO 3166-1 alpha-2 (http://en.wikipedia.org/
 
 In your model use the Phony.plausible method to validate an attribute:
 
-    validates :phone_number, :phony_plausible => true
-
+```ruby
+validates :phone_number, phony_plausible: true
+```
 or the helper method:
 
-    validates_plausible_phone :phone_number
+```ruby
+validates_plausible_phone :phone_number
+```
 
 this method use other validators under the hood to provide:
 * presence validation using `ActiveModel::Validations::PresenceValidator`
@@ -84,35 +98,45 @@ this method use other validators under the hood to provide:
 
 so we can use:
 
-    validates_plausible_phone :phone_number, :presence => true
-    validates_plausible_phone :phone_number, :with => /^\+\d+/
-    validates_plausible_phone :phone_number, :without => /^\+\d+/
-    validates_plausible_phone :phone_number, :presence => true, :with => /^\+\d+/
+```ruby
+validates_plausible_phone :phone_number, presence: true
+validates_plausible_phone :phone_number, with: /^\+\d+/
+validates_plausible_phone :phone_number, without: /^\+\d+/
+validates_plausible_phone :phone_number, presence: true, with: /^\+\d+/
+```
 
-the i18n key is `:improbable_phone`. Languages supported by default: de, en, fr, it, ja, kh and tr.
+the i18n key is `:improbable_phone`. Languages supported by default: de, en, fr, it, ja, kh, tr, ua and ru.
 
 You can also validate if a number has the correct country number:
 
-    validates_plausible_phone :phone_number, :country_number => '61'
+```ruby
+validates_plausible_phone :phone_number, country_number: '61'
+```
 
 or correct country code:
 
-    validates_plausible_phone :phone_number, :country_code => 'AU'
+```ruby
+validates_plausible_phone :phone_number, country_code: 'AU'
+```
 
 You can validate against the normalized input as opposed to the raw input:
 
-    phony_normalize :phone_number, as: :phone_number_normalized, :default_country_code => 'US'
-    validates_plausible_phone :phone_number, :normalized_country_code => 'US'
+```ruby
+phony_normalize :phone_number, as: :phone_number_normalized, default_country_code: 'US'
+validates_plausible_phone :phone_number, normalized_country_code: 'US'
+```
 
 #### Allowing records country codes to not match phone number country codes
 
 You may have a record specifying one country (via a `country_code` attribute) but using a phone number from another country.  For example, your record may be from Japan but have a phone number from the Philippines. By default, `phony_rails` will consider your record's `country_code` as part of the validation.  If that country doesn't match the country code in the phone number, validation will fail.
 
-Additionally, `phony_normalize` will always add the records country code as the country number (eg. the user enters '+81xxx' for Japan and the records `country_code` is 'DE' then `phony_normalize` will change the number to '+4981'). You can turn this off by adding `:enforce_record_country => false` to the validation options. The country_code will then only be added if no country code is specified.
+Additionally, `phony_normalize` will always add the records country code as the country number (eg. the user enters '+81xxx' for Japan and the records `country_code` is 'DE' then `phony_normalize` will change the number to '+4981'). You can turn this off by adding `enforce_record_country: false` to the validation options. The country_code will then only be added if no country code is specified.
 
 If you want to allow records from one country to have phone numbers from a different one, there are a couple of options you can use: `ignore_record_country_number` and `ignore_record_country_code`.  Use them like so:
 
-    validates :phone_number, :phony_plausible => { :ignore_record_country_code => true, :ignore_record_country_number => true }
+```ruby
+validates :phone_number, phony_plausible: { ignore_record_country_code: true, ignore_record_country_number: true }
+```
 
 Obviously, you don't have to use both, and you may not need or want to set either.
 
@@ -120,35 +144,47 @@ Obviously, you don't have to use both, and you may not need or want to set eithe
 
 In your views use:
 
-    <%= "311012341234".phony_formatted(:format => :international, :spaces => '-') %>
-    <%= "+31-10-12341234".phony_formatted(:format => :international, :spaces => '-') %>
-    <%= "+31(0)1012341234".phony_formatted(:format => :international, :spaces => '-') %>
+```erb
+<%= "311012341234".phony_formatted(format: :international, spaces: '-') %>
+<%= "+31-10-12341234".phony_formatted(format: :international, spaces: '-') %>
+<%= "+31(0)1012341234".phony_formatted(format: :international, spaces: '-') %>
+```
 
 To first normalize the String to a certain country use:
 
-    <%= "010-12341234".phony_formatted(:normalize => :NL, :format => :international, :spaces => '-') %>
+```erb
+<%= "010-12341234".phony_formatted(normalize: :NL, format: :international, spaces: '-') %>
+```
 
 To return nil when a number is not valid:
 
-    "123".phony_formatted(:strict => true) # => nil
+```ruby
+"123".phony_formatted(strict: true) # => nil
+```
 
 You can also use the bang method (phony_formatted!):
 
-    number = "010-12341234"
-    number.phony_formatted!(:normalize => :NL, :format => :international)
-    number # => "+31 10 123 41234"
+```ruby
+number = "010-12341234"
+number.phony_formatted!(normalize: :NL, format: :international)
+number # => "+31 10 123 41234"
+```
 
 You can also easily normalize a phone number String:
 
-    "+31 (0)30 1234 123".phony_normalized # => '31301234123'
-    "(0)30 1234 123".phony_normalized # => '301234123'
-    "(0)30 1234 123".phony_normalized(country_code: 'NL') # => '301234123'
+```ruby
+"+31 (0)30 1234 123".phony_normalized # => '31301234123'
+"(0)30 1234 123".phony_normalized # => '301234123'
+"(0)30 1234 123".phony_normalized(country_code: 'NL') # => '301234123'
+```
 
 ### Find by normalized number
 
 Say you want to find a record by a phone number. Best is to normalize user input and compare to an attribute stored in the db.
 
-    Home.find_by_normalized_phone_number(PhonyRails.normalize_number(params[:phone_number]))
+```ruby
+Home.find_by_normalized_phone_number(PhonyRails.normalize_number(params[:phone_number]))
+```
 
 ## Contributing
 

data/lib/phony_rails.rb

@@ -27,6 +27,7 @@ module PhonyRails
   #   http://www.redguava.com.au/2011/06/rails-convert-phone-numbers-to-international-format-for-sms/
   def self.normalize_number(number, options = {})
     return if number.nil?
+    original_number = number
     number = number.clone # Just to be sure, we don't want to change the original.
     number.gsub!(/[^\(\)\d\+]/, '') # Strips weird stuff from the number
     return if number.blank?
@@ -44,6 +45,11 @@ module PhonyRails
       if not (number =~ /\A\+/) # if we don't have a +
         if Phony.plausible?("#{_default_country_number}#{number}") || !Phony.plausible?(number) || country_code_from_number(number).nil?
           number = "#{_default_country_number}#{number}"
+        elsif (number =~ /^0[^0]/) && Phony.plausible?("#{_default_country_number}#{number.gsub(/^0/, '')}")
+          # If the number starts with ONE zero (two might indicate a country code)
+          # and this is a plausible number for the default_country
+          # we prefer that one.
+          number = "#{_default_country_number}#{number.gsub(/^0/, '')}"
         end
       end
       # number = "#{_default_country_number}#{number}" unless Phony.plausible?(number)
@@ -52,7 +58,7 @@ module PhonyRails
     options[:add_plus] = true if options[:add_plus].nil? && Phony.plausible?(normalized_number)
     options[:add_plus] ? "+#{normalized_number}" : normalized_number
   rescue
-    number # If all goes wrong .. we still return the original input.
+    original_number # If all goes wrong .. we still return the original input.
   end
 
   def self.country_code_from_number(number)

data/lib/phony_rails/locales/ru.yml

@@ -0,0 +1,4 @@
+ru:
+  errors:
+    messages:
+      improbable_phone: "является недействительным номером"

data/lib/phony_rails/locales/uk.yml

@@ -0,0 +1,4 @@
+uk:
+  errors:
+    messages:
+      improbable_phone: "є недійсним номером"

data/lib/phony_rails/string_extensions.rb

@@ -39,6 +39,7 @@
 
     # The bang method
     def phony_formatted!(options = {})
+      raise ArgumentError, "The :strict options is only supported in the phony_formatted (non bang) method." if options[:strict]
       replace(self.phony_formatted(options))
     end
 

data/lib/phony_rails/version.rb

@@ -1,3 +1,3 @@
 module PhonyRails
-  VERSION = "0.12.10"
+  VERSION = "0.12.11"
 end

data/phony_rails.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |gem|
   gem.version       = PhonyRails::VERSION
 
   gem.post_install_message = "PhonyRails v0.10.0 changes the way numbers are stored!"
-  gem.post_install_message = "It now ads a '+' to the normalized number when it starts with a country number!"
+  gem.post_install_message = "It now adds a '+' to the normalized number when it starts with a country number!"
 
   gem.add_dependency "phony", '~> 2.12'
   gem.add_dependency "activesupport", ">= 3.0"

data/spec/lib/phony_rails_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
-describe PhonyRails do
 
+describe PhonyRails do
   it "should not pollute the global namespace with a Country class" do
     should_not be_const_defined "Country"
   end
@@ -10,16 +10,16 @@ describe PhonyRails do
     describe 'the phony_formatted method' do
 
       it 'should not modify the original options Hash' do
-        options = {:normalize => :NL, :format => :international}
+        options = {normalize: :NL, format: :international}
         "0101234123".phony_formatted(options)
-        expect(options).to eql({:normalize => :NL, :format => :international})
+        expect(options).to eql({normalize: :NL, format: :international})
       end
 
       describe 'with the bang!' do
 
         it "should change the String using the bang method" do
           s = "0101234123"
-          expect(s.phony_formatted!(:normalize => :NL, :format => :international)).to eql('+31 10 123 4123')
+          expect(s.phony_formatted!(normalize: :NL, format: :international)).to eql('+31 10 123 4123')
           expect(s).to eql("+31 10 123 4123")
         end
 
@@ -30,13 +30,13 @@ describe PhonyRails do
         it "should return nil with non plausible number" do
           number = '+319090' # not valid
           expect(Phony.plausible?(number)).to be false
-          expect(number.phony_formatted(:strict => true)).to eql(nil)
+          expect(number.phony_formatted(strict: true)).to eql(nil)
         end
 
         it "should not return nil with plausible number" do
           number = '+31101234123' # valid
           expect(Phony.plausible?(number)).to be true
-          expect(number.phony_formatted(:strict => true)).to_not eql(nil)
+          expect(number.phony_formatted(strict: true)).to_not eql(nil)
         end
 
       end
@@ -44,30 +44,30 @@ describe PhonyRails do
       describe 'with normalize option' do
 
         it "should phony_format" do
-          expect("101234123".phony_formatted(:normalize => :NL)).to eql('010 123 4123')
-          expect("101234123".phony_formatted(:normalize => :NL, :format => :international)).to eql('+31 10 123 4123')
+          expect("101234123".phony_formatted(normalize: :NL)).to eql('010 123 4123')
+          expect("101234123".phony_formatted(normalize: :NL, format: :international)).to eql('+31 10 123 4123')
         end
 
         it "should not change original String" do
           s = "0101234123"
-          expect(s.phony_formatted(:normalize => :NL)).to eql('010 123 4123')
+          expect(s.phony_formatted(normalize: :NL)).to eql('010 123 4123')
           expect(s).to eql("0101234123")
         end
 
         it "should phony_format String with country code" do
-          expect("31101234123".phony_formatted(:normalize => :NL)).to eql('010 123 4123')
+          expect("31101234123".phony_formatted(normalize: :NL)).to eql('010 123 4123')
         end
 
         it "should phony_format String with country code" do
-          expect("31101234123".phony_formatted(:normalize => :NL)).to eql('010 123 4123')
+          expect("31101234123".phony_formatted(normalize: :NL)).to eql('010 123 4123')
         end
 
         it "should accept strings with non-digits in it" do
-          expect("+31-10-1234123".phony_formatted(:normalize => :NL, :format => :international, :spaces => '-')).to eql('+31-10-123-4123')
+          expect("+31-10-1234123".phony_formatted(normalize: :NL, format: :international, spaces: '-')).to eql('+31-10-123-4123')
         end
 
         it "should phony_format String with country code different than normalized value" do
-          expect("+4790909090".phony_formatted(:normalize => :SE, :format => :international)).to eql('+47 909 09 090')
+          expect("+4790909090".phony_formatted(normalize: :SE, format: :international)).to eql('+47 909 09 090')
         end
 
       end
@@ -105,14 +105,16 @@ describe PhonyRails do
         end
 
         it "should pass Github issue #85" do
-          expect(PhonyRails.normalize_number("47386160",  default_country_code: 'NO')).to eq('+4747386160')
-          expect(PhonyRails.normalize_number("47386160",  country_number: '47')).to eq('+4747386160')
+          expect(PhonyRails.normalize_number("47386160", default_country_code: 'NO')).to eq('+4747386160')
+          expect(PhonyRails.normalize_number("47386160", country_number: '47')).to eq('+4747386160')
         end
 
         it "should pass Github issue #87" do
           expect(PhonyRails.normalize_number('2318725305', country_code: 'US')).to eq('+12318725305')
           expect(PhonyRails.normalize_number('2318725305', default_country_code: 'US')).to eq('+12318725305')
           expect(PhonyRails.normalize_number('+2318725305', default_country_code: 'US')).to eq('+2318725305')
+          # expect(Phony.plausible?("#{PhonyRails.country_number_for('US')}02318725305")).to be_truthy
+          expect(PhonyRails.normalize_number('02318725305', default_country_code: 'US')).to eq('+12318725305')
         end
 
         it "should pass Github issue #89" do
@@ -126,20 +128,50 @@ describe PhonyRails do
            expect(number.phony_normalized(country_code: 'NL')).to eq('+31301234123')
         end
 
+        it "should pass Github issue #107" do
+           number = '04575700834'
+           expect(number.phony_normalized(country_code: 'FI')).to eq('+3584575700834')
+           # Seems this number can be interpreted as from multiple countries, following fails:
+           # expect(number.phony_normalized(default_country_code: 'FI')).to eq('+3584575700834')
+           # expect("04575700834".phony_formatted(normalize: 'FI', format: :international)).to eql('+358 45 757 00 834')
+        end
+
+        it "should pass Github issue #113" do
+          number = "(951) 703-593"
+          expect(lambda {
+            number.phony_formatted!(normalize: 'US', spaces: '-', strict: true)
+          }).to raise_error(ArgumentError)
+        end
+
+        it "should pass Github issue #95" do
+          number = '02031234567'
+          expect(number.phony_normalized(default_country_code: 'GB')).to eq('+442031234567')
+        end
+
+        it 'should pass Github issue #121' do
+          number = '06-87-73-83-58'
+          expect(number.phony_normalized(default_country_code: 'FR')).to eq('+33687738358')
+        end
+
+        it "returns the original input if all goes wrong" do
+          expect(Phony).to receive(:plausible?).and_raise("unexpected error")
+          number = '(0)30 1234 123'
+          expect(number.phony_normalized(country_code: 'NL')).to eq number
+        end
       end
 
       it "should not change original String" do
         s = '0101234123'
-        expect(s.phony_formatted(:normalize => :NL)).to eql('010 123 4123')
+        expect(s.phony_formatted(normalize: :NL)).to eql('010 123 4123')
         expect(s).to eql('0101234123')
       end
 
       it "should phony_format a digits string with spaces String" do
-        expect("31 10 1234123".phony_formatted(:format => :international, :spaces => '-')).to eql('+31-10-123-4123')
+        expect("31 10 1234123".phony_formatted(format: :international, spaces: '-')).to eql('+31-10-123-4123')
       end
 
       it "should phony_format a digits String" do
-        expect("31101234123".phony_formatted(:format => :international, :spaces => '-')).to eql('+31-10-123-4123')
+        expect("31101234123".phony_formatted(format: :international, spaces: '-')).to eql('+31-10-123-4123')
       end
 
       it "returns nil if implausible phone" do
@@ -159,14 +191,14 @@ describe PhonyRails do
       end
 
       it 'should not modify the original options Hash' do
-        options = {:normalize => :NL, :format => :international}
+        options = {normalize: :NL, format: :international}
         "0101234123".phony_normalized(options)
-        expect(options).to eql({:normalize => :NL, :format => :international})
+        expect(options).to eql({normalize: :NL, format: :international})
       end
 
       context "when String misses a country_code" do
         it "should normalize with :country_code option" do
-          expect("010 1231234".phony_normalized(:country_code => :NL)).to eql("+31101231234")
+          expect("010 1231234".phony_normalized(country_code: :NL)).to eql("+31101231234")
         end
 
         it "should normalize without :country_code option" do
@@ -174,13 +206,13 @@ describe PhonyRails do
         end
 
         it "should normalize with :add_plus option" do
-          expect("010 1231234".phony_normalized(:country_code => :NL, :add_plus => false)).to eql("31101231234")
+          expect("010 1231234".phony_normalized(country_code: :NL, add_plus: false)).to eql("31101231234")
         end
 
       end
 
       it "should normalize with :add_plus option" do
-        expect("+31 (0)10 1231234".phony_normalized(:add_plus => false)).to eql("31101231234")
+        expect("+31 (0)10 1231234".phony_normalized(add_plus: false)).to eql("31101231234")
       end
 
       it "should normalize a String" do
@@ -195,19 +227,19 @@ describe PhonyRails do
     context 'number with a country code' do
 
       it "should not add default_country_code" do
-        expect(PhonyRails.normalize_number('+4790909090', :default_country_code => 'SE')).to eql('+4790909090') # SE = +46
-        expect(PhonyRails.normalize_number('004790909090', :default_country_code => 'SE')).to eql('+4790909090')
-        expect(PhonyRails.normalize_number('4790909090', :default_country_code => 'NO')).to eql('+4790909090') # NO = +47
+        expect(PhonyRails.normalize_number('+4790909090', default_country_code: 'SE')).to eql('+4790909090') # SE = +46
+        expect(PhonyRails.normalize_number('004790909090', default_country_code: 'SE')).to eql('+4790909090')
+        expect(PhonyRails.normalize_number('4790909090', default_country_code: 'NO')).to eql('+4790909090') # NO = +47
       end
 
       it "should force add country_code" do
-        expect(PhonyRails.normalize_number('+4790909090', :country_code => 'SE')).to eql('+464790909090')
-        expect(PhonyRails.normalize_number('004790909090', :country_code => 'SE')).to eql('+4604790909090') # FIXME: differs due to Phony.normalize in v2.7.1?!
-        expect(PhonyRails.normalize_number('4790909090', :country_code => 'SE')).to eql('+464790909090')
+        expect(PhonyRails.normalize_number('+4790909090', country_code: 'SE')).to eql('+464790909090')
+        expect(PhonyRails.normalize_number('004790909090', country_code: 'SE')).to eql('+4604790909090') # FIXME: differs due to Phony.normalize in v2.7.1?!
+        expect(PhonyRails.normalize_number('4790909090', country_code: 'SE')).to eql('+464790909090')
       end
 
       it "should recognize lowercase country codes" do
-        expect(PhonyRails.normalize_number('4790909090', :country_code => 'se')).to eql('+464790909090')
+        expect(PhonyRails.normalize_number('4790909090', country_code: 'se')).to eql('+464790909090')
       end
 
     end
@@ -215,47 +247,47 @@ describe PhonyRails do
     context 'number without a country code' do
 
       it "should normalize with a default_country_code" do
-        expect(PhonyRails.normalize_number('010-1234123', :default_country_code => 'NL')).to eql('+31101234123')
+        expect(PhonyRails.normalize_number('010-1234123', default_country_code: 'NL')).to eql('+31101234123')
       end
 
       it "should normalize with a country_code" do
-        expect(PhonyRails.normalize_number('010-1234123', :country_code => 'NL', :default_country_code => 'DE')).to eql('+31101234123')
-        expect(PhonyRails.normalize_number('010-1234123', :country_code => 'NL')).to eql('+31101234123')
+        expect(PhonyRails.normalize_number('010-1234123', country_code: 'NL', default_country_code: 'DE')).to eql('+31101234123')
+        expect(PhonyRails.normalize_number('010-1234123', country_code: 'NL')).to eql('+31101234123')
       end
 
       it "should handle different countries" do
-        expect(PhonyRails.normalize_number('(030) 8 61 29 06', :country_code => 'DE')).to eql('+49308612906')
-        expect(PhonyRails.normalize_number('0203 330 8897', :country_code => 'GB')).to eql('+442033308897')
+        expect(PhonyRails.normalize_number('(030) 8 61 29 06', country_code: 'DE')).to eql('+49308612906')
+        expect(PhonyRails.normalize_number('0203 330 8897', country_code: 'GB')).to eql('+442033308897')
       end
 
       it "should prefer country_code over default_country_code" do
-        expect(PhonyRails.normalize_number('(030) 8 61 29 06', :country_code => 'DE', :default_country_code => 'NL')).to eql('+49308612906')
+        expect(PhonyRails.normalize_number('(030) 8 61 29 06', country_code: 'DE', default_country_code: 'NL')).to eql('+49308612906')
       end
 
       it "should recognize lowercase country codes" do
-        expect(PhonyRails.normalize_number('010-1234123', :country_code => 'nl')).to eql('+31101234123')
+        expect(PhonyRails.normalize_number('010-1234123', country_code: 'nl')).to eql('+31101234123')
       end
 
     end
 
     it "should handle some edge cases (with country_code)" do
-      expect(PhonyRails.normalize_number('some nasty stuff in this +31 number 10-1234123 string', :country_code => 'NL')).to eql('+31101234123')
-      expect(PhonyRails.normalize_number('070-4157134', :country_code => 'NL')).to eql('+31704157134')
-      expect(PhonyRails.normalize_number('0031-70-4157134', :country_code => 'NL')).to eql('+31704157134')
-      expect(PhonyRails.normalize_number('+31-70-4157134', :country_code => 'NL')).to eql('+31704157134')
-      expect(PhonyRails.normalize_number('0322-69497', :country_code => 'BE')).to eql('+3232269497')
-      expect(PhonyRails.normalize_number('+32 3 226 94 97', :country_code => 'BE')).to eql('+3232269497')
-      expect(PhonyRails.normalize_number('0450 764 000', :country_code => 'AU')).to eql('+61450764000')
+      expect(PhonyRails.normalize_number('some nasty stuff in this +31 number 10-1234123 string', country_code: 'NL')).to eql('+31101234123')
+      expect(PhonyRails.normalize_number('070-4157134', country_code: 'NL')).to eql('+31704157134')
+      expect(PhonyRails.normalize_number('0031-70-4157134', country_code: 'NL')).to eql('+31704157134')
+      expect(PhonyRails.normalize_number('+31-70-4157134', country_code: 'NL')).to eql('+31704157134')
+      expect(PhonyRails.normalize_number('0322-69497', country_code: 'BE')).to eql('+3232269497')
+      expect(PhonyRails.normalize_number('+32 3 226 94 97', country_code: 'BE')).to eql('+3232269497')
+      expect(PhonyRails.normalize_number('0450 764 000', country_code: 'AU')).to eql('+61450764000')
     end
 
     it "should handle some edge cases (with default_country_code)" do
-      expect(PhonyRails.normalize_number('some nasty stuff in this +31 number 10-1234123 string', :country_code => 'NL')).to eql('+31101234123')
-      expect(PhonyRails.normalize_number('070-4157134', :default_country_code => 'NL')).to eql('+31704157134')
-      expect(PhonyRails.normalize_number('0031-70-4157134', :default_country_code => 'NL')).to eql('+31704157134')
-      expect(PhonyRails.normalize_number('+31-70-4157134', :default_country_code => 'NL')).to eql('+31704157134')
-      expect(PhonyRails.normalize_number('0322-69497', :default_country_code => 'BE')).to eql('+3232269497')
-      expect(PhonyRails.normalize_number('+32 3 226 94 97', :default_country_code => 'BE')).to eql('+3232269497')
-      expect(PhonyRails.normalize_number('0450 764 000', :default_country_code => 'AU')).to eql('+61450764000')
+      expect(PhonyRails.normalize_number('some nasty stuff in this +31 number 10-1234123 string', country_code: 'NL')).to eql('+31101234123')
+      expect(PhonyRails.normalize_number('070-4157134', default_country_code: 'NL')).to eql('+31704157134')
+      expect(PhonyRails.normalize_number('0031-70-4157134', default_country_code: 'NL')).to eql('+31704157134')
+      expect(PhonyRails.normalize_number('+31-70-4157134', default_country_code: 'NL')).to eql('+31704157134')
+      expect(PhonyRails.normalize_number('0322-69497', default_country_code: 'BE')).to eql('+3232269497')
+      expect(PhonyRails.normalize_number('+32 3 226 94 97', default_country_code: 'BE')).to eql('+3232269497')
+      expect(PhonyRails.normalize_number('0450 764 000', default_country_code: 'AU')).to eql('+61450764000')
     end
 
     it "should normalize even an implausible number" do
@@ -263,7 +295,8 @@ describe PhonyRails do
     end
   end
 
-  describe 'PhonyRails#plausible_number?' do
+  describe 'PhonyRails.plausible_number?' do
+    subject { described_class }
     let(:valid_number) { '1 555 555 5555' }
     let(:invalid_number) { '123456789 123456789 123456789 123456789' }
     let(:normalizable_number) { '555 555 5555' }
@@ -272,35 +305,40 @@ describe PhonyRails do
     let(:nil_number) { nil }
 
     it "should return true for a valid number" do
-      expect(PhonyRails.plausible_number?(valid_number, country_code: 'US')).to be true
+      is_expected.to be_plausible_number valid_number, country_code: 'US'
     end
 
     it "should return false for an invalid number" do
-      expect(PhonyRails.plausible_number?(invalid_number, country_code: 'US')).to be false
+      is_expected.not_to be_plausible_number invalid_number, country_code: 'US'
     end
 
     it "should return true for a normalizable number" do
-      expect(PhonyRails.plausible_number?(normalizable_number, country_code: 'US')).to be true
+      is_expected.to be_plausible_number normalizable_number, country_code: 'US'
     end
 
     it "should return false for a valid number with the wrong country code" do
-      expect(PhonyRails.plausible_number?(valid_number, country_code: 'FR')).to be false
+      is_expected.not_to be_plausible_number normalizable_number, country_code: 'FR'
     end
 
     it "should return true for a well formatted valid number" do
-      expect(PhonyRails.plausible_number?(formatted_french_number_with_country_code, country_code: 'FR')).to be true
+      is_expected.to be_plausible_number formatted_french_number_with_country_code, country_code: 'FR'
     end
 
     it "should return false for an empty number" do
-      expect(PhonyRails.plausible_number?(empty_number, country_code: 'US')).to be false
+      is_expected.not_to be_plausible_number empty_number, country_code: 'US'
     end
 
     it "should return false for a nil number" do
-      expect(PhonyRails.plausible_number?(nil_number, country_code: 'US')).to be false
+      is_expected.not_to be_plausible_number nil_number, country_code: 'US'
     end
 
     it "should return false when no country code is supplied" do
-      expect(PhonyRails.plausible_number?(normalizable_number)).to be false
+      is_expected.not_to be_plausible_number normalizable_number
+    end
+
+    it "returns false if something goes wrong" do
+      expect(Phony).to receive(:plausible?).twice.and_raise("unexpected error")
+      is_expected.not_to be_plausible_number normalizable_number, country_code: 'US'
     end
   end
 
@@ -331,25 +369,25 @@ describe PhonyRails do
     describe 'defining model#phony_normalize' do
       it "should not accept :as option with multiple attribute names" do
         expect(lambda {
-          model_klass.phony_normalize(:phone_number, :phone1_method, :as => 'non_existing_attribute')
+          model_klass.phony_normalize(:phone_number, :phone1_method, as: 'non_existing_attribute')
         }).to raise_error(ArgumentError)
       end
 
       it "should accept :as option with non existing attribute name" do
         expect(lambda {
-          dummy_klass.phony_normalize(:non_existing_attribute, :as => 'non_existing_attribute')
+          dummy_klass.phony_normalize(:non_existing_attribute, as: 'non_existing_attribute')
         }).to_not raise_error
       end
 
       it "should accept :as option with single non existing attribute name" do
         expect(lambda {
-          dummy_klass.phony_normalize(:phone_number, :as => 'something_else')
+          dummy_klass.phony_normalize(:phone_number, as: 'something_else')
         }).to_not raise_error
       end
 
       it "should accept :as option with single existing attribute name" do
         expect(lambda {
-          model_klass.phony_normalize(:phone_number, :as => 'phone_number_as_normalized')
+          model_klass.phony_normalize(:phone_number, as: 'phone_number_as_normalized')
         }).to_not raise_error
       end
 
@@ -378,82 +416,82 @@ describe PhonyRails do
     describe 'using model#phony_normalized_method' do
     # Following examples have complete number (with country code!)
       it "should return a normalized version of an attribute" do
-        model = model_klass.new(:phone_attribute => "+31-(0)10-1234123")
+        model = model_klass.new(phone_attribute: "+31-(0)10-1234123")
         expect(model.normalized_phone_attribute).to eql('+31101234123')
       end
 
       it "should return a normalized version of a method" do
-        model = model_klass.new(:phone_method => "+31-(0)10-1234123")
+        model = model_klass.new(phone_method: "+31-(0)10-1234123")
         expect(model.normalized_phone_method).to eql('+31101234123')
       end
 
     # Following examples have incomplete number
       it "should normalize even a unplausible number (no country code)" do
-        model = model_klass.new(:phone_attribute => "(0)10-1234123")
+        model = model_klass.new(phone_attribute: "(0)10-1234123")
         expect(model.normalized_phone_attribute).to eql('101234123')
       end
 
       it "should use country_code option" do
-        model = model_klass.new(:phone_attribute => "(0)10-1234123")
-        expect(model.normalized_phone_attribute(:country_code => 'NL')).to eql('+31101234123')
+        model = model_klass.new(phone_attribute: "(0)10-1234123")
+        expect(model.normalized_phone_attribute(country_code: 'NL')).to eql('+31101234123')
       end
 
       it "should use country_code object method" do
-        model = model_klass.new(:phone_attribute => "(0)10-1234123", :country_code => 'NL')
+        model = model_klass.new(phone_attribute: "(0)10-1234123", country_code: 'NL')
         expect(model.normalized_phone_attribute).to eql('+31101234123')
       end
 
       it "should fallback to default_country_code option" do
-        model = model_klass.new(:phone1_method => "(030) 8 61 29 06")
+        model = model_klass.new(phone1_method: "(030) 8 61 29 06")
         expect(model.normalized_phone1_method).to eql('+49308612906')
       end
 
       it "should overwrite default_country_code option with object method" do
-        model = model_klass.new(:phone1_method => "(030) 8 61 29 06", :country_code => 'NL')
+        model = model_klass.new(phone1_method: "(030) 8 61 29 06", country_code: 'NL')
         expect(model.normalized_phone1_method).to eql('+31308612906')
       end
 
       it "should overwrite default_country_code option with option" do
-        model = model_klass.new(:phone1_method => "(030) 8 61 29 06")
-        expect(model.normalized_phone1_method(:country_code => 'NL')).to eql('+31308612906')
+        model = model_klass.new(phone1_method: "(030) 8 61 29 06")
+        expect(model.normalized_phone1_method(country_code: 'NL')).to eql('+31308612906')
       end
 
       it "should use last passed options" do
-        model = model_klass.new(:phone1_method => "(030) 8 61 29 06")
-        expect(model.normalized_phone1_method(:country_code => 'NL')).to eql('+31308612906')
-        expect(model.normalized_phone1_method(:country_code => 'DE')).to eql('+49308612906')
-        expect(model.normalized_phone1_method(:country_code => nil)).to eql('+49308612906')
+        model = model_klass.new(phone1_method: "(030) 8 61 29 06")
+        expect(model.normalized_phone1_method(country_code: 'NL')).to eql('+31308612906')
+        expect(model.normalized_phone1_method(country_code: 'DE')).to eql('+49308612906')
+        expect(model.normalized_phone1_method(country_code: nil)).to eql('+49308612906')
       end
 
       it "should use last object method" do
-        model = model_klass.new(:phone1_method => "(030) 8 61 29 06")
+        model = model_klass.new(phone1_method: "(030) 8 61 29 06")
         model.country_code = 'NL'
         expect(model.normalized_phone1_method).to eql('+31308612906')
         model.country_code = 'DE'
         expect(model.normalized_phone1_method).to eql('+49308612906')
         model.country_code = nil
-        expect(model.normalized_phone1_method(:country_code => nil)).to eql('+49308612906')
+        expect(model.normalized_phone1_method(country_code: nil)).to eql('+49308612906')
       end
     end
 
     describe 'using model#phony_normalize' do
       it "should not change normalized numbers (see #76)" do
-        model = model_klass.new(:phone_number => "+31-(0)10-1234123")
-        expect(model.valid?).to be true
+        model = model_klass.new(phone_number: "+31-(0)10-1234123")
+        expect(model).to be_valid
         expect(model.phone_number).to eql('+31101234123')
       end
 
       it "should set a normalized version of an attribute using :as option" do
-        model_klass.phony_normalize :phone_number, :as => :phone_number_as_normalized
-        model = model_klass.new(:phone_number => "+31-(0)10-1234123")
-        expect(model.valid?).to be true
+        model_klass.phony_normalize :phone_number, as: :phone_number_as_normalized
+        model = model_klass.new(phone_number: "+31-(0)10-1234123")
+        expect(model).to be_valid
         expect(model.phone_number_as_normalized).to eql('+31101234123')
       end
 
       it "should not add a + using :add_plus option" do
-        model_klass.phony_normalize :phone_number, :add_plus => false
-        model = model_klass.new(:phone_number => "+31-(0)10-1234123")
-        expect(model.valid?).to be true
+        model_klass.phony_normalize :phone_number, add_plus: false
+        model = model_klass.new(phone_number: "+31-(0)10-1234123")
+        expect(model).to be_valid
         expect(model.phone_number).to eql('31101234123')
       end
 
@@ -466,7 +504,7 @@ describe PhonyRails do
       end
 
       it "should raise a RuntimeError at validation if the :as option attribute doesn't exist" do
-        dummy_klass.phony_normalize :phone_number, :as => :non_existing_attribute
+        dummy_klass.phony_normalize :phone_number, as: :non_existing_attribute
         dummy = dummy_klass.new
         expect(lambda {
           dummy.valid?
@@ -476,12 +514,12 @@ describe PhonyRails do
   end
 
   describe 'ActiveRecord' do
-    let(:model_klass){ ActiveRecordModel }
-    let(:dummy_klass){ ActiveRecordDummy }
+    let(:model_klass) { ActiveRecordModel }
+    let(:dummy_klass) { ActiveRecordDummy }
     it_behaves_like 'model with PhonyRails'
 
     it "should correctly keep a hard set country_code" do
-      model = model_klass.new(:fax_number => '+1 978 555 0000')
+      model = model_klass.new(fax_number: '+1 978 555 0000')
       expect(model.valid?).to be true
       expect(model.fax_number).to eql('+19785550000')
       expect(model.save).to be true
@@ -545,8 +583,8 @@ describe PhonyRails do
   end
 
   describe 'Mongoid' do
-    let(:model_klass){ MongoidModel }
-    let(:dummy_klass){ MongoidDummy }
+    let(:model_klass) { MongoidModel }
+    let(:dummy_klass) { MongoidDummy }
     it_behaves_like 'model with PhonyRails'
   end
 end