phony_rails 0.13.1 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6000f96b00258917b5399b860088a5d1d11d1fff
-  data.tar.gz: 666250cc63932a0d10563cd122ea2a8835032d90
+  metadata.gz: ebc2d2e0d7c8552d406ca7527590181a8d7f1437
+  data.tar.gz: 6e0ca4a8dd0e4447bd6d31469de69cc3e0781d3d
 SHA512:
-  metadata.gz: 935b0168ab070efdef52c294a886c8ac1c8e9a50c9e8a428be7762a449c63fd57ce3275b4b1f91e5772966ceb40c525101afc73e517bf3c82ca1d132d49511d8
-  data.tar.gz: cd99b5a59f9a1478480380b2df006b5f7869809fa2b520d669b5477188f70ff6e47e69df311782760ddb8652c868ab70338a046ac2ea34d77a4b9bb419818524
+  metadata.gz: 0f615e9274fca0cadab38bcbac8e58172c4102450d2f79e285c34dbcd88a2cf6c4c6ba476be24cfbb8e866113819daceb96f93d1e9c800e1c91656eceaf1de80
+  data.tar.gz: 5c6d09cb08448d47462afce4f448f6e3e15e46bd9c46f4016c4e961802cb231aff5ee4a2ecd9a49211b1d1caaba347a364cb5262ddfe9206a3573e88f2b4b953

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Change Log
 
