phony_rails 0.12.11 → 0.12.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fcd21433ed37b73d7a13e4a968426fe495824be7
-  data.tar.gz: c6906d6e411bbae10ecdacbe4ba6f571f0a11dae
+  metadata.gz: 97008ef55c4d1d7748babd4150f0cd8ff7cabaeb
+  data.tar.gz: 37045f7383c7811809ba99f151dd133448c4967c
 SHA512:
-  metadata.gz: 67e23bae153edccc3e21d6392a0d9d38394646ba3008701db2565d6c77842a0ad5156802a173b9d34eeb5a4408d5f7c220ff0c0ecb54f3516cf94f4b685ae2c9
-  data.tar.gz: bdb52a58cf910d0918f5b088178fea408fe8915affe747cbdc67e5fa3045082162c6e4df409f8b9d55fd5693b4061d166fcfb5ab375dc8ca44f9e022d45719f6
+  metadata.gz: 39dc96431aca90966b4d79f6441213cbe6e1fbd920a86e50b1fe10f49606fbe020bb4ae557b0edec411b4a8e15814d3f15e8e102c595b63c6eabf2790596a130
+  data.tar.gz: 73b3c1c05704b4dd21e442888eedd2550688d5d6bb2dbe68475f29671bdff61228f2d0522c919ce8744781ff46060e79eb47c6d5b06bfb523f9d01de9757368c

data/.gitignore

