phonelib 0.6.2 → 0.6.3

data/lib/phonelib/phone_analyzer.rb

@@ -1,5 +1,5 @@
 module Phonelib
-  # phone analyzing methods module
+  # @private phone analyzing methods module
   module PhoneAnalyzer
     # extending with helper methods for analyze
     include Phonelib::PhoneAnalyzerHelper
@@ -7,8 +7,8 @@ module Phonelib
     # array of types not included for validation check in cycle
     NOT_FOR_CHECK = [:general_desc, :fixed_line, :mobile, :fixed_or_mobile]
 
-    # parses provided phone if it is valid for  country data and returns result of
-    # analyze
+    # parses provided phone if it is valid for  country data and
+    # returns result of analyze
     #
     # ==== Attributes
     #
@@ -20,7 +20,9 @@ module Phonelib
 
       result = try_to_parse_single_country(phone, country)
       # if previous parsing failed, trying for all countries
-      if passed_country.nil? && (result.nil? || result.empty? || result.values.first[:valid].empty?)
+      if passed_country.nil? && \
+        (result.nil? || result.empty? || result.values.first[:valid].empty?)
+
         detected = detect_and_parse phone
         result = detected.empty? ? result || {} : detected
       end
@@ -38,18 +40,18 @@ module Phonelib
     # * +country+ - country to parse phone with
     def try_to_parse_single_country(phone, country)
       data = Phonelib.phone_data[country]
-      if country && data
-        # if country was provided and it's a valid country, trying to
-        # create e164 representation of phone number,
-        # kind of normalization for parsing
-        e164 = convert_to_e164 phone, data
-        # if phone starts with international prefix of provided
-        # country try to reanalyze without international prefix for
-        # all countries
-        return analyze(e164.gsub('+', ''), nil) if e164[0] == '+'
-        # trying to parse number for provided country
-        parse_single_country e164, data
-      end
+      return nil unless country && data
+
+      # if country was provided and it's a valid country, trying to
+      # create e164 representation of phone number,
+      # kind of normalization for parsing
+      e164 = convert_to_e164 phone, data
+      # if phone starts with international prefix of provided
+      # country try to reanalyze without international prefix for
+      # all countries
+      return analyze(e164.delete('+'), nil) if e164[0] == '+'
+      # trying to parse number for provided country
+      parse_single_country e164, data
     end
 
     # method checks if phone is valid against single provided country data
@@ -61,10 +63,10 @@ module Phonelib
     def parse_single_country(e164, data)
       valid_match = phone_match_data?(e164, data)
       if valid_match
-        get_national_and_data(e164, data, valid_match)
+        national_and_data(e164, data, valid_match)
       else
         possible_match = phone_match_data?(e164, data, true)
-        possible_match && get_national_and_data(e164, data, possible_match, true)
+        possible_match && national_and_data(e164, data, possible_match, true)
       end
     end
 
@@ -112,14 +114,14 @@ module Phonelib
     # * +data+ - country data
     # * +country_match+ - result of match of phone within full regex
     # * +not_valid+ - specifies that number is not valid by general desc pattern
-    def get_national_and_data(phone, data, country_match, not_valid = false)
+    def national_and_data(phone, data, country_match, not_valid = false)
       prefix_length = data[Core::COUNTRY_CODE].length
       prefix_length += [1, 2].map { |i| country_match[i].to_s.size }.inject(:+)
-      result = data.select { |k, v| k != :types && k != :formats }
+      result = data.select { |k, _v| k != :types && k != :formats }
       result[:national] = phone[prefix_length..-1] || ''
-      result[:format] = get_number_format(result[:national],
-                                          data[Core::FORMATS])
-      result.merge! all_number_types(result[:national], data[Core::TYPES], not_valid)
+      result[:format] = number_format(result[:national], data[Core::FORMATS])
+      result.merge! all_number_types(result[:national], data[Core::TYPES],
+                                     not_valid)
       result[:valid] = [] if not_valid
 
       { result[:id] => result }
@@ -154,10 +156,10 @@ module Phonelib
     #
     # * +national+ - national phone number
     # * +format_data+  - formatting data from country data