+## [v0.14.0](https://github.com/joost/phony_rails/tree/v0.14.0) (2016-04-21)
+
+[Full Changelog](https://github.com/joost/phony_rails/compare/v0.13.0...v0.14.0)
+
+**Closed issues:**
+
+- In normalize\_number, .clone is being used, which preserves "frozenness", causing method to fail sometimes [\#136](https://github.com/joost/phony_rails/issues/136)
+
+- question Is thr any way to find country code from mobile no? [\#135](https://github.com/joost/phony_rails/issues/135)
+
+- invalid number assumed to be valid [\#130](https://github.com/joost/phony_rails/issues/130)
+
+- Split fails when a + is present [\#123](https://github.com/joost/phony_rails/issues/123)
+
+**Merged pull requests:**
+
+- Adds ability to pass symbols as option values to phony model helpers [\#139](https://github.com/joost/phony_rails/pull/139) ([jonathan-wheeler](https://github.com/jonathan-wheeler))
+
+- Add support for phone numbers with extensions [\#138](https://github.com/joost/phony_rails/pull/138) ([jerryclinesmith](https://github.com/jerryclinesmith))
+
+- Add support for a default country code [\#137](https://github.com/joost/phony_rails/pull/137) ([jerryclinesmith](https://github.com/jerryclinesmith))
+
+- Added first RuboCop stuff. [\#134](https://github.com/joost/phony_rails/pull/134) ([joost](https://github.com/joost))
+
 ## [v0.13.0](https://github.com/joost/phony_rails/tree/v0.13.0) (2016-03-12)
 
 [Full Changelog](https://github.com/joost/phony_rails/compare/v0.12.11...v0.13.0)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    phony_rails (0.13.0)
+    phony_rails (0.14.0)
       activesupport (>= 3.0)
       phony (~> 2.12)
 
@@ -139,3 +139,6 @@ DEPENDENCIES
   rspec
   rubocop
   sqlite3
+
+BUNDLED WITH
+   1.11.2

data/README.md

@@ -79,6 +79,14 @@ PhonyRails.normalize_number('+4790909090', default_country_code: 'SE') # => '+47
 
 The country_code should always be a ISO 3166-1 alpha-2 (http://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
 
+#### Default for all models
+
+You can set the default_country_code for all models using:
+
+```ruby
+PhonyRails.default_country_code = "US"
+```
+
 ### Validation
 
 In your model use the Phony.plausible method to validate an attribute:
@@ -178,6 +186,15 @@ You can also easily normalize a phone number String:
 "(0)30 1234 123".phony_normalized(country_code: 'NL') # => '301234123'
 ```
 
+Extensions are supported (identified by "ext", "ex", "x", "xt", "#", or ":") and will show at the end of the number:
+
+```ruby
+"+31 (0)30 1234 123 x999".phony_normalized # => '31301234123 x999'
+"+31 (0)30 1234 123 ext999".phony_normalized # => '31301234123 x999'
+"+31 (0)30 1234 123 #999".phony_normalized # => '31301234123 x999'
+```
+
+
 ### 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.

data/Rakefile

@@ -4,3 +4,11 @@ require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 task default: :spec
+
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'phony_rails'
+  ARGV.clear
+  IRB.start
+end

data/lib/phony_rails.rb

@@ -5,6 +5,23 @@ require 'phony_rails/version'
 require 'yaml'
 
 module PhonyRails
+  def self.default_country_code
+    @default_country_code ||= nil
+  end
+
+  def self.default_country_code=(new_code)
+    @default_country_code = new_code
+    @default_country_number = nil # Reset default country number, will lookup next time its asked for
+  end
+
+  def self.default_country_number
+    @default_country_number ||= default_country_code.present? ? country_number_for(default_country_code) : nil
+  end
+
+  def self.default_country_number=(new_number)
+    @default_country_number = new_number
+  end
+
   def self.country_number_for(country_code)
     return if country_code.nil?
 
@@ -28,6 +45,7 @@ module PhonyRails
     return if number.nil?
     original_number = number
     number = number.dup # Just to be sure, we don't want to change the original.
+    number, ext = extract_extension(number)
     number.gsub!(/[^\(\)\d\+]/, '') # Strips weird stuff from the number
     return if number.blank?
     if _country_number = options[:country_number] || country_number_for(options[:country_code])
@@ -37,29 +55,40 @@ module PhonyRails
       if !Phony.plausible?(number) || _country_number != country_code_from_number(number)
         number = "#{_country_number}#{number}"
       end
-    elsif _default_country_number = options[:default_country_number] || country_number_for(options[:default_country_code])
+    elsif _default_country_number = extract_default_country_number(options)
       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
-      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/, '')}")
-          # 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)
+      number = normalize_number_default_country(number, _default_country_number)
     end
     normalized_number = Phony.normalize(number)
     options[:add_plus] = true if options[:add_plus].nil? && Phony.plausible?(normalized_number)
-    options[:add_plus] ? "+#{normalized_number}" : normalized_number
+    normalized_number = options[:add_plus] ? "+#{normalized_number}" : normalized_number
+    format_extension(normalized_number, ext)
   rescue
     original_number # If all goes wrong .. we still return the original input.
   end
 
+  def self.normalize_number_default_country(number, default_country_number)
+    # 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
+    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?
+        return "#{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.
+        return "#{default_country_number}#{number.gsub(/^0/, '')}"
+      end
+    end
+    # number = "#{default_country_number}#{number}" unless Phony.plausible?(number)
+    # Just return the number unchanged
+    number
+  end
+
+  def self.extract_default_country_number(options = {})
+    options[:default_country_number] || country_number_for(options[:default_country_code]) || default_country_number
+  end
+
   def self.country_code_from_number(number)
     return nil unless Phony.plausible?(number)
     Phony.split(Phony.normalize(number)).first
@@ -69,14 +98,33 @@ module PhonyRails
   # NB: This method calls #normalize_number and passes _options_ directly to that method.
   def self.plausible_number?(number, options = {})
     return false if number.nil? || number.blank?
+    number = extract_extension(number).first
     number = normalize_number(number, options)
     country_number = options[:country_number] || country_number_for(options[:country_code]) ||
-                     options[:default_country_number] || country_number_for(options[:default_country_code])
+                     options[:default_country_number] || country_number_for(options[:default_country_code]) ||
+                     default_country_number
     Phony.plausible? number, cc: country_number
   rescue
     false
   end
 
+  COMMON_EXTENSIONS = /[ ]*(ext|ex|x|xt|#|:)+[^0-9]*\(*([-0-9]{1,})\)*#?$/i
+
+  def self.extract_extension(number_and_ext)
+    return [nil, nil] if number_and_ext.nil?
+    # :nocov:
+    if subbed = number_and_ext.sub(COMMON_EXTENSIONS, '')
+      [subbed, Regexp.last_match(2)]
+    else
+      [number_and_ext, nil]
+    end
+    # :nocov:
+  end
+
+  def self.format_extension(number, ext)
+    ext.present? ? "#{number} x#{ext}" : number
+  end
+
   module Extension
     extend ActiveSupport::Concern
 
@@ -87,6 +135,7 @@ module PhonyRails
       # It also adds the country_code (number), eg. 31 for NL numbers.
       def set_phony_normalized_numbers(attributes, options = {})
         options = options.dup
+        assign_values_for_phony_symbol_options(options)
         if respond_to?(:country_code)
           set_country_as = options[:enforce_record_country] ? :country_code : :default_country_code
           options[set_country_as] ||= country_code
@@ -98,6 +147,13 @@ module PhonyRails
           send("#{attribute_name}=", new_value) if new_value
         end
       end
+
+      def assign_values_for_phony_symbol_options(options)
+        symbol_options = [:country_number, :default_country_number, :country_code, :default_country_code]
+        symbol_options.each do |option|
+          options[option] = send(options[option]) if options[option].is_a?(Symbol)
+        end
+      end
     end
 
     module ClassMethods
@@ -130,10 +186,11 @@ module PhonyRails
         attributes.each do |attribute|
           raise(StandardError, "Instance method normalized_#{attribute} already exists on #{name} (PhonyRails)") if method_defined?(:"normalized_#{attribute}")
           define_method :"normalized_#{attribute}" do |*args|
-            options = args.first || {}
+            options = main_options.merge(args.first || {})
+            assign_values_for_phony_symbol_options(options)
             raise(ArgumentError, "No attribute/method #{attribute} found on #{self.class.name} (PhonyRails)") unless respond_to?(attribute)
             options[:country_code] ||= country_code if respond_to?(:country_code)
-            PhonyRails.normalize_number(send(attribute), main_options.merge(options))
+            PhonyRails.normalize_number(send(attribute), options)
           end
         end
       end

data/lib/phony_rails/string_extensions.rb

@@ -24,10 +24,11 @@ class String
     raise ArgumentError, "Expected options to be a Hash, got #{options.inspect}" unless options.is_a?(Hash)
     options = options.dup
     normalize_country_code = options.delete(:normalize)
-    s = (normalize_country_code ? PhonyRails.normalize_number(self, default_country_code: normalize_country_code.to_s, add_plus: false) : gsub(/\D/, ''))
+    s, ext = PhonyRails.extract_extension(self)
+    s = (normalize_country_code ? PhonyRails.normalize_number(s, default_country_code: normalize_country_code.to_s, add_plus: false) : s.gsub(/\D/, ''))
     return if s.blank?
     return if options[:strict] && !Phony.plausible?(s)
-    Phony.format(s, options.reverse_merge(format: :national))
+    PhonyRails.format_extension(Phony.format(s, options.reverse_merge(format: :national)), ext)
   rescue
     raise if options[:raise]
     s

data/lib/phony_rails/version.rb

@@ -1,3 +1,3 @@
 module PhonyRails
-  VERSION = '0.13.1'.freeze
+  VERSION = '0.14.0'.freeze
 end

data/lib/validators/phony_validator.rb

@@ -8,7 +8,6 @@ class PhonyPlausibleValidator < ActiveModel::EachValidator
     return if value.blank?
 
     @record = record
-
     value = PhonyRails.normalize_number(value.dup, default_country_code: normalized_country_code) if normalized_country_code
     @record.errors.add(attribute, error_message) unless Phony.plausible?(value, cc: country_number)
   end
@@ -16,15 +15,15 @@ class PhonyPlausibleValidator < ActiveModel::EachValidator
   private
 
   def error_message
-    options[:message] || :improbable_phone
+    options_value(:message) || :improbable_phone
   end
 
   def country_number
-    options[:country_number] || record_country_number || country_number_from_country_code
+    options_value(:country_number) || record_country_number || country_number_from_country_code
   end
 
   def record_country_number
-    @record.country_number if @record.respond_to?(:country_number) && !options[:ignore_record_country_number]
+    @record.country_number if @record.respond_to?(:country_number) && !options_value(:ignore_record_country_number)
   end
 
   def country_number_from_country_code
@@ -32,15 +31,23 @@ class PhonyPlausibleValidator < ActiveModel::EachValidator
   end
 
   def country_code
-    options[:country_code] || record_country_code
+    options_value(:country_code) || record_country_code
   end
 
   def record_country_code
-    @record.country_code if @record.respond_to?(:country_code) && !options[:ignore_record_country_code]
+    @record.country_code if @record.respond_to?(:country_code) && !options_value(:ignore_record_country_code)
   end
 
   def normalized_country_code
-    options[:normalized_country_code]
+    options_value(:normalized_country_code)
+  end
+
+  def options_value(option)
+    if options[option].is_a?(Symbol)
+      @record.send(options[option])
+    else
+      options[option]
+    end
   end
 end
 

data/spec/lib/phony_rails_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe PhonyRails do
+  EXT_PREFIXES = %w(ext ex x xt # :).freeze
+
   it 'should not pollute the global namespace with a Country class' do
     should_not be_const_defined 'Country'
   end
@@ -81,6 +83,19 @@ describe PhonyRails do
         end
       end
 
+      describe 'with extensions' do
+        EXT_PREFIXES.each do |prefix|
+          it "should format number with #{prefix} extension" do
+            expect("+319090#{prefix}123".phony_formatted(strict: true)).to eql(nil)
+            expect("101234123#{prefix}123".phony_formatted(normalize: :NL)).to eql('010 123 4123 x123')
+            expect("101234123#{prefix}123".phony_formatted(normalize: :NL, format: :international)).to eql('+31 10 123 4123 x123')
+            expect("31101234123#{prefix}123".phony_formatted(normalize: :NL)).to eql('010 123 4123 x123')
+            expect("8887716095#{prefix}123".phony_formatted(format: :international, normalize: 'US', raise: true)).to eq('+1 (888) 771-6095 x123')
+            expect("+12145551212#{prefix}123".phony_formatted).to eq('(214) 555-1212 x123')
+          end
+        end
+      end
+
       describe 'specific tests from issues' do
         # https://github.com/joost/phony_rails/issues/79
         it 'should pass Github issue #42' do
@@ -297,6 +312,30 @@ describe PhonyRails do
       end
     end
 
+    context 'number with an extension' do
+      EXT_PREFIXES.each do |prefix|
+        it "should handle some edge cases (with country_code) and #{prefix} extension" do
+          expect(PhonyRails.normalize_number("some nasty stuff in this +31 number 10-1234123 string #{prefix}123", country_code: 'NL')).to eql('+31101234123 x123')
+          expect(PhonyRails.normalize_number("070-4157134#{prefix}123", country_code: 'NL')).to eql('+31704157134 x123')
+          expect(PhonyRails.normalize_number("0031-70-4157134#{prefix}123", country_code: 'NL')).to eql('+31704157134 x123')
+          expect(PhonyRails.normalize_number("+31-70-4157134#{prefix}123", country_code: 'NL')).to eql('+31704157134 x123')
+          expect(PhonyRails.normalize_number("0322-69497#{prefix}123", country_code: 'BE')).to eql('+3232269497 x123')
+          expect(PhonyRails.normalize_number("+32 3 226 94 97#{prefix}123", country_code: 'BE')).to eql('+3232269497 x123')
+          expect(PhonyRails.normalize_number("0450 764 000#{prefix}123", country_code: 'AU')).to eql('+61450764000 x123')
+        end
+
+        it "should handle some edge cases (with default_country_code) and #{prefix}" do
+          expect(PhonyRails.normalize_number("some nasty stuff in this +31 number 10-1234123 string #{prefix}123", country_code: 'NL')).to eql('+31101234123 x123')
+          expect(PhonyRails.normalize_number("070-4157134#{prefix}123", default_country_code: 'NL')).to eql('+31704157134 x123')
+          expect(PhonyRails.normalize_number("0031-70-4157134#{prefix}123", default_country_code: 'NL')).to eql('+31704157134 x123')
+          expect(PhonyRails.normalize_number("+31-70-4157134#{prefix}123", default_country_code: 'NL')).to eql('+31704157134 x123')
+          expect(PhonyRails.normalize_number("0322-69497#{prefix}123", default_country_code: 'BE')).to eql('+3232269497 x123')
+          expect(PhonyRails.normalize_number("+32 3 226 94 97#{prefix}123", default_country_code: 'BE')).to eql('+3232269497 x123')
+          expect(PhonyRails.normalize_number("0450 764 000#{prefix}123", default_country_code: 'AU')).to eql('+61450764000 x123')
+        end
+      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')
@@ -320,6 +359,29 @@ describe PhonyRails do
     it 'should normalize even an implausible number' do
       expect(PhonyRails.normalize_number('01')).to eql('1')
     end
+
+    context 'with default_country_code set' do
+      before { PhonyRails.default_country_code = 'NL' }
+      after { PhonyRails.default_country_code = nil }
+
+      it 'normalize using the default' do
+        expect(PhonyRails.normalize_number('010-1234123')).to eql('+31101234123')
+        expect(PhonyRails.normalize_number('010-1234123')).to eql('+31101234123')
+        expect(PhonyRails.normalize_number('070-4157134')).to eql('+31704157134')
+        expect(PhonyRails.normalize_number('0031-70-4157134')).to eql('+31704157134')
+        expect(PhonyRails.normalize_number('+31-70-4157134')).to eql('+31704157134')
+      end
+
+      it 'allows default_country_code to be overridden' do
+        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('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
+    end
   end
 
   describe 'PhonyRails.plausible_number?' do
@@ -367,6 +429,65 @@ describe PhonyRails do
       expect(Phony).to receive(:plausible?).twice.and_raise('unexpected error')
       is_expected.not_to be_plausible_number normalizable_number, country_code: 'US'
     end
+
+    context 'with default_country_code set' do
+      before { PhonyRails.default_country_code = 'FR' }
+      after { PhonyRails.default_country_code = nil }
+
+      it 'uses the default' do
+        is_expected.not_to be_plausible_number normalizable_number
+        is_expected.to be_plausible_number formatted_french_number_with_country_code
+      end
+
+      it 'allows default_country_code to be overridden' do
+        is_expected.not_to be_plausible_number empty_number, country_code: 'US'
+        is_expected.not_to be_plausible_number nil_number, country_code: 'US'
+      end
+    end
+  end
+
+  describe 'PhonyRails.default_country' do
+    before { PhonyRails.default_country_code = 'US' }
+    after { PhonyRails.default_country_code = nil }
+
+    it 'can set a global default country code' do
+      expect(PhonyRails.default_country_code). to eq 'US'
+    end
+
+    it 'can set a global default country code' do
+      PhonyRails.default_country_number = '1'
+      expect(PhonyRails.default_country_number).to eq '1'
+    end
+
+    it 'default country code affects default country number' do
+      expect(PhonyRails.default_country_number).to eq '1'
+    end
+  end
+
+  describe 'PhonyRails#extract_extension' do
+    it 'returns [nil, nil] on nil input' do
+      expect(PhonyRails.extract_extension(nil)).to eq [nil, nil]
+    end
+
+    it 'returns [number, nil] when number does not have an extension' do
+      expect(PhonyRails.extract_extension('123456789')).to eq ['123456789', nil]
+    end
+
+    EXT_PREFIXES.each do |prefix|
+      it "returns [number, ext] when number has a #{prefix} extension" do
+        expect(PhonyRails.extract_extension("123456789#{prefix}123")).to eq %w(123456789 123)
+      end
+    end
+  end
+
+  describe 'PhonyRails#format_extension' do
+    it 'returns just number if no extension' do
+      expect(PhonyRails.format_extension('+123456789', nil)).to eq '+123456789'
+    end
+
+    it 'returns number with extension if extension exists' do
+      expect(PhonyRails.format_extension('+123456789', '123')).to eq '+123456789 x123'
+    end
   end
 
   shared_examples_for 'model with PhonyRails' do
@@ -499,6 +620,11 @@ describe PhonyRails do
         model.country_code = nil
         expect(model.normalized_phone1_method(country_code: nil)).to eql('+49308612906')
       end
+
+      it 'should accept a symbol when setting country_code options' do
+        model = model_klass.new(symboled_phone_method: '02031234567', country_code_attribute: 'GB')
+        expect(model.normalized_symboled_phone_method).to eql('+442031234567')
+      end
     end
 
     describe 'using model#phony_normalize' do
@@ -537,6 +663,12 @@ describe PhonyRails do
           dummy.valid?
         end).to raise_error(RuntimeError)
       end
+
+      it 'should accept a symbol when setting country_code options' do
+        model = model_klass.new(symboled_phone: '0606060606', country_code_attribute: 'FR')
+        expect(model).to be_valid
+        expect(model.symboled_phone).to eql('+33606060606')
+      end
     end
   end
 
@@ -560,8 +692,8 @@ describe PhonyRails do
     end
 
     context 'when enforce_record_country is turned off' do
-      let(:model_klass)  { RelaxedActiveRecordModel }
-      let(:record)       { model_klass.new }
+      let(:model_klass) { RelaxedActiveRecordModel }
+      let(:record) { model_klass.new }
 
       before do
         record.phone_number = phone_number

data/spec/lib/validators/phony_validator_spec.rb

@@ -54,6 +54,11 @@ ActiveRecord::Schema.define do
   create_table :invalid_country_code_helpful_homes do |table|
     table.column :phone_number, :string
   end
+
+  create_table :symbolizable_helpful_homes do |table|
+    table.column :phone_number, :string
+    table.column :phone_number_country_code, :string
+  end
 end
 
 #--------------------
@@ -132,6 +137,12 @@ class InvalidCountryCodeHelpfulHome < ActiveRecord::Base
     '--'
   end
 end
+
+#--------------------
+class SymbolizableHelpfulHome < ActiveRecord::Base
+  attr_accessor :phone_number, :phone_number_country_code
+  validates_plausible_phone :phone_number, country_code: :phone_number_country_code
+end
 #-----------------------------------------------------------------------------------------------------------------------
 # Tests
 #-----------------------------------------------------------------------------------------------------------------------
@@ -502,5 +513,36 @@ describe ActiveModel::Validations::HelperMethods do
         end.to_not raise_error
       end
     end
+
+    #--------------------
+    context 'when a country code is passed as a symbol' do
+      before(:each) do
+        @home = SymbolizableHelpfulHome.new
+      end
+
+      it 'should validate an empty number' do
+        expect(@home).to be_valid
+      end
+
+      it 'should validate a valid number with the right country code' do
+        @home.phone_number = POLISH_NUMBER_WITH_COUNTRY_CODE
+        @home.phone_number_country_code = 'PL'
+        expect(@home).to be_valid
+      end
+
+      it 'should invalidate a valid number with the wrong country code' do
+        @home.phone_number = FRENCH_NUMBER_WITH_COUNTRY_CODE
+        @home.phone_number_country_code = 'PL'
+        expect(@home).to_not be_valid
+        expect(@home.errors.messages).to include(phone_number: ['is an invalid number'])
+      end
+
+      it 'should invalidate a valid number without a country code' do
+        @home.phone_number = VALID_NUMBER
+        @home.phone_number_country_code = 'PL'
+        expect(@home).to_not be_valid
+        expect(@home.errors.messages).to include(phone_number: ['is an invalid number'])
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -21,18 +21,22 @@ ActiveRecord::Schema.define do
     table.column :phone_number, :string
     table.column :phone_number_as_normalized, :string
     table.column :fax_number, :string
+    table.column :country_code_attribute, :string
+    table.column :symboled_phone, :string
   end
 end
 
 module SharedModelMethods
   extend ActiveSupport::Concern
   included do
-    attr_accessor :phone_method, :phone1_method, :country_code
+    attr_accessor :phone_method, :phone1_method, :symboled_phone_method, :country_code, :country_code_attribute
     phony_normalized_method :phone_attribute # adds normalized_phone_attribute method
     phony_normalized_method :phone_method # adds normalized_phone_method method
     phony_normalized_method :phone1_method, default_country_code: 'DE' # adds normalized_phone_method method
+    phony_normalized_method :symboled_phone_method, country_code: :country_code_attribute # adds phone_with_symboled_options method
     phony_normalize :phone_number # normalized on validation
     phony_normalize :fax_number, default_country_code: 'AU'
+    phony_normalize :symboled_phone, default_country_code: :country_code_attribute
   end
 end
 
@@ -57,6 +61,8 @@ class MongoidModel
   field :phone_number,    type: String
   field :phone_number_as_normalized, type: String
   field :fax_number
+  field :country_code_attribute, type: String
+  field :symboled_phone, type: String
   include SharedModelMethods
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phony_rails
 version: !ruby/object:Gem::Version
-  version: 0.13.1
+  version: 0.14.0
 platform: ruby
 authors:
 - Joost Hietbrink
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-01 00:00:00.000000000 Z
+date: 2016-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: phony