phonelib 0.6.21 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 340a5c0487adffe92db6fbba129f1d79d669e3ca
-  data.tar.gz: 58b742b98ed74a4a8b47573f30b0eb4e4963e4ab
+SHA256:
+  metadata.gz: d9a96a615d554195979c6dc886188eb4f8638e89f616fb5ce5aa6cb74ee91ca0
+  data.tar.gz: e8b51d76743373fd9e2913eb5eddcea65e35e57673f29e47a361398dab662a16
 SHA512:
-  metadata.gz: 935c0feb67ce471cba7f9e2c4046deba98ea3800e5bbd864ef227ec5503a4fd1b8317d8a00cac190e02c8f161c9c72191f44b4c79129f1436ee2d4d7a7136cf7
-  data.tar.gz: 5377cf7fa504d3538163f7eac8142e8729620c0f558a48f3488e93a4a5ddd786061e2366028b21d525f16d68145b3c295be1dc8a243e11b068c1c3b5555a71f9
+  metadata.gz: 7710f2ab513e1bb53bb6bec2fe78de93fa742c18c85f2393f05ebf862cd245c7b3b01a4055403af287c4e225a58c26fd03507f0f08bf9e4d1468ad1279623ecd
+  data.tar.gz: e44959fbc033b27ac6b2974941c2ce010ba788bf371a4048a45c7d3dba78bb982b08c9201019b4bd2f958b139e46f7f29dcf0c0ae6c406a94d21490129df68de

data/README.md