-    def get_number_format(national, format_data)
+    def number_format(national, format_data)
       format_data && format_data.find do |format|
         (format[Core::LEADING_DIGITS].nil? \
-            || national.match(cr("^(#{format[Core::LEADING_DIGITS]})"))) \
+          || national.match(cr("^(#{format[Core::LEADING_DIGITS]})"))) \
         && national.match(cr("^(#{format[Core::PATTERN]})$"))
       end || Core::DEFAULT_NUMBER_FORMAT
     end

data/lib/phonelib/phone_analyzer_helper.rb

@@ -1,13 +1,14 @@
 module Phonelib
-  # helper methods for analyser
+  # @private helper methods for analyser
   module PhoneAnalyzerHelper
     private
 
     # defines if to validate against single country or not
     def passed_country(country)
-      country_code = country_prefix(country)
-      if @original.start_with?('+') && country_code && !sanitized.start_with?(country_code)
-        # in case number passed with + but it doesn't start with passed country prefix
+      code = country_prefix(country)
+      if @original.start_with?('+') && code && !sanitized.start_with?(code)
+        # in case number passed with + but it doesn't start with passed
+        # country prefix
         country = nil
       end
       country
@@ -16,7 +17,8 @@ module Phonelib
     # returns country prefix for provided country or nil
     def country_prefix(country)
       country = country.to_s.upcase
-      Phonelib.phone_data[country] && Phonelib.phone_data[country][Core::COUNTRY_CODE]
+      Phonelib.phone_data[country] && \
+        Phonelib.phone_data[country][Core::COUNTRY_CODE]
     end
 
     # caches regular expression, reusing it for later lookups
@@ -33,8 +35,13 @@ module Phonelib
     # * +parsed+ - parsed regex match for phone
     def allows_double_prefix(data, phone, parsed)
       data[Core::DOUBLE_COUNTRY_PREFIX_FLAG] &&
-          phone =~ cr("^#{data[Core::COUNTRY_CODE]}") &&
-          parsed && (parsed[:valid].nil? || parsed[:valid].empty?)
+        phone =~ cr("^#{data[Core::COUNTRY_CODE]}") &&
+        parsed && (parsed[:valid].nil? || parsed[:valid].empty?)
+    end
+
+    # Returns original number passed if it's a string or empty string otherwise
+    def original_string
+      @original.is_a?(String) ? @original : ''
     end
 
     # Get country that was provided or default country in needable format
@@ -43,7 +50,7 @@ module Phonelib
     #
     # * +country+ - country passed for parsing
     def country_or_default_country(country)
-      country = country || Phonelib.default_country
+      country ||= (original_string.start_with?('+') ? nil : Phonelib.default_country)
       country && country.to_s.upcase
     end
 
@@ -143,4 +150,4 @@ module Phonelib
       [valid && possible, possible]
     end
   end
-end
+end

data/lib/phonelib/phone_extended_data.rb

@@ -1,8 +1,16 @@
 module Phonelib
   # module provides extended data methods for parsed phone
   module PhoneExtendedData
+    # @private keys for extended data
+    EXT_KEYS = [
+      Phonelib::Core::EXT_GEO_NAME_KEY,
+      Phonelib::Core::EXT_TIMEZONE_KEY,
+      Phonelib::Core::EXT_CARRIER_KEY
+    ]
+
     # Returns geo name of parsed phone number or nil if number is invalid or
     # there is no geo name specified in db for this number
+    # @return [String|nil] geo name for parsed phone
     def geo_name
       get_ext_name Phonelib::Core::EXT_GEO_NAMES,
                    Phonelib::Core::EXT_GEO_NAME_KEY
@@ -10,6 +18,7 @@ module Phonelib
 
     # Returns timezone of parsed phone number or nil if number is invalid or
     # there is no timezone specified in db for this number
+    # @return [String|nil] timezone for parsed phone
     def timezone
       get_ext_name Phonelib::Core::EXT_TIMEZONES,
                    Phonelib::Core::EXT_TIMEZONE_KEY
@@ -17,6 +26,7 @@ module Phonelib
 
     # Returns carrier of parsed phone number or nil if number is invalid or
     # there is no carrier specified in db for this number