@@ -1,5 +1,8 @@
+.DS_Store
 /.rvmrc
 /.idea/
 .ruby-gemset
 .ruby-version
 coverage/*
+/.bundle
+/vendor

data/CHANGELOG.md

@@ -1,19 +1,37 @@
 # Change Log
 
-## [Unreleased](https://github.com/joost/phony_rails/tree/HEAD)
+## [v0.12.11](https://github.com/joost/phony_rails/tree/v0.12.11) (2015-11-12)
 
-[Full Changelog](https://github.com/joost/phony_rails/compare/v0.12.9...HEAD)
+[Full Changelog](https://github.com/joost/phony_rails/compare/v0.12.9...v0.12.11)
 
 **Closed issues:**
 
+- French formatting [\#121](https://github.com/joost/phony_rails/issues/121)
+
+- French phony\_normalize [\#120](https://github.com/joost/phony_rails/issues/120)
+
+- Correct phone number failed the validatiton [\#115](https://github.com/joost/phony_rails/issues/115)
+
+- 'no implicit conversion of nil into String' from phony\_formatted!\(spaces: '-', strict: true\) with invalid numbers [\#113](https://github.com/joost/phony_rails/issues/113)
+
 - Can i skip a validation with another number? [\#110](https://github.com/joost/phony_rails/issues/110)
 
 - Consider dropping the dependency on the countries gem and using a YAML file instead [\#108](https://github.com/joost/phony_rails/issues/108)
 
+- Some Finnish mobile numbers are formatted wrong [\#107](https://github.com/joost/phony_rails/issues/107)
+
 - undefined method `\[\]' for Data:Class [\#106](https://github.com/joost/phony_rails/issues/106)
 
+- Phony is out of date [\#102](https://github.com/joost/phony_rails/issues/102)
+
 **Merged pull requests:**
 
+- Update readme [\#117](https://github.com/joost/phony_rails/pull/117) ([toydestroyer](https://github.com/toydestroyer))
+
+- Add uk, ru error message translations [\#114](https://github.com/joost/phony_rails/pull/114) ([shhavel](https://github.com/shhavel))
+
+- Update phony\_rails.gemspec [\#112](https://github.com/joost/phony_rails/pull/112) ([Agsiegert](https://github.com/Agsiegert))
+
 - Don't re-parse country codes YAML file every time it's needed. [\#111](https://github.com/joost/phony_rails/pull/111) ([jcoleman](https://github.com/jcoleman))
 
 - Replace countries dependency with YAML file [\#109](https://github.com/joost/phony_rails/pull/109) ([monfresh](https://github.com/monfresh))

data/Gemfile.lock

@@ -1,40 +1,40 @@
 PATH
   remote: .
   specs:
-    phony_rails (0.12.10)
+    phony_rails (0.12.12)
       activesupport (>= 3.0)
       phony (~> 2.12)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (4.2.5)
-      activesupport (= 4.2.5)
+    activemodel (4.2.5.1)
+      activesupport (= 4.2.5.1)
       builder (~> 3.1)
-    activerecord (4.2.5)
-      activemodel (= 4.2.5)
-      activesupport (= 4.2.5)
+    activerecord (4.2.5.1)
+      activemodel (= 4.2.5.1)
+      activesupport (= 4.2.5.1)
       arel (~> 6.0)
-    activesupport (4.2.5)
+    activesupport (4.2.5.1)
       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.6)
+    bson (4.0.1)
     builder (3.2.2)
     coderay (1.1.0)
-    coveralls (0.8.8)
+    coveralls (0.8.10)
       json (~> 1.8)
       rest-client (>= 1.6.8, < 2)
-      simplecov (~> 0.10.0)
+      simplecov (~> 0.11.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.25)
+    domain_name (0.5.20160128)
       unf (>= 0.0.5, < 1.0.0)
     ffi (1.9.10)
     formatador (0.2.5)
@@ -60,34 +60,34 @@ GEM
       domain_name (~> 0.5)
     i18n (0.7.0)
     json (1.8.3)
-    listen (3.0.4)
+    listen (3.0.6)
       rb-fsevent (>= 0.9.3)
-      rb-inotify (>= 0.9)
-    lumberjack (1.0.9)
+      rb-inotify (>= 0.9.7)
+    lumberjack (1.0.10)
     method_source (0.8.2)
-    mime-types (2.6.2)
-    minitest (5.8.2)
-    mongo (2.1.2)
-      bson (~> 3.0)
-    mongoid (5.0.1)
+    mime-types (2.99)
+    minitest (5.8.4)
+    mongo (2.2.2)
+      bson (~> 4.0)
+    mongoid (5.1.0)
       activemodel (~> 4.0)
       mongo (~> 2.1)
-      origin (~> 2.1)
+      origin (~> 2.2)
       tzinfo (>= 0.3.37)
-    nenv (0.2.0)
+    nenv (0.3.0)
     netrc (0.11.0)
     notiffany (0.0.8)
       nenv (~> 0.1)
       shellany (~> 0.0)
-    origin (2.1.1)
-    phony (2.15.8)
+    origin (2.2.0)
+    phony (2.15.15)
     pry (0.10.3)
       coderay (~> 1.1.0)
       method_source (~> 0.8.1)
       slop (~> 3.4)
-    rake (10.4.2)
-    rb-fsevent (0.9.6)
-    rb-inotify (0.9.5)
+    rake (10.5.0)
+    rb-fsevent (0.9.7)
+    rb-inotify (0.9.7)
       ffi (>= 0.5.0)
     rest-client (1.8.0)
       http-cookie (>= 1.0.2, < 2.0)
@@ -97,17 +97,17 @@ GEM
       rspec-core (~> 3.4.0)
       rspec-expectations (~> 3.4.0)
       rspec-mocks (~> 3.4.0)
-    rspec-core (3.4.0)
+    rspec-core (3.4.2)
       rspec-support (~> 3.4.0)
     rspec-expectations (3.4.0)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.4.0)
-    rspec-mocks (3.4.0)
+    rspec-mocks (3.4.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.4.0)
-    rspec-support (3.4.0)
+    rspec-support (3.4.1)
     shellany (0.0.1)
-    simplecov (0.10.0)
+    simplecov (0.11.2)
       docile (~> 1.1.0)
       json (~> 1.8)
       simplecov-html (~> 0.10.0)
@@ -123,7 +123,7 @@ GEM
       thread_safe (~> 0.1)
     unf (0.1.4)
       unf_ext
-    unf_ext (0.0.7.1)
+    unf_ext (0.0.7.2)
 
 PLATFORMS
   ruby

data/README.md

@@ -105,7 +105,7 @@ 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, tr, ua and ru.
+the i18n key is `:improbable_phone`. Languages supported by default: de, en, fr, it, ja, kh, nl, tr, ua and ru.
 
 You can also validate if a number has the correct country number:
 

data/lib/data/country_codes.yaml

@@ -489,6 +489,8 @@ WF:
   country_code: '681'
 WS:
   country_code: '685'
+XK:
+  country_code: '383'
 YE:
   country_code: '967'
 YT:

data/lib/phony_rails.rb

@@ -5,7 +5,6 @@ require 'phony_rails/version'
 require 'yaml'
 
 module PhonyRails
-
   def self.country_number_for(country_code)
     return if country_code.nil?
 
@@ -34,7 +33,7 @@ module PhonyRails
     if _country_number = options[:country_number] || country_number_for(options[:country_code])
       options[:add_plus] = true if options[:add_plus].nil?
       # (Force) add country_number if missing
-      # NOTE: do we need to force adding country code? Otherwise we can share lofic with next block
+      # NOTE: do we need to force adding country code? Otherwise we can share logic with next block
       if !Phony.plausible?(number) || _country_number != country_code_from_number(number)
         number = "#{_country_number}#{number}"
       end
@@ -42,7 +41,7 @@ module PhonyRails
       options[:add_plus] = true if options[:add_plus].nil?
       # We try to add the default country number and see if it is a
       # correct phone number. See https://github.com/joost/phony_rails/issues/87#issuecomment-89324426
-      if not (number =~ /\A\+/) # if we don't have a +
+      unless 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/, '')}")
@@ -72,7 +71,7 @@ module PhonyRails
     return false if number.nil? || number.blank?
     number = normalize_number(number, options)
     country_number = options[:country_number] || country_number_for(options[:country_code]) ||
-      default_country_number = options[:default_country_number] || country_number_for(options[:default_country_code])
+                     options[:default_country_number] || country_number_for(options[:default_country_code])
     Phony.plausible? number, cc: country_number
   rescue
     false
@@ -94,14 +93,13 @@ module PhonyRails
         end
         attributes.each do |attribute|
           attribute_name = options[:as] || attribute
-          raise RuntimeError, "No attribute #{attribute_name} found on #{self.class.name} (PhonyRails)" if not self.class.attribute_method?(attribute_name)
-          self.send("#{attribute_name}=", PhonyRails.normalize_number(self.send(attribute), options))
+          fail(RuntimeError, "No attribute #{attribute_name} found on #{self.class.name} (PhonyRails)") unless self.class.attribute_method?(attribute_name)
+          send("#{attribute_name}=", PhonyRails.normalize_number(send(attribute), options))
         end
       end
     end
 
     module ClassMethods
-
       # Use this method on the class level like:
       #   phony_normalize :phone_number, :fax_number, :default_country_code => 'NL'
       #
@@ -117,7 +115,7 @@ module PhonyRails
         options[:enforce_record_country] = true if options[:enforce_record_country].nil?
 
         # Add before validation that saves a normalized version of the phone number
-        self.before_validation do
+        before_validation do
           set_phony_normalized_numbers(attributes, options)
         end
       end
@@ -129,12 +127,12 @@ module PhonyRails
         main_options = attributes.last.is_a?(Hash) ? attributes.pop : {}
         main_options.assert_valid_keys :country_code, :default_country_code
         attributes.each do |attribute|
-          raise StandardError, "Instance method normalized_#{attribute} already exists on #{self.name} (PhonyRails)" if method_defined?(:"normalized_#{attribute}")
+          fail(StandardError, "Instance method normalized_#{attribute} already exists on #{self.name} (PhonyRails)") if method_defined?(:"normalized_#{attribute}")
           define_method :"normalized_#{attribute}" do |*args|
             options = args.first || {}
-            raise ArgumentError, "No attribute/method #{attribute} found on #{self.class.name} (PhonyRails)" if not self.respond_to?(attribute)
-            options[:country_code] ||= self.country_code if self.respond_to?(:country_code)
-            PhonyRails.normalize_number(self.send(attribute), main_options.merge(options))
+            fail(ArgumentError, "No attribute/method #{attribute} found on #{self.class.name} (PhonyRails)") unless self.respond_to?(attribute)
+            options[:country_code] ||= country_code if self.respond_to?(:country_code)
+            PhonyRails.normalize_number(send(attribute), main_options.merge(options))
           end
         end
       end

data/lib/phony_rails/locales/nl.yml

@@ -0,0 +1,4 @@
+nl:
+  errors:
+    messages:
+      improbable_phone: "is geen geldig nummer"

data/lib/phony_rails/version.rb

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

data/spec/lib/phony_rails_spec.rb

@@ -1,115 +1,103 @@
 require 'spec_helper'
 
 describe PhonyRails do
-  it "should not pollute the global namespace with a Country class" do
-    should_not be_const_defined "Country"
+  it 'should not pollute the global namespace with a Country class' do
+    should_not be_const_defined 'Country'
   end
 
   describe 'phony_format String extension' do
-
     describe 'the phony_formatted method' do
-
       it 'should not modify the original options Hash' do
         options = {normalize: :NL, format: :international}
-        "0101234123".phony_formatted(options)
+        '0101234123'.phony_formatted(options)
         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"
+        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).to eql("+31 10 123 4123")
+          expect(s).to eql('+31 10 123 4123')
         end
-
       end
 
       describe 'with strict option' do
-
-        it "should return nil with non plausible number" 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)
         end
 
-        it "should not return nil with plausible number" do
+        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)
         end
-
       end
 
       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')
+        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')
         end
 
-        it "should not change original String" do
-          s = "0101234123"
+        it 'should not change original String' do
+          s = '0101234123'
           expect(s.phony_formatted(normalize: :NL)).to eql('010 123 4123')
-          expect(s).to eql("0101234123")
+          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')
+        it 'should phony_format String with country code' do
+          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')
+        it 'should phony_format String with country code' do
+          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')
+        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')
         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')
+        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')
         end
-
       end
 
       describe 'with raise option' do
-
         # https://github.com/joost/phony_rails/issues/79
-
         context 'when raise is true' do
-          it "should raise the error" do
-            expect(lambda {
+          it 'should raise the error' do
+            expect(lambda do
               "8887716095".phony_formatted(format: :international, raise: true)
-            }).to raise_error(NoMethodError)
+            end).to raise_error(NoMethodError)
           end
         end
 
         context 'when raise is false (default)' do
-          it "should return original String on exception" do
-            expect("8887716095".phony_formatted(format: :international)).to eq('8887716095')
+          it 'should return original String on exception' do
+            expect('8887716095'.phony_formatted(format: :international)).to eq('8887716095')
           end
         end
-
       end
 
-      describe "specific tests from issues" do
-
+      describe 'specific tests from issues' do
         # https://github.com/joost/phony_rails/issues/79
-        it "should pass Github issue #42" do
-          expect("8887716095".phony_formatted(format: :international, normalize: 'US', raise: true)).to eq('+1 (888) 771-6095')
+        it 'should pass Github issue #42' do
+          expect('8887716095'.phony_formatted(format: :international, normalize: 'US', raise: true)).to eq('+1 (888) 771-6095')
         end
 
         # https://github.com/joost/phony_rails/issues/42
-        it "should pass Github issue #42" do
+        it 'should pass Github issue #42' do
           expect(PhonyRails.normalize_number("0606060606", default_country_code: 'FR')).to eq('+33606060606')
         end
 
-        it "should pass Github issue #85" do
+        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')
         end
 
-        it "should pass Github issue #87" do
+        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')
@@ -117,33 +105,33 @@ describe PhonyRails do
           expect(PhonyRails.normalize_number('02318725305', default_country_code: 'US')).to eq('+12318725305')
         end
 
-        it "should pass Github issue #89" do
+        it 'should pass Github issue #89' do
           number = '+33 (0)6 87 36 18 75'
           expect(Phony.plausible?(number)).to be true
           expect(PhonyRails.normalize_number(number, country_code: 'FR')).to eq('+33687361875')
         end
 
-        it "should pass Github issue #90" do
-           number = '(0)30 1234 123'
-           expect(number.phony_normalized(country_code: 'NL')).to eq('+31301234123')
+        it 'should pass Github issue #90' do
+          number = '(0)30 1234 123'
+          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')
+        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"
+        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
+        it 'should pass Github issue #95' do
           number = '02031234567'
           expect(number.phony_normalized(default_country_code: 'GB')).to eq('+442031234567')
         end
@@ -153,124 +141,144 @@ describe PhonyRails do
           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")
+        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
+
+        it 'should pass Github issue #126 (country_code)' do
+          phone = '0143590213' # A plausible FR number
+          phone = PhonyRails.normalize_number(phone, country_code: 'FR')
+          expect(phone).to eq('+33143590213')
+          expect(Phony.plausible?(phone)).to be_truthy
+          phone = PhonyRails.normalize_number(phone, country_code: 'FR')
+          expect(phone).to eq('+33143590213')
+        end
+
+        # Adding a country code is expected behavior when a
+        # number is nog plausible.
+        it 'should pass Github issue #126 (country_code) (intended)' do
+          phone = '06123456789' # A non-plausible FR number
+          phone = PhonyRails.normalize_number(phone, country_code: 'FR')
+          expect(phone).to eq('+336123456789')
+          expect(Phony.plausible?(phone)).to be_falsy
+          phone = PhonyRails.normalize_number(phone, country_code: 'FR')
+          expect(phone).to eq('+33336123456789')
+        end
+
+        it 'should pass Github issue #126 (default_country_code)' do
+          phone = '06123456789' # French phone numbers have to be 10 chars long
+          phone = PhonyRails.normalize_number(phone, default_country_code: 'FR')
+          expect(phone).to eq('+336123456789')
+          phone = PhonyRails.normalize_number(phone, default_country_code: 'FR')
+          expect(phone).to eq('+336123456789')
+        end
       end
 
-      it "should not change original String" do
+      it 'should not change original String' do
         s = '0101234123'
         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')
+      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')
       end
 
-      it "should phony_format a digits String" do
-        expect("31101234123".phony_formatted(format: :international, spaces: '-')).to eql('+31-10-123-4123')
+      it 'should phony_format a digits String' do
+        expect('31101234123'.phony_formatted(format: :international, spaces: '-')).to eql('+31-10-123-4123')
       end
 
-      it "returns nil if implausible phone" do
-        expect("this is not a phone".phony_formatted).to be_nil
+      it 'returns nil if implausible phone' do
+        expect('this is not a phone'.phony_formatted).to be_nil
       end
 
-      it "returns nil on blank string" do
+      it 'returns nil on blank string' do
         expect("".phony_formatted).to be_nil
       end
-
     end
 
     describe 'the phony_normalized method' do
-
-      it "returns blank on blank string" do
-        expect("".phony_normalized).to be_nil
+      it 'returns blank on blank string' do
+        expect(''.phony_normalized).to be_nil
       end
 
       it 'should not modify the original options Hash' do
         options = {normalize: :NL, format: :international}
-        "0101234123".phony_normalized(options)
+        '0101234123'.phony_normalized(options)
         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")
+      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')
         end
 
-        it "should normalize without :country_code option" do
-          expect("010 1231234".phony_normalized).to eql("101231234")
+        it 'should normalize without :country_code option' do
+          expect('010 1231234'.phony_normalized).to eql('101231234')
         end
 
-        it "should normalize with :add_plus option" do
-          expect("010 1231234".phony_normalized(country_code: :NL, add_plus: false)).to eql("31101231234")
+        it 'should normalize with :add_plus option' do
+          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")
+      it 'should normalize with :add_plus option' do
+        expect('+31 (0)10 1231234'.phony_normalized(add_plus: false)).to eql('31101231234')
       end
 
-      it "should normalize a String" do
-        expect("+31 (0)10 1231234".phony_normalized).to eql("+31101231234")
+      it 'should normalize a String' do
+        expect('+31 (0)10 1231234'.phony_normalized).to eql('+31101231234')
       end
-
     end
-
   end
 
   describe 'PhonyRails#normalize_number' do
     context 'number with a country code' do
-
-      it "should not add default_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
       end
 
-      it "should force add country_code" do
+      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')
       end
 
-      it "should recognize lowercase country codes" do
+      it 'should recognize lowercase country codes' do
         expect(PhonyRails.normalize_number('4790909090', country_code: 'se')).to eql('+464790909090')
       end
-
     end
 
     context 'number without a country code' do
-
-      it "should normalize with a default_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')
       end
 
-      it "should normalize with a country_code" do
+      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')
       end
 
-      it "should handle different countries" do
+      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')
       end
 
-      it "should prefer country_code over default_country_code" do
+      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')
       end
 
-      it "should recognize lowercase country codes" do
+      it 'should recognize lowercase country codes' do
         expect(PhonyRails.normalize_number('010-1234123', country_code: 'nl')).to eql('+31101234123')
       end
 
     end
 
-    it "should handle some edge cases (with country_code)" do
+    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')
@@ -280,7 +288,7 @@ describe PhonyRails do
       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
+    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')
@@ -290,7 +298,7 @@ describe PhonyRails do
       expect(PhonyRails.normalize_number('0450 764 000', default_country_code: 'AU')).to eql('+61450764000')
     end
 
-    it "should normalize even an implausible number" do
+    it 'should normalize even an implausible number' do
       expect(PhonyRails.normalize_number('01')).to eql('1')
     end
   end
@@ -304,7 +312,7 @@ describe PhonyRails do
     let(:empty_number) { '' }
     let(:nil_number) { nil }
 
-    it "should return true for a valid number" do
+    it 'should return true for a valid number' do
       is_expected.to be_plausible_number valid_number, country_code: 'US'
     end
 
@@ -312,159 +320,159 @@ describe PhonyRails do
       is_expected.not_to be_plausible_number invalid_number, country_code: 'US'
     end
 
-    it "should return true for a normalizable number" do
+    it 'should return true for a normalizable number' do
       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
+    it 'should return false for a valid number with the wrong country code' do
       is_expected.not_to be_plausible_number normalizable_number, country_code: 'FR'
     end
 
-    it "should return true for a well formatted valid number" do
+    it 'should return true for a well formatted valid number' do
       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
+    it 'should return false for an empty number' do
       is_expected.not_to be_plausible_number empty_number, country_code: 'US'
     end
 
-    it "should return false for a nil number" do
+    it 'should return false for a nil number' do
       is_expected.not_to be_plausible_number nil_number, country_code: 'US'
     end
 
-    it "should return false when no country code is supplied" do
+    it 'should return false when no country code is supplied' do
       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")
+    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
 
   shared_examples_for 'model with PhonyRails' do
     describe 'defining model#phony_normalized_method' do
-      it "should add a normalized_phone_attribute method" do
+      it 'should add a normalized_phone_attribute method' do
         expect(model_klass.new).to respond_to(:normalized_phone_attribute)
       end
 
-      it "should add a normalized_phone_method method" do
+      it 'should add a normalized_phone_method method' do
         expect(model_klass.new).to respond_to(:normalized_phone_method)
       end
 
-      it "should raise error on existing methods" do
+      it 'should raise error on existing methods' do
         expect(lambda {
           model_klass.phony_normalized_method(:phone_method)
         }).to raise_error(StandardError)
       end
 
-      it "should raise error on not existing attribute" do
+      it 'should raise error on not existing attribute' do
         model_klass.phony_normalized_method(:phone_non_existing_method)
-        expect(lambda {
+        expect(lambda do
           model_klass.new.normalized_phone_non_existing_method
-        }).to raise_error(ArgumentError)
+        end).to raise_error(ArgumentError)
       end
     end
 
     describe 'defining model#phony_normalize' do
-      it "should not accept :as option with multiple attribute names" do
-        expect(lambda {
+      it 'should not accept :as option with multiple attribute names' do
+        expect(lambda do
           model_klass.phony_normalize(:phone_number, :phone1_method, as: 'non_existing_attribute')
-        }).to raise_error(ArgumentError)
+        end).to raise_error(ArgumentError)
       end
 
-      it "should accept :as option with non existing attribute name" do
-        expect(lambda {
+      it 'should accept :as option with non existing attribute name' do
+        expect(lambda do
           dummy_klass.phony_normalize(:non_existing_attribute, as: 'non_existing_attribute')
-        }).to_not raise_error
+        end).to_not raise_error
       end
 
-      it "should accept :as option with single non existing attribute name" do
-        expect(lambda {
+      it 'should accept :as option with single non existing attribute name' do
+        expect(lambda do
           dummy_klass.phony_normalize(:phone_number, as: 'something_else')
-        }).to_not raise_error
+        end).to_not raise_error
       end
 
-      it "should accept :as option with single existing attribute name" do
+      it 'should accept :as option with single existing attribute name' do
         expect(lambda {
           model_klass.phony_normalize(:phone_number, as: 'phone_number_as_normalized')
         }).to_not raise_error
       end
 
-      it "should accept a non existing attribute name" do
+      it 'should accept a non existing attribute name' do
         expect(lambda {
           dummy_klass.phony_normalize(:non_existing_attribute)
         }).to_not raise_error
       end
 
-      it "should accept supported options" do
+      it 'should accept supported options' do
         options = [:country_number, :default_country_number, :country_code, :default_country_code, :add_plus, :as, :enforce_record_country]
         options.each do |option_sym|
-          expect(lambda {
+          expect(lambda do
             dummy_klass.phony_normalize(:phone_number, option_sym => false)
-          }).to_not raise_error
+          end).to_not raise_error
         end
       end
 
-      it "should not accept unsupported options" do
-        expect(lambda {
+      it 'should not accept unsupported options' do
+        expect(lambda do
           dummy_klass.phony_normalize(:phone_number, unsupported_option: false)
-        }).to raise_error(ArgumentError)
+        end).to raise_error(ArgumentError)
       end
     end
 
     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")
+      # 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')
         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")
+      # 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')
         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")
+      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')
       end
 
-      it "should use country_code object method" do
-        model = model_klass.new(phone_attribute: "(0)10-1234123", country_code: 'NL')
+      it 'should use country_code object method' do
+        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")
+      it 'should fallback to default_country_code option' do
+        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')
+      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')
         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")
+      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')
       end
 
-      it "should use last passed options" do
-        model = model_klass.new(phone1_method: "(030) 8 61 29 06")
+      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')
       end
 
-      it "should use last object method" do
-        model = model_klass.new(phone1_method: "(030) 8 61 29 06")
+      it 'should use last object method' do
+        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'
@@ -475,27 +483,27 @@ describe PhonyRails do
     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")
+      it 'should not change normalized numbers (see #76)' do
+        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
+      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")
+        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
+      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")
+        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 raise a RuntimeError at validation if the attribute doesn't exist" do
+      it 'should raise a RuntimeError at validation if the attribute doesn\'t exist' do
         dummy_klass.phony_normalize :non_existing_attribute
         dummy = dummy_klass.new
         expect(lambda {
@@ -503,7 +511,7 @@ describe PhonyRails do
         }).to raise_error(RuntimeError)
       end
 
-      it "should raise a RuntimeError at validation if the :as option attribute doesn't exist" do
+      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 = dummy_klass.new
         expect(lambda {
@@ -518,7 +526,7 @@ describe PhonyRails do
     let(:dummy_klass) { ActiveRecordDummy }
     it_behaves_like 'model with PhonyRails'
 
-    it "should correctly keep a hard set country_code" do
+    it 'should correctly keep a hard set country_code' do
       model = model_klass.new(fax_number: '+1 978 555 0000')
       expect(model.valid?).to be true
       expect(model.fax_number).to eql('+19785550000')

data/spec/lib/validators/phony_validator_spec.rb

@@ -157,6 +157,14 @@ describe PhonyPlausibleValidator do
       expect(@home.errors.messages).to include(phone_number: ["is an invalid number"])
     end
 
+    it "should translate the error message in Dutch" do
+      I18n.with_locale(:nl) do
+        @home.phone_number = INVALID_NUMBER
+        @home.valid?
+        expect(@home.errors.messages).to include(phone_number: ["is geen geldig nummer"])
+      end
+    end
+
     it "should translate the error message in English" do
       I18n.with_locale(:en) do
         @home.phone_number = INVALID_NUMBER

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phony_rails
 version: !ruby/object:Gem::Version
-  version: 0.12.11
+  version: 0.12.13
 platform: ruby
 authors:
 - Joost Hietbrink
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-12 00:00:00.000000000 Z
+date: 2016-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: phony
@@ -93,6 +93,7 @@ files:
 - lib/phony_rails/locales/it.yml
 - lib/phony_rails/locales/ja.yml
 - lib/phony_rails/locales/km.yml
+- lib/phony_rails/locales/nl.yml
 - lib/phony_rails/locales/ru.yml
 - lib/phony_rails/locales/tr.yml
 - lib/phony_rails/locales/uk.yml