@@ -2,16 +2,20 @@
 
 [![Built in integration with JetBrains RubyMine](https://github.com/daddyz/phonelib/blob/master/icon_RubyMine.png?raw=true)](https://www.jetbrains.com/ruby/)
 [![Gem Version](https://badge.fury.io/rb/phonelib.svg)](http://badge.fury.io/rb/phonelib)
-[![Build Status](https://travis-ci.org/daddyz/phonelib.png?branch=master)](http://travis-ci.org/daddyz/phonelib)
+[![CircleCI](https://circleci.com/gh/daddyz/phonelib/tree/master.svg?style=shield)](https://circleci.com/gh/daddyz/phonelib/tree/master)
 [![](https://codeclimate.com/github/daddyz/phonelib/badges/coverage.svg)](https://codeclimate.com/github/daddyz/phonelib/coverage)
 [![](https://codeclimate.com/github/daddyz/phonelib/badges/gpa.svg)](https://codeclimate.com/github/daddyz/phonelib)
-[![Dependency Status](https://gemnasium.com/daddyz/phonelib.svg)](https://gemnasium.com/daddyz/phonelib)
 [![Inline docs](http://inch-ci.org/github/daddyz/phonelib.svg?branch=master)](http://inch-ci.org/github/daddyz/phonelib)
 
 Phonelib is a gem allowing you to validate phone number. All validations are based on [Google libphonenumber](https://github.com/googlei18n/libphonenumber).
 Currently it can make basic validations and formatting to e164 international number format and national number format with prefix.
 But it still doesn't include all Google's library functionality.
 
+## Incorrect parsing or validation
+
+In case your phone number is incorrectly parsed, you can check original libphonenumber for result [here](https://rawgit.com/googlei18n/libphonenumber/master/javascript/i18n/phonenumbers/demo-compiled.html) and in case of same parse result [open an issue for them](https://issuetracker.google.com/issues/new?component=192347&template=829703). This gem's data is based on it.
+If you can't wait for libphonenumber to resolve the issue, try to use ```Phonelib.add_additional_regex``` and ```Phonelib.additional_regexes``` methods.
+
 ## Information
 
 ### Change Log
@@ -62,6 +66,18 @@ To disable sanitizing of passed phone number (keeping digits only)
 Phonelib.strict_check = true
 ```
 
+To change sanitized symbols on parsed number, so non-specified symbols won't be wiped and will fail the parsing
+
+``` ruby
+Phonelib.sanitize_regex = '[\.\-\(\) \;\+]'
+```
+
+To disable sanitizing of double prefix on passed phone number
+
+```ruby
+Phonelib.strict_double_prefix_check = true
+```
+
 To set different extension separator on formatting, this setting doesn't affect parsing. Default setting is ';'
 
 ``` ruby
@@ -72,7 +88,7 @@ To set symbols that are used for separating extension from phone number for pars
 
 ``` ruby
 Phonelib.extension_separate_symbols = '#;'           # for single symbol separator
-Phonelib.extension_separator = %w(ext # ; extension) # each string will be treated as separator
+Phonelib.extension_separate_symbols = %w(ext # ; extension) # each string will be treated as separator
 ```
 
 In case you need to overwrite some Google's libphonenumber library data, you need to assign file path to this setter. File should be Marshal.dump'ed with existing structure like in ```Phonelib.phone_data```. Gem is simply doing ```merge``` between hashes.
@@ -81,6 +97,21 @@ In case you need to overwrite some Google's libphonenumber library data, you nee
 Phonelib.override_phone_data = '/path/to/override_phone_data.dat'
 ```
 
+In case you want to add some custom or still not updated regex patterns for certain type you can use additional regexes feature in a following way:
+
+``` ruby
+Phonelib.add_additional_regex :us, Phonelib::Core::MOBILE, '[5]{10}' # this will add number 1-555-555-5555 to be valid
+Phonelib.add_additional_regex :gb, Phonelib::Core::MOBILE, '[1]{5}' # this will add number 44-11-111 to be valid
+# you can also specify all regexes using this method
+Phonelib.additional_regexes = [[:us, :mobile, "[5]{10}"], [:gb, :mobile, "[1]{5}"]]
+# or just use dump method to keep them altogether
+Phonelib.dump_additional_regexes # => [["US", :mobile, "[5]{10}"], ["GB", :mobile, "[1]{5}"]
+```
+
+(!) For a list of available types refer to this readme.
+
+(!) Please note that regex should be added as string
+
 In case phone number that was passed for parsing has "+" sign in the beginning, library will try to detect a country regarding the provided one.
 
 ### ActiveRecord Integration
@@ -109,7 +140,10 @@ Refer to [Google libphonenumber](http://code.google.com/p/libphonenumber/) for m
 <tt>types: :mobile</tt> or <tt>types: [:voip, :mobile]</tt> - allows to validate against specific phone types patterns,
 if mixed with <tt>possible</tt> will check if number is possible for specified type
 
-<tt>country_specifier: -> phone { phone.country.try(:upcase) }</tt> - allows to specify country for validation dynamically for each validation.
+<tt>countries: :us</tt> or <tt>countries: [:us, :ca]</tt> - allows to validate against specific countries, 
+if mixed with <tt>possible</tt> will check if number is possible for specified countries
+
+<tt>country_specifier: :method_name</tt> or <tt>country_specifier: -> instance { instance.country.try(:upcase) }</tt> - allows to specify country for validation dynamically for each validation. Usefull when phone is stored as national number without country prefix.
 
 <tt>extensions: false</tt> - set to perform check for phone extension to be blank
 
@@ -143,6 +177,7 @@ Additionally you can run:
 
 ``` ruby
 phone = Phonelib.parse('123456789')
+phone = Phonelib.parse('+1 (972) 123-4567', 'US')
 ```
 
 You can pass phone number with extension, it should be separated with <tt>;</tt> or <tt>#</tt> signs from the phone number.
@@ -222,7 +257,7 @@ phone.full_e164          # returns e164 phone representation with extension
 phone.full_international # returns formatted international number with extension
 ```
 
-You can pass <tt>false</tt> to <tt>national</tt> and <tt>international</tt> methods in order to get unformatted representaions
+You can pass <tt>false</tt> to <tt>national</tt> and <tt>international</tt> methods in order to get unformatted representations
 
 ``` ruby
 phone.international(false) # returns unformatted international phone
@@ -235,12 +270,33 @@ You can get E164 formatted number
 phone.e164 # returns number in E164 format
 ```
 
+You can define prefix for ```international``` and ```e164``` related methods to get formatted number prefixed with anything you need.
+
+``` ruby
+phone.international('00')      # returns formatted international number prefixed by 00 instead of +
+phone.e164('00')               # returns e164 represantation of a number prefixed by 00 instead of +
+phone.full_international('00') # returns formatted international number with extension prefixed by 00 instead of +
+phone.full_e164('00')          # returns e164 represantation of a number with extension prefixed by 00 instead of +
+phone.international_00         # same as phone.international('00'). 00 can be replaced with whatever you need
+phone.e164_00                  # same as phone.international('00') 
+```
+
 There is a ```to_s``` method, it will return ```e164``` in case number is valid and ```original``` otherwise
 
 ``` ruby
 phone.to_s # returns number in E164 format if number is valid or original otherwise
 ```
 
+You can compare 2 instances of ```Phonelib::Phone``` with ```==``` method or just use it with string
+
+```ruby 
+phone1 = Phonelib.parse('+12125551234') # Phonelib::Phone instance
+phone2 = Phonelib.parse('+12125551234') # Phonelib::Phone instance
+phone1 == phone2                        # returns true
+phone1 == '+12125551234'                # returns true
+phone1 == '12125551234;123'             # returns true
+```
+
 There is extended data available for numbers. It will return <tt>nil</tt> in case there is no data or phone is impossible.
 Can return array of values in case there are some results for specified number
 

data/Rakefile

@@ -22,6 +22,13 @@ end
 Bundler::GemHelper.install_tasks
 
 require 'rspec/core/rake_task'
+module TempFixForRakeLastComment
+  def last_comment
+    last_description
+  end
+end
+Rake::Application.send :include, TempFixForRakeLastComment
+
 RSpec::Core::RakeTask.new(:spec) do |t|
   if defined? Rails
     puts 'Rails found! Running tests with Rails'

data/lib/phonelib/core.rb

@@ -107,6 +107,38 @@ module Phonelib
       @@strict_check = strict
     end
 
+    # @private sanitizing regex, matching symbols will get removed from parsed number, must be string
+    @@sanitize_regex = '[^0-9]+'
+
+    # getter for sanitize regex
+    # @return [String] regex of symbols to wipe from parsed number
+    def sanitize_regex
+      @@sanitize_regex
+    end
+
+    # setter for sanitize regex
+    # @param regex [String] symbols to wipe from parsed number
+    # @return [String] regex of symbols to wipe from parsed number
+    def sanitize_regex=(regex)
+      @@sanitize_regex = regex.is_a?(String) ? regex : regex.to_s
+    end
+
+    # @private strict double prefix check for validator, doesn't sanitize number
+    @@strict_double_prefix_check = false
+
+    # getter for strict double prefix check flag
+    # @return [Boolean] Flag defines whether to do strict double prefix parsing check
+    def strict_double_prefix_check
+      @@strict_double_prefix_check
+    end
+
+    # setter for strict double prefix check flag
+    # @param strict [Boolean] make a strict double prefix parsing or not
+    # @return [Boolean] Flag defines whether to do strict double prefix parsing check
+    def strict_double_prefix_check=(strict)
+      @@strict_double_prefix_check = strict
+    end
+
     @@override_phone_data = nil
     # setter for data file to use
     def override_phone_data=(file_path)
@@ -117,6 +149,42 @@ module Phonelib
       @@override_phone_data
     end
 
+    @@additional_regexes = {}
+    # setter for data file to use
+    def additional_regexes=(data)
+      return unless data.is_a?(Array)
+      @@additional_regexes = {}
+      data.each do |row|
+        next if row.size != 3
+        add_additional_regex(*row)
+      end
+    end
+
+    def add_additional_regex(country, type, national_regex)
+      return unless Phonelib::Core::TYPES_DESC.keys.include?(type.to_sym)
+      return unless national_regex.is_a?(String)
+      @@phone_data = nil
+      @@additional_regexes[country.to_s.upcase] ||= {}
+      @@additional_regexes[country.to_s.upcase][type] ||= []
+      @@additional_regexes[country.to_s.upcase][type] << national_regex
+    end
+
+    def dump_additional_regexes
+      rows = []
+      @@additional_regexes.each do |country, types|
+        types.each do |type, regexes|
+          regexes.each do |regex|
+            rows << [country, type, regex]
+          end
+        end
+      end
+      rows
+    end
+
+    def additional_regexes
+      @@additional_regexes
+    end
+
     @@vanity_conversion = false
     # setter for vanity phone numbers chars replacement
     def vanity_conversion=(value)
@@ -285,6 +353,8 @@ module Phonelib
     EXT_PREFIXES = :prefixes
     # @private Extended data geo names array key
     EXT_GEO_NAMES = :geo_names
+    # @private Extended data country names array key
+    EXT_COUNTRY_NAMES = :country_names
     # @private Extended data timezones array key
     EXT_TIMEZONES = :timezones
     # @private Extended data carriers array key
@@ -359,6 +429,21 @@ module Phonelib
         override_data_file = Marshal.load(File.binread(override_phone_data))
         default_data.merge!(override_data_file)
       end
+      additional_regexes.each do |country, types|
+        types.each do |type, regex|
+          default_data[country][Core::TYPES][type] ||= {}
+          [Core::VALID_PATTERN, Core::POSSIBLE_PATTERN].each do |key|
+            if default_data[country][Core::TYPES][type][key]
+              default_data[country][Core::TYPES][type][key] << "|#{regex.join('|')}"
+            else
+              default_data[country][Core::TYPES][type][key] = regex.join('|')
+            end
+            if type != Core::GENERAL
+              default_data[country][Core::TYPES][Core::GENERAL][key] << "|#{regex.join('|')}"
+            end
+          end
+        end
+      end
       default_data
     end
 

data/lib/phonelib/data_importer.rb

@@ -18,7 +18,48 @@ module Phonelib
       include Phonelib::DataImporterHelper
 
       # countries that can have double country prefix in number
-      DOUBLE_COUNTRY_CODES_COUNTRIES = %w(IN DE BR IT NO)
+      DOUBLE_COUNTRY_CODES_COUNTRIES = %w(IN DE BR IT NO PL CU VN)
+      FORMAT_SHARING = {
+        'CA' => 'US',
+        'CC' => 'AU',
+        'CX' => 'AU',
+        'DM' => 'US',
+        'DO' => 'US',
+        'EH' => 'MA',
+        'GD' => 'US',
+        'GG' => 'GB',
+        'GU' => 'US',
+        'IM' => 'GB',
+        'JE' => 'GB',
+        'JM' => 'US',
+        'KN' => 'US',
+        'KY' => 'US',
+        'KZ' => 'RU',
+        'LC' => 'US',
+        'MF' => 'GP',
+        'MP' => 'US',
+        'MS' => 'US',
+        'PR' => 'US',
+        'SJ' => 'NO',
+        'SX' => 'US',
+        'TA' => 'SH',
+        'TC' => 'US',
+        'TT' => 'US',
+        'VA' => 'IT',
+        'VC' => 'US',
+        'VG' => 'US',
+        'VI' => 'US',
+        'YT' => 'RE',
+        'AG' => 'US',
+        'AI' => 'US',
+        'AS' => 'US',
+        'AX' => 'FI',
+        'BB' => 'US',
+        'BL' => 'GP',
+        'BM' => 'US',
+        'BQ' => 'CW',
+        'BS' => 'US',
+      }
 
       # main data file in repo
       MAIN_FILE = 'resources/PhoneNumberMetadata.xml'
@@ -42,6 +83,7 @@ module Phonelib
         @geo_names = []
         @timezones = []
         @carriers = []
+        @countries = {}
 
         run_import
       end
@@ -54,9 +96,11 @@ module Phonelib
         import_main_data
         import_short_data
         import_alternate_formats
+        process_format_links
         import_geocoding_data
         import_timezone_data
         import_carrier_data
+        import_country_names
         save_data_file
         save_extended_data_file
       end
@@ -113,6 +157,14 @@ module Phonelib
         end
       end
 
+      # some countries missing formats, and are linking them to another countries
+      def process_format_links
+        FORMAT_SHARING.each do |destination, source|
+          @data[destination][:formats] ||= []
+          @data[destination][:formats] = @data[destination][:formats] + @data[source][:formats]
+        end
+      end
+
       # method parses geocoding data dir
       def import_geocoding_data
         puts 'IMPORTING GEOCODING DATA'
@@ -137,6 +189,21 @@ module Phonelib
                               :c)
       end
 
+      # import country names
+      def import_country_names
+        puts 'IMPORTING COUNTRY NAMES'
+
+        require 'open-uri'
+        require 'csv'
+        io = open('http://api.geonames.org/countryInfoCSV?username=demo&style=full')
+        csv = CSV.new(io, {col_sep: "\t"})
+        csv.each do |row|
+          next if row[0].nil? || row[0].start_with?('#') || row[0].empty? || row[0].size != 2
+
+          @countries[row[0]] = row[4]
+        end
+      end
+
       # adds double country code flag in case country allows
       def add_double_country_flag(country)
         if DOUBLE_COUNTRY_CODES_COUNTRIES.include?(country[:id])

data/lib/phonelib/data_importer_helper.rb

@@ -22,6 +22,7 @@ module Phonelib
       extended = {
         Phonelib::Core::EXT_PREFIXES => @prefixes,
         Phonelib::Core::EXT_GEO_NAMES => @geo_names,
+        Phonelib::Core::EXT_COUNTRY_NAMES => @countries,
         Phonelib::Core::EXT_TIMEZONES => @timezones,
         Phonelib::Core::EXT_CARRIERS => @carriers
       }

data/lib/phonelib/phone.rb

@@ -7,6 +7,9 @@ module Phonelib
     # @!attribute [r] extension
     # @return [String] phone extension passed for parsing after a number
     attr_reader :extension
+    # @!attribute [r] national_number
+    # @return [String] phone national number
+    attr_reader :national_number
 
     # including module that has all phone analyzing methods
     include Phonelib::PhoneAnalyzer
@@ -37,12 +40,21 @@ module Phonelib
       valid? ? e164 : original
     end
 
+    # Compare a phone number against a string or other parsed number
+    # @param other [String|Phonelib::Phone] Phone number to compare against
+    # @return [Boolean] result of equality comparison
+    def ==(other)
+      other = Phonelib.parse(other) unless other.is_a?(Phonelib::Phone)
+      return (e164 == other.e164) if valid? && other.valid?
+      original == other.original
+    end
+
     # method to get sanitized phone number (only numbers)
     # @return [String] Sanitized phone number
     def sanitized
       @sanitized ||=
           vanity_converted(@original).gsub(
-              Phonelib.strict_check ? cr('^\+') : cr('[^0-9]+'),
+              Phonelib.strict_check ? cr('^\+') : cr(Phonelib.sanitize_regex),
               '')
     end
 

data/lib/phonelib/phone_analyzer.rb

@@ -16,15 +16,38 @@ module Phonelib
     # * +passed_country+ - Country provided for parsing. Must be ISO code of
     #   country (2 letters) like 'US', 'us' or :us for United States
     def analyze(phone, passed_country)
-      country = country_or_default_country passed_country
+      countries = country_or_default_country passed_country
 
+      return analyze_single_country(phone, countries.first, passed_country) if countries.size == 1
+
+      results = {}
+      countries.map do |country|
+        results.merge! analyze_single_country(phone, country, passed_country)
+      end
+
+      pick_results(results)
+    end
+
+    private
+
+    # pick best result when several countries specified
+    def pick_results(results)
+      [:valid, :possible].each do |key|
+        final = results.select { |_k, v| v[key].any? }
+        return decorate_analyze_result(final) if final.size > 0
+      end
+
+      decorate_analyze_result(results)
+    end
+
+    def analyze_single_country(phone, country, passed_country)
       result = parse_country(phone, country)
       d_result = case
                  when result && result.values.find { |e| e[:valid].any? }
                    # all is good, return result
                  when passed_country.nil?
                    # trying for all countries if no country was passed
-                   detect_and_parse phone
+                   detect_and_parse(phone, country)
                  when country_can_dp?(country)
                    # if country allows double prefix trying modified phone
                    parse_country(changed_dp_phone(country, phone), country)
@@ -32,8 +55,6 @@ module Phonelib
       better_result(result, d_result)
     end
 
-    private
-
     # method checks which result is better to return
     def better_result(base_result, result = nil)
       base_result ||= {}
@@ -102,11 +123,11 @@ module Phonelib
     # ==== Attributes
     #
     # * +phone+ - phone number for parsing
-    def detect_and_parse(phone)
+    def detect_and_parse(phone, country)
       result = {}
       Phonelib.phone_data.each do |key, data|
         parsed = parse_single_country(phone, data)
-        if double_prefix_allowed?(data, phone, parsed && parsed[key])
+        if (!Phonelib.strict_double_prefix_check || key == country) && double_prefix_allowed?(data, phone, parsed && parsed[key])
           parsed = parse_single_country(changed_dp_phone(key, phone), data)
         end
         result.merge!(parsed) unless parsed.nil?

data/lib/phonelib/phone_analyzer_helper.rb

@@ -3,6 +3,14 @@ module Phonelib
   module PhoneAnalyzerHelper
     private
 
+    def decorate_analyze_result(result)
+      if result.size == 1
+        result
+      else
+        Hash[result.take(1)]
+      end
+    end
+
     def original_starts_with_plus?
       original_s[0] == Core::PLUS_SIGN
     end
@@ -90,7 +98,11 @@ module Phonelib
     # * +country+ - country passed for parsing
     def country_or_default_country(country)
       country ||= (original_starts_with_plus? ? nil : Phonelib.default_country)
-      country && country.to_s.upcase
+      if country.is_a?(Array)
+        country.compact.map { |e| e.to_s.upcase }
+      else
+        [country && country.to_s.upcase]
+      end
     end
 
     # constructs full regex for phone validation for provided phone data
@@ -102,6 +114,7 @@ module Phonelib
     # * +country_optional+ - whether to put country code as optional group
     def full_regex_for_data(data, type, country_optional = true)
       regex = []
+      regex << '0{2}?'
       regex << "(#{data[Core::INTERNATIONAL_PREFIX]})?"
       regex << "(#{data[Core::COUNTRY_CODE]})#{country_optional ? '?' : ''}"
       regex << "(#{data[Core::NATIONAL_PREFIX_FOR_PARSING] || data[Core::NATIONAL_PREFIX]})?"
@@ -133,7 +146,7 @@ module Phonelib
     def phone_match_data?(phone, data, possible = false)
       country_code = "#{data[Core::COUNTRY_CODE]}"
       inter_prefix = "(#{data[Core::INTERNATIONAL_PREFIX]})?"
-      return unless phone.match cr("^#{inter_prefix}#{country_code}")
+      return unless phone.match cr("^0{2}?#{inter_prefix}#{country_code}")
 
       type = possible ? Core::POSSIBLE_PATTERN : Core::VALID_PATTERN
       phone.match full_regex_for_data(data, type, false)

data/lib/phonelib/phone_extended_data.rb

@@ -32,6 +32,13 @@ module Phonelib
                    Phonelib::Core::EXT_CARRIER_KEY
     end
 
+    # returns valid country name
+    def valid_country_name
+      return unless valid?
+
+      Phonelib.phone_ext_data[Phonelib::Core::EXT_COUNTRY_NAMES][valid_country]
+    end
+
     private
 
     # @private get name from extended phone data by keys
@@ -42,7 +49,7 @@ module Phonelib
     # * +id_key+   - parameter id key in resolved extended data for number
     #
     def get_ext_name(names_key, id_key)
-      return nil unless ext_data[id_key] > 0
+      return nil unless ext_data[id_key]
 
       res = Phonelib.phone_ext_data[names_key][ext_data[id_key]]
       return nil unless res
@@ -51,7 +58,7 @@ module Phonelib
 
     # @private returns extended data ids for current number
     def ext_data
-      return @ext_data if @ext_data
+      return @ext_data if defined?(@ext_data) && @ext_data
 
       result = default_ext_data
       return result unless possible?
@@ -72,7 +79,7 @@ module Phonelib
     # @private default extended data
     def default_ext_data
       result = {}
-      EXT_KEYS.each { |key| result[key] = 0 }
+      EXT_KEYS.each { |key| result[key] = nil }
       result
     end
   end

data/lib/phonelib/phone_formatter.rb

@@ -36,22 +36,24 @@ module Phonelib
                         Phonelib.phone_data[country][Core::COUNTRY_CODE]
     end
 
-    # Returns e164 formatted phone number
+    # Returns e164 formatted phone number. Method can receive single string parameter that will be defined as prefix
     # @param formatted [Boolean] whether to return numbers only or formatted
+    # @param prefix [String] prefix to be placed before the number, "+" by default
     # @return [String] formatted international number
-    def international(formatted = true)
+    def international(formatted = true, prefix = '+')
+      prefix = formatted if formatted.is_a?(String)
       return nil if sanitized.empty?
-      return "+#{country_prefix_or_not}#{sanitized}" unless valid?
-      return country_code + @national_number unless formatted
+      return "#{prefix}#{country_prefix_or_not}#{sanitized}" unless valid?
+      return "#{prefix}#{country_code}#{@national_number}" unless formatted
 
       fmt = @data[country][:format]
       national = @national_number
       if (matches = @national_number.match(cr(fmt[Core::PATTERN])))
         fmt = fmt[:intl_format] || fmt[:format]
-        national = fmt.gsub(/\$\d/) { |el| matches[el[1].to_i] }
+        national = fmt.gsub(/\$\d/) { |el| matches[el[1].to_i] } unless fmt == 'NA'
       end
 
-      "+#{country_code} #{national}"
+      "#{prefix}#{country_code} #{national}"
     end
 
     # returns national formatted number with extension added
@@ -61,22 +63,25 @@ module Phonelib
     end
 
     # returns international formatted number with extension added
+    # @param prefix [String] prefix to be placed before the number, "+" by default
     # @return [String] formatted internation phone number with extension
-    def full_international
-      "#{international}#{formatted_extension}"
+    def full_international(prefix = '+')
+      "#{international(true, prefix)}#{formatted_extension}"
     end
 
     # returns e164 format of phone with extension added
+    # @param prefix [String] prefix to be placed before the number, "+" by default
     # @return [String] phone formatted in E164 format with extension
-    def full_e164
-      "#{e164}#{formatted_extension}"
+    def full_e164(prefix = '+')
+      "#{e164(prefix)}#{formatted_extension}"
     end
 
     # Returns e164 unformatted phone number
+    # @param prefix [String] prefix to be placed before the number, "+" by default
     # @return [String] phone formatted in E164 format
-    def e164
-      international = self.international
-      international && international.gsub(/[^+0-9]/, '')
+    def e164(prefix = '+')
+      international = self.international(false, '')
+      international && "#{prefix}#{international}"
     end
 
     # returns area code of parsed number
@@ -93,6 +98,15 @@ module Phonelib
       format_match[take_group]
     end
 
+    def method_missing(method, *args)
+      prefix_methods = %w(international_ full_international_ e164_ full_e164_)
+      method_s = method.to_s
+      prefix_methods.each do |key|
+        return send(key[0..-2], method_s.gsub(key, '')) if method_s.start_with?(key)
+      end
+      super
+    end
+
     private
 
     # @private defines if phone can have area code
@@ -135,7 +149,12 @@ module Phonelib
       rule.gsub!(/(\$NP|\$FG)/, '$NP' => prefix, '$FG' => '$1')
 
       # add space to format groups, change first group to rule,
-      format_string = format[:format].gsub(/(\d)\$/, '\\1 $').gsub('$1', rule)
+      format_string = format[:format].gsub(/(\d)\$/, '\\1 $')
+      if format_string.include? '$1'
+	format_string.gsub! '$1', rule
+      else
+	format_string = rule.gsub('$1', '') + format_string
+      end
 
       @formatting_data =
           [@national_number.match(/#{format[Core::PATTERN]}/), format_string]

data/lib/phonelib/version.rb

@@ -1,4 +1,4 @@
 module Phonelib
   # @private
-  VERSION = '0.6.21'
+  VERSION = '0.7.0'
 end

data/lib/phonelib.rb

@@ -12,5 +12,9 @@ module Phonelib
 end
 
 if defined?(ActiveModel) || defined?(Rails)
-  autoload :PhoneValidator, 'validators/phone_validator'
+  if RUBY_VERSION >= '3.0.0'
+    autoload :PhoneValidator, 'validators/phone_validator3'
+  else
+    autoload :PhoneValidator, 'validators/phone_validator'
+  end
 end

data/lib/validators/phone_validator.rb

@@ -36,6 +36,13 @@
 #     validates :mobile, phone: { possible: true, types: :mobile  }
 #   end
 #
+# validates that phone is valid and it is from specified country or countries
+#
+#   class Phone < ActiveRecord::Base
+#     attr_accessible :number
+#     validates :number, phone: { countries: [:us, :ca] }
+#   end
+#
 # Validates that attribute does not include an extension.
 # The default setting is to allow extensions
 #
@@ -51,21 +58,11 @@ class PhoneValidator < ActiveModel::EachValidator
   # Validation method
   def validate_each(record, attribute, value)
     return if options[:allow_blank] && value.blank?
-    allowed_extensions = options.has_key?(:extensions) ? options[:extensions] : true
 
-    phone = parse(value, specified_country(record))
-    valid = if simple_validation?
-              phone.send(validate_method)
-            else
-              (phone_types(phone) & types).size > 0
-            end
+    @phone = parse(value, specified_country(record))
+    valid = phone_valid? && valid_types? && valid_country? && valid_extensions?
 
-    # We default to not-allowing extensions for fax numbers
-    if valid && !allowed_extensions && !phone.extension.empty?
-      valid = false
-    end
-
-    record.errors.add(attribute, message, options) unless valid
+    record.errors.add(attribute, message, **options) unless valid
   end
 
   private
@@ -74,34 +71,60 @@ class PhoneValidator < ActiveModel::EachValidator
     options[:message] || :invalid
   end
 
-  def validate_method
-    options[:possible] ? :possible? : :valid?
+  def phone_valid?
+    @phone.send(options[:possible] ? :possible? : :valid?)
+  end
+
+  def valid_types?
+    return true unless options[:types]
+    (phone_types & types).size > 0
+  end
+
+  def valid_country?
+    return true unless options[:countries]
+    (phone_countries & countries).size > 0
+  end
+
+  def valid_extensions?
+    return true if !options.has_key?(:extensions) || options[:extensions]
+    @phone.extension.empty?
   end
 
   def specified_country(record)
     return unless options[:country_specifier]
-    options[:country_specifier].call(record)
-  end
 
-  # @private
-  def simple_validation?
-    options[:types].nil?
+    if options[:country_specifier].is_a?(Symbol)
+      record.send(options[:country_specifier])
+    else
+      options[:country_specifier].call(record)
+    end
   end
 
   # @private
-  # @param phone [Phonelib::Phone] parsed phone
-  def phone_types(phone)
+  def phone_types
     method = options[:possible] ? :possible_types : :types
-    phone_types = phone.send(method)
+    phone_types = @phone.send(method)
     if (phone_types & [Phonelib::Core::FIXED_OR_MOBILE]).size > 0
       phone_types += [Phonelib::Core::FIXED_LINE, Phonelib::Core::MOBILE]
     end
     phone_types
   end
 
+  # @private
+  def phone_countries
+    method = options[:possible] ? :countries : :valid_countries
+    @phone.send(method)
+  end
+
   # @private
   def types
     types = options[:types].is_a?(Array) ? options[:types] : [options[:types]]
     types.map(&:to_sym)
   end
+
+  # @private
+  def countries
+    countries = options[:countries].is_a?(Array) ? options[:countries] : [options[:countries]]
+    countries.map { |c| c.to_s.upcase }
+  end
 end

data/lib/validators/phone_validator3.rb

@@ -0,0 +1,130 @@
+# Validator class for phone validations
+#
+# ==== Examples
+#
+# Validates that attribute is a valid phone number.
+# If empty value passed for attribute it fails.
+#
+#   class Phone < ActiveRecord::Base
+#     attr_accessible :number
+#     validates :number, phone: true
+#   end
+#
+# Validates that attribute is a possible phone number.
+# If empty value passed for attribute it fails.
+#
+#   class Phone < ActiveRecord::Base
+#     attr_accessible :number
+#     validates :number, phone: { possible: true }
+#   end
+#
+# Validates that attribute is a valid phone number.
+# Empty value is allowed to be passed.
+#
+#   class Phone < ActiveRecord::Base
+#     attr_accessible :number
+#     validates :number, phone: { allow_blank: true }
+#   end
+#
+# Validates that attribute is a valid phone number of specified type(s).
+# It is also possible to check that attribute is a possible number of specified
+# type(s). Symbol or array accepted.
+#
+#   class Phone < ActiveRecord::Base
+#     attr_accessible :number, :mobile
+#     validates :number, phone: { types: [:mobile, :fixed], allow_blank: true }
+#     validates :mobile, phone: { possible: true, types: :mobile  }
+#   end
+#
+# validates that phone is valid and it is from specified country or countries
+#
+#   class Phone < ActiveRecord::Base
+#     attr_accessible :number
+#     validates :number, phone: { countries: [:us, :ca] }
+#   end
+#
+# Validates that attribute does not include an extension.
+# The default setting is to allow extensions
+#
+#   class Phone < ActiveRecord::Base
+#     attr_accessible :number
+#     validates :number, phone: { extensions: false }
+#   end
+#
+class PhoneValidator < ActiveModel::EachValidator
+  # Include all core methods
+  include Phonelib::Core
+
+  # Validation method
+  def validate_each(record, attribute, value)
+    return if options[:allow_blank] && value.blank?
+
+    @phone = parse(value, specified_country(record))
+    valid = phone_valid? && valid_types? && valid_country? && valid_extensions?
+
+    record.errors.add(attribute, message, **options) unless valid
+  end
+
+  private
+
+  def message
+    options[:message] || :invalid
+  end
+
+  def phone_valid?
+    @phone.send(options[:possible] ? :possible? : :valid?)
+  end
+
+  def valid_types?
+    return true unless options[:types]
+    (phone_types & types).size > 0
+  end
+
+  def valid_country?
+    return true unless options[:countries]
+    (phone_countries & countries).size > 0
+  end
+
+  def valid_extensions?
+    return true if !options.has_key?(:extensions) || options[:extensions]
+    @phone.extension.empty?
+  end
+
+  def specified_country(record)
+    return unless options[:country_specifier]
+
+    if options[:country_specifier].is_a?(Symbol)
+      record.send(options[:country_specifier])
+    else
+      options[:country_specifier].call(record)
+    end
+  end
+
+  # @private
+  def phone_types
+    method = options[:possible] ? :possible_types : :types
+    phone_types = @phone.send(method)
+    if (phone_types & [Phonelib::Core::FIXED_OR_MOBILE]).size > 0
+      phone_types += [Phonelib::Core::FIXED_LINE, Phonelib::Core::MOBILE]
+    end
+    phone_types
+  end
+
+  # @private
+  def phone_countries
+    method = options[:possible] ? :countries : :valid_countries
+    @phone.send(method)
+  end
+
+  # @private
+  def types
+    types = options[:types].is_a?(Array) ? options[:types] : [options[:types]]
+    types.map(&:to_sym)
+  end
+
+  # @private
+  def countries
+    countries = options[:countries].is_a?(Array) ? options[:countries] : [options[:countries]]
+    countries.map { |c| c.to_s.upcase }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phonelib
 version: !ruby/object:Gem::Version
-  version: 0.6.21
+  version: 0.7.0
 platform: ruby
 authors:
 - Vadim Senderovich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-12 00:00:00.000000000 Z
+date: 2022-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "<"
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '14.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "<"
       - !ruby/object:Gem::Version
-        version: '11.0'
+        version: '14.0'
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.1
+        version: 1.13.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.1
+        version: 1.13.0
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -114,14 +114,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.8.6
+        version: 2.3.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.8.6
+        version: 2.3.1
 description: |2
       Google libphonenumber library was taken as a basis for
       this gem. Gem uses its data file for validations and number formatting.
@@ -148,6 +148,7 @@ files:
 - lib/phonelib/version.rb
 - lib/tasks/phonelib_tasks.rake
 - lib/validators/phone_validator.rb
+- lib/validators/phone_validator3.rb
 homepage: https://github.com/daddyz/phonelib
 licenses:
 - MIT
@@ -168,8 +169,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Gem validates phone numbers with Google libphonenumber database