+    # @return [String|nil] carrier for parsed phone
     def carrier
       get_ext_name Phonelib::Core::EXT_CARRIERS,
                    Phonelib::Core::EXT_CARRIER_KEY
@@ -24,7 +34,7 @@ module Phonelib
 
     private
 
-    # get name from extended phone data by keys
+    # @private get name from extended phone data by keys
     #
     # ==== Attributes
     #
@@ -32,37 +42,37 @@ module Phonelib
     # * +id_key+   - parameter id key in resolved extended data for number
     #
     def get_ext_name(names_key, id_key)
-      if ext_data[id_key] > 0
-        res = Phonelib.phone_ext_data[names_key][ext_data[id_key]]
-        res.size == 1 ? res.first : res
-      end
+      return nil unless ext_data[id_key] > 0
+
+      res = Phonelib.phone_ext_data[names_key][ext_data[id_key]]
+      res.size == 1 ? res.first : res
     end
 
-    # returns extended data ids for current number
+    # @private returns extended data ids for current number
     def ext_data
       return @ext_data if @ext_data
 
-      ext_keys = [
-          Phonelib::Core::EXT_GEO_NAME_KEY,
-          Phonelib::Core::EXT_TIMEZONE_KEY,
-          Phonelib::Core::EXT_CARRIER_KEY
-      ]
-      result = {}
-      ext_keys.each { |key| result[key] = 0 }
-
+      result = default_ext_data
       return result unless possible?
 
       drill = Phonelib.phone_ext_data[Phonelib::Core::EXT_PREFIXES]
 
-      e164.gsub('+', '').each_char do |num|
+      e164.delete('+').each_char do |num|
         drill = drill[num.to_i] || break
 
-        ext_keys.each do |key|
+        EXT_KEYS.each do |key|
           result[key] = drill[key] if drill[key]
         end
       end
 
       @ext_data = result
     end
+
+    # @private default extended data
+    def default_ext_data
+      result = {}
+      EXT_KEYS.each { |key| result[key] = 0 }
+      result
+    end
   end
-end
+end

data/lib/phonelib/phone_formatter.rb

@@ -0,0 +1,131 @@
+module Phonelib
+  # module includes all formatting methods
+  module PhoneFormatter
+    # Returns formatted national number
+    # @param formatted [Boolean] whether to return numbers only or formatted
+    # @return [String] formatted national number
+    def national(formatted = true)
+      return @national_number unless valid?
+      format_match, format_string = formatting_data
+
+      if format_match
+        out = format_string.gsub(/\$\d/) { |el| format_match[el[1].to_i] }
+        formatted ? out : out.gsub(/[^0-9]/, '')
+      else
+        @national_number
+      end
+    end
+
+    # Returns the country code from the original phone number.
+    # @return [String] matched country phone code
+    def country_code
+      Phonelib.phone_data[country] && \
+        Phonelib.phone_data[country][Core::COUNTRY_CODE]
+    end
+
+    # Returns e164 formatted phone number
+    # @param formatted [Boolean] whether to return numbers only or formatted
+    # @return [String] formatted international number
+    def international(formatted = true)
+      return nil if sanitized.nil? || sanitized.empty?
+      return "+#{country_prefix_or_not}#{sanitized}" unless valid?
+      return "#{country_code}#{@national_number}" unless formatted
+
+      format = @data[country][:format]
+      if (matches = @national_number.match(/#{format[Core::PATTERN]}/))
+        fmt = format[:intl_format] || format[:format]
+        national = fmt.gsub(/\$\d/) { |el| matches[el[1].to_i] }
+      else
+        national = @national_number
+      end
+
+      "+#{country_code} #{national}"
+    end
+
+    # returns national formatted number with extension added
+    # @return [String] formatted national number with extension
+    def full_national
+      "#{national}#{formatted_extension}"
+    end
+
+    # returns international formatted number with extension added
+    # @return [String] formatted internation phone number with extension
+    def full_international
+      "#{international}#{formatted_extension}"
+    end
+
+    # returns e164 format of phone with extension added
+    # @return [String] phone formatted in E164 format with extension
+    def full_e164
+      "#{e164}#{formatted_extension}"
+    end
+
+    # Returns e164 unformatted phone number
+    # @return [String] phone formatted in E164 format
+    def e164
+      international = self.international
+      international && international.gsub(/[^+0-9]/, '')
+    end
+
+    # returns area code of parsed number
+    # @return [String|nil] parsed phone area code if available
+    def area_code
+      return nil unless area_code_possible?
+
+      format_match, _format_string = formatting_data
+      take_group = 1
+      if type == Core::MOBILE && Core::AREA_CODE_MOBILE_TOKENS[country] && \
+        format_match[1] == Core::AREA_CODE_MOBILE_TOKENS[country]
+        take_group = 2
+      end
+      format_match[take_group]
+    end
+
+    private
+
+    # @private defines if phone can have area code
+    def area_code_possible?
+      return false unless possible?
+
+      # has national prefix
+      return false unless @data[country][Core::NATIONAL_PREFIX] || country == 'IT'
+      # fixed or mobile
+      return false unless Core::AREA_CODE_TYPES.include?(type)
+      # mobile && mexico, argentina, brazil
+      return false if type == Core::MOBILE && !Core::AREA_CODE_MOBILE_COUNTRIES.include?(country)
+      true
+    end
+
+    # @private defines whether to put country prefix or not
+    def country_prefix_or_not
+      return '' unless country_code
+      sanitized.start_with?(country_code) ? '' : country_code
+    end
+
+    # @private returns extension with separator defined
+    def formatted_extension
+      return '' if @extension.nil? || @extension.empty?
+
+      "#{Phonelib.extension_separator}#{@extension}"
+    end
+
+    # @private Get needable data for formatting phone as national number
+    def formatting_data
+      return @formatting_data if @formatting_data
+
+      format = @data[country][:format]
+      prefix = @data[country][Core::NATIONAL_PREFIX]
+      rule = (format[Core::NATIONAL_PREFIX_RULE] ||
+          @data[country][Core::NATIONAL_PREFIX_RULE] || '$1')
+
+      # change rule's constants to values
+      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)
+
+      @formatting_data =
+          [@national_number.match(/#{format[Core::PATTERN]}/), format_string]
+    end
+  end
+end

data/lib/phonelib/version.rb

@@ -1,5 +1,4 @@
-# :nodoc:
 module Phonelib
-  # :nodoc:
-  VERSION = '0.6.2'
+  # @private
+  VERSION = '0.6.3'
 end

data/lib/tasks/phonelib_tasks.rake

@@ -1,5 +1,4 @@
 namespace :phonelib do
-
   desc 'Create database for tests in Rails dummy application'
   task :create_test_db do
     exit unless defined? Rails
@@ -13,5 +12,4 @@ namespace :phonelib do
     require 'phonelib/data_importer'
     Phonelib::DataImporter.import
   end
-
 end

data/lib/validators/phone_validator.rb

@@ -36,7 +36,6 @@
 #     validates :mobile, phone: { possible: true, types: :mobile  }
 #   end
 #
-
 class PhoneValidator < ActiveModel::EachValidator
   # Include all core methods
   include Phonelib::Core
@@ -46,26 +45,37 @@ class PhoneValidator < ActiveModel::EachValidator
     return if options[:allow_blank] && value.blank?
 
     phone = parse(value)
-    if options[: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
-      valid = (phone_types & types).size > 0
-    else
-      method = options[:possible] ? :possible? : :valid?
-      valid = phone.send(method)
-    end
+    valid = if simple_validation?
+              method = options[:possible] ? :possible? : :valid?
+              phone.send(method)
+            else
+              (phone_types(phone) & types).size > 0
+            end
 
     record.errors.add(attribute, options[:message] || :invalid) unless valid
   end
 
   private
 
+  # @private
+  def simple_validation?
+    options[:types].nil?
+  end
+
+  # @private
+  # @param phone [Phonelib::Phone] parsed phone
+  def phone_types(phone)
+    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 types
     types = options[:types].is_a?(Array) ? options[:types] : [options[:types]]
-    types.map &:to_sym
+    types.map(&:to_sym)
   end
-
 end