phonelib 0.6.10 → 0.6.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9c2862f5e9f97af025f8a5beba5a99c68fa24a85
-  data.tar.gz: e1d12a6507f085b7c1ee633e8940cf88dbdd1dab
+  metadata.gz: fa38e795e6d299330a008f39f359cdd29ba221fc
+  data.tar.gz: 9bf8ce164c4838722a06aff72037147852100244
 SHA512:
-  metadata.gz: 4e5cb8d9c464042b48411057ff7367bcb5ed5d3893454469dd65ddd96812e5ada4048883c4eaa49dc8a5d0927125e9ee40b7c9ccc484121c67489b0427858b2b
-  data.tar.gz: e0541b7cf75c20d71a65297263bfa06b6941a6afffd9375aed0968df040e2bb6f2642e650b4535faf15fc54c0c5827ca3957c525c47ee0197eb10877aff6ab03
+  metadata.gz: 61367e9387768b79bbb6d43c5b9718098c4a6772281b24111acd9bce2e6dadcfe08b9aa54aa64e4463b4457e593d4fb08e92da6e15d537dcf083df14d3c5e3f1
+  data.tar.gz: 58ba6833ce8aec90171faacef75b9fbfd865cd236242cb621c4fff26e457b4dc387c49d9e2293c7b9e0d77eac36d8442cbba830f1fe68011fff4539f54374758

data/lib/phonelib/core.rb

@@ -218,23 +218,28 @@ module Phonelib
     # @private Pattern key
     PATTERN = :pattern
 
+    PLUS_SIGN = '+'.freeze
+
+    # @private vanity numbers 4 keys letters
+    VANITY_4_LETTERS_KEYS_REGEX = /[SVYZ]/.freeze
+
     # @private Area code possible types
-    AREA_CODE_TYPES = [FIXED_LINE, FIXED_OR_MOBILE, MOBILE]
+    AREA_CODE_TYPES = [FIXED_LINE, FIXED_OR_MOBILE, MOBILE].freeze
 
     # @private Area code countries for mobile type
-    AREA_CODE_MOBILE_COUNTRIES = %w(AR MX BR)
+    AREA_CODE_MOBILE_COUNTRIES = %w(AR MX BR).freeze
 
     # @private Area code mobile phone token
     AREA_CODE_MOBILE_TOKENS = {
       'MX' => '1',
       'AR' => '9'
-    }
+    }.freeze
 
     # @private Default number formatting data hash
     DEFAULT_NUMBER_FORMAT = {
       pattern: '(\\d+)(\\d{3})(\\d{4})',
       format: '$1 $2 $3'
-    }
+    }.freeze
 
     # @private hash of all phone types with human representation
     TYPES_DESC = {
@@ -261,7 +266,7 @@ module Phonelib
       standard_rate: 'Standard Rate Destination',
       carrier_selection_codes: 'Carrier Selection codes',
       area_code_optional: 'Are code optional'
-    }
+    }.freeze
 
     # @private short codes types keys
     SHORT_CODES = [
@@ -269,7 +274,7 @@ module Phonelib
       :expanded_emergency, :no_international_dialling, :carrier_services,
       :directory_services, :standard_rate, :carrier_selection_codes,
       :area_code_optional
-    ]
+    ].freeze
 
     # @private Extended data prefixes hash key
     EXT_PREFIXES = :prefixes

data/lib/phonelib/data_importer.rb

@@ -58,29 +58,7 @@ module Phonelib
         import_timezone_data
         import_carrier_data
         save_data_file
-      end
-
-      # method saves parsed data to data files
-      def save_data_file
-        data_file =
-            "#{File.dirname(__FILE__)}/../../#{Phonelib::Core::FILE_MAIN_DATA}"
-
-        File.open(data_file, 'wb+') do |f|
-          Marshal.dump(@data, f)
-        end
-
-        ext_file =
-            "#{File.dirname(__FILE__)}/../../#{Phonelib::Core::FILE_EXT_DATA}"
-        extended = {
-          Phonelib::Core::EXT_PREFIXES => @prefixes,
-          Phonelib::Core::EXT_GEO_NAMES => @geo_names,
-          Phonelib::Core::EXT_TIMEZONES => @timezones,
-          Phonelib::Core::EXT_CARRIERS => @carriers
-        }
-        File.open(ext_file, 'wb+') do |f|
-          Marshal.dump(extended, f)
-        end
-        puts 'DATA SAVED'
+        save_extended_data_file
       end
 
       # method clones libphonenumber repo to local dir
@@ -97,10 +75,8 @@ module Phonelib
         puts 'IMPORTING MAIN DATA'
         main_from_xml("#{@destination}#{MAIN_FILE}").elements.each do |el|
           # each country
-          country = get_hash_from_xml(el, :attributes)
-          country[:types] = {}
-
-          country.merge! get_types_and_formats(el.children)
+          country = hash_from_xml(el, :attributes)
+          country.merge! types_and_formats(el.children)
           country = add_double_country_flag country
           @data[country[:id]] = country
         end
@@ -111,17 +87,11 @@ module Phonelib
         puts 'IMPORTING SHORT NUMBER DATA'
         main_from_xml("#{@destination}#{SHORT_DATA_FILE}").elements.each do |el|
           # each country
-          country = get_hash_from_xml(el, :attributes)
-          country[:types] = {}
-
-          country.merge! get_types_and_formats(el.children)
+          country = hash_from_xml(el, :attributes)
+          country.merge! types_and_formats(el.children)
 
           country[:types].each do |type, data|
-            if @data[country[:id]][:types][type]
-              merge_short_with_main_type(country[:id], type, data)
-            else
-              @data[country[:id]][:types][type] = data
-            end
+            merge_short_with_main_type(country[:id], type, data)
           end
         end
       end
@@ -134,10 +104,8 @@ module Phonelib
           el.children.each do |phone_type|
             next unless phone_type.name == 'availableFormats'
 
-            formats = parse_formats(phone_type.children)
-
-            country_code = el.attribute('countryCode').value
-            @data[get_country_by_code(country_code)][:formats] += formats
+            country_code = country_by_code(el.attribute('countryCode').value)
+            @data[country_code][:formats] += parse_formats(phone_type.children)
           end
         end
       end
@@ -175,26 +143,24 @@ module Phonelib
       end
 
       # method extracts formats and types from xml data
-      def get_types_and_formats(children)
-        types = {}
-        formats = []
+      def types_and_formats(children)
+        result = { types: {}, formats: [] }
 
         without_comments(children).each do |phone_type|
           if phone_type.name == 'availableFormats'
-            formats = parse_formats(phone_type.children)
+            result[:formats] = parse_formats(phone_type.children)
           else
-            types[name2sym(phone_type.name)] =
-                get_hash_from_xml(phone_type, :element)
+            result[:types][name2sym(phone_type.name)] =
+                hash_from_xml(phone_type, :element)
           end
         end
 
-        types = add_possible_if_not_exists(types)
-
-        { types: types, formats: formats }
+        fill_possible_to_types_if_nil(result)
       end
 
       # method adds short number patterns to main data parsed from main xml
       def merge_short_with_main_type(country_id, type, data)
+        @data[country_id][:types][type] ||= {}
         data.each do |k, v|
           if @data[country_id][:types][type][k]
             @data[country_id][:types][type][k] += "|#{v}"
@@ -205,20 +171,20 @@ module Phonelib
       end
 
       # adds possible pattern in case it doesn't exists
-      def add_possible_if_not_exists(types)
-        types.each do |type, data|
+      def fill_possible_to_types_if_nil(result)
+        result[:types].each do |type, data|
           if data[Core::VALID_PATTERN] && !data[Core::POSSIBLE_PATTERN]
-            types[type][Core::POSSIBLE_PATTERN] =
+            result[:types][type][Core::POSSIBLE_PATTERN] =
                 data[Core::VALID_PATTERN]
           end
         end
-        types
+        result
       end
 
       # method parses xml for formats data
       def parse_formats(formats_children)
         without_comments(formats_children).map do |format|
-          current_format = get_hash_from_xml(format, :children)
+          current_format = hash_from_xml(format, :children)
 
           without_comments(format.children).each do |f|
             current_format[name2sym(f.name)] =
@@ -226,7 +192,7 @@ module Phonelib
           end
 
           current_format
-        end.compact
+        end
       end
 
       # method updates data from raw files
@@ -245,7 +211,7 @@ module Phonelib
       end
 
       # method finds country by country prefix
-      def get_country_by_code(country_code)
+      def country_by_code(country_code)
         match = @data.select { |_k, v| v[:country_code] == country_code }
         if match.size > 1
           match = match.select { |_k, v| v[:main_country_for_code] == 'true' }

data/lib/phonelib/data_importer_helper.rb

@@ -6,12 +6,38 @@ module Phonelib
     # xml format attributes names
     XML_FORMAT_NAMES = %w(intlFormat format)
 
+    def file_path(file)
+      "#{File.dirname(__FILE__)}/../../#{file}"
+    end
+
+    # method saves parsed data to data files
+    def save_data_file
+      File.open(file_path(Phonelib::Core::FILE_MAIN_DATA), 'wb+') do |f|
+        Marshal.dump(@data, f)
+      end
+    end
+
+    # method saves extended data file
+    def save_extended_data_file
+      extended = {
+        Phonelib::Core::EXT_PREFIXES => @prefixes,
+        Phonelib::Core::EXT_GEO_NAMES => @geo_names,
+        Phonelib::Core::EXT_TIMEZONES => @timezones,
+        Phonelib::Core::EXT_CARRIERS => @carriers
+      }
+      File.open(file_path(Phonelib::Core::FILE_EXT_DATA), 'wb+') do |f|
+        Marshal.dump(extended, f)
+      end
+      puts 'DATA SAVED'
+    end
+
     # method updates prefixes hash recursively
     def fill_prefixes(key, value, prefix, prefixes)
       prefixes = {} if prefixes.nil?
       if prefix.size == 1
-        prefixes[prefix.to_i] = {} unless prefixes[prefix.to_i]
-        prefixes[prefix.to_i][key] = value
+        pr = prefix.to_i
+        prefixes[pr] ||= {}
+        prefixes[pr][key] = value
       else
         pr = prefix[0].to_i
         prefixes[pr] = fill_prefixes(key, value, prefix[1..-1], prefixes[pr])
@@ -32,7 +58,7 @@ module Phonelib
     end
 
     # method creates hash from xml elements/element attributes
-    def get_hash_from_xml(data, type)
+    def hash_from_xml(data, type)
       hash = {}
       case type
       when :attributes

data/lib/phonelib/phone.rb

@@ -42,20 +42,20 @@ module Phonelib
     def sanitized
       @sanitized ||=
           vanity_converted(@original).gsub(
-              Phonelib.strict_check ? /^\+/.freeze : /[^0-9]+/.freeze,
+              Phonelib.strict_check ? cr('^\+') : cr('[^0-9]+'),
               '')
     end
 
     # Returns all phone types that matched valid patterns
     # @return [Array] all valid phone types
     def types
-      @data.flat_map { |_iso2, data| data[:valid] }.uniq
+      @types ||= @data.flat_map { |_iso2, data| data[:valid] }.uniq
     end
 
     # Returns all possible types that matched possible patterns
     # @return [Array] all possible phone types
     def possible_types
-      @data.flat_map { |_iso2, data| data[:possible] }.uniq
+      @possible_types ||= @data.flat_map { |_iso2, data| data[:possible] }.uniq
     end
 
     # Returns first phone type that matched
@@ -105,7 +105,7 @@ module Phonelib
     # Returns whether a current parsed phone number is valid
     # @return [Boolean] parsed phone is valid
     def valid?
-      @data.select { |_iso2, data| data[:valid].any? }.any?
+      @valid ||= @data.select { |_iso2, data| data[:valid].any? }.any?
     end
 
     # Returns whether a current parsed phone number is invalid
@@ -117,7 +117,7 @@ module Phonelib
     # Returns whether a current parsed phone number is possible
     # @return [Boolean] parsed phone is possible
     def possible?
-      @data.select { |_iso2, data| data[:possible].any? }.any?
+      @possible ||= @data.select { |_iso2, data| data[:possible].any? }.any?
     end
 
     # Returns whether a current parsed phone number is impossible

data/lib/phonelib/phone_analyzer.rb

@@ -18,16 +18,16 @@ module Phonelib
     def analyze(phone, passed_country)
       country = country_or_default_country passed_country
 
-      result = try_to_parse_country(phone, country)
+      result = parse_country(phone, country)
       d_result = case
-                 when result && result.values.find {|e| e[:valid].any? }
+                 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
-                 when !original_string.start_with?('+') && country_can_double_prefix?(country)
+                 when country_can_dp?(country)
                    # if country allows double prefix trying modified phone
-                   try_to_parse_country(changed_double_prefixed_phone(country, phone), country)
+                   parse_country(changed_dp_phone(country, phone), country)
                  end
       better_result(result, d_result)
     end
@@ -36,19 +36,14 @@ module Phonelib
 
     # method checks which result is better to return
     def better_result(base_result, result = nil)
-      if result.nil?
-        return base_result || {}
-      end
+      base_result ||= {}
+      return base_result unless result
 
-      if base_result.nil? || base_result.empty? || base_result.values.find {|e| e[:possible].any? }.nil?
-        return result
-      end
+      return result unless base_result.values.find { |e| e[:possible].any? }
 
-      if result && result.values.find {|e| e[:valid].any? }
-        return result
-      end
+      return result if result.values.find { |e| e[:valid].any? }
 
-      base_result || {}
+      base_result
     end
 
     # trying to parse phone for single country including international prefix
@@ -58,9 +53,9 @@ module Phonelib
     #
     # * +phone+ - phone for parsing
     # * +country+ - country to parse phone with
-    def try_to_parse_country(phone, country)
+    def parse_country(phone, country)
       data = Phonelib.phone_data[country]
-      return nil unless country && data
+      return nil unless data
 
       # if country was provided and it's a valid country, trying to
       # create e164 representation of phone number,
@@ -69,7 +64,7 @@ module Phonelib
       # 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] == '+'
+      return analyze(e164[1..-1], nil) if Core::PLUS_SIGN == e164[0]
       # trying to parse number for provided country
       parse_single_country e164, data
     end
@@ -83,10 +78,10 @@ module Phonelib
     def parse_single_country(e164, data)
       valid_match = phone_match_data?(e164, data)
       if valid_match
-        national_and_data(e164, data, valid_match)
+        national_and_data(data, valid_match)
       else
         possible_match = phone_match_data?(e164, data, true)
-        possible_match && national_and_data(e164, data, possible_match, true)
+        possible_match && national_and_data(data, possible_match, true)
       end
     end
 
@@ -100,7 +95,7 @@ module Phonelib
       Phonelib.phone_data.each do |key, data|
         parsed = parse_single_country(phone, data)
         if double_prefix_allowed?(data, phone, parsed && parsed[key])
-          parsed = parse_single_country(changed_double_prefixed_phone(key, phone), data)
+          parsed = parse_single_country(changed_dp_phone(key, phone), data)
         end
         result.merge!(parsed) unless parsed.nil?
       end
@@ -114,13 +109,14 @@ module Phonelib
     # * +phone+ - phone number for parsing
     # * +data+  - country data to be based on for creating e164 representation
     def convert_to_e164(phone, data)
-      match = phone.match full_regex_for_data(data, Core::VALID_PATTERN)
+      match = phone.match full_regex_for_data(data, Core::VALID_PATTERN, !original_starts_with_plus?)
       case
       when match
-        national_start = phone.length - match.to_a.last.size
-        "#{data[Core::COUNTRY_CODE]}#{phone[national_start..-1]}"
+        "#{data[Core::COUNTRY_CODE]}#{match.to_a.last}"
       when phone.match(cr("^#{data[Core::INTERNATIONAL_PREFIX]}"))
-        phone.sub(cr("^#{data[Core::INTERNATIONAL_PREFIX]}"), '+')
+        phone.sub(cr("^#{data[Core::INTERNATIONAL_PREFIX]}"), Core::PLUS_SIGN)
+      when original_starts_with_plus? && phone.start_with?(data[Core::COUNTRY_CODE])
+        phone
       else
         "#{data[Core::COUNTRY_CODE]}#{phone}"
       end
@@ -130,18 +126,15 @@ module Phonelib
     #
     # ==== Attributes
     #
-    # * +phone+ - phone number for parsing
     # * +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 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(:+)
+    def national_and_data(data, country_match, not_valid = false)
       result = data.select { |k, _v| k != :types && k != :formats }
-      result[:national] = phone[prefix_length..-1] || ''
-      result[:format] = number_format(result[:national], data[Core::FORMATS])
-      result.merge! all_number_types(result[:national], data[Core::TYPES],
-                                     not_valid)
+      phone = country_match.to_a.last
+      result[:national] = phone
+      result[:format] = number_format(phone, data[Core::FORMATS])
+      result.merge! all_number_types(phone, data[Core::TYPES], not_valid)
       result[:valid] = [] if not_valid
 
       { result[:id] => result }
@@ -178,9 +171,9 @@ module Phonelib
     # * +format_data+  - formatting data from country 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::PATTERN]})$"))
+        (format[Core::LEADING_DIGITS].nil? || \
+            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

@@ -3,24 +3,28 @@ module Phonelib
   module PhoneAnalyzerHelper
     private
 
+    def original_starts_with_plus?
+      original_s[0] == Core::PLUS_SIGN
+    end
+
+    # converts symbols in phone to numbers
     def vanity_converted(phone)
       return phone unless Phonelib.vanity_conversion
 
-      (phone || '').gsub(/[a-z]/i.freeze) do |c|
+      (phone || '').gsub(cr('[a-zA-Z]')) do |c|
         c.upcase!
         # subtract "A"
         n = (c.ord - 65) / 3
         # account for #7 & #9 which have 4 chars
-        n -= 1 if c == 'S'.freeze || c == 'V'.freeze || c >= 'Y'.freeze
+        n -= 1 if c.match(Core::VANITY_4_LETTERS_KEYS_REGEX)
         (n + 2).to_s
       end
     end
 
-
     # defines if to validate against single country or not
     def passed_country(country)
       code = country_prefix(country)
-      if @original.start_with?('+') && code && !sanitized.start_with?(code)
+      if Core::PLUS_SIGN == @original[0] && code && !sanitized.start_with?(code)
         # in case number passed with + but it doesn't start with passed
         # country prefix
         country = nil
@@ -37,17 +41,18 @@ module Phonelib
 
     # caches regular expression, reusing it for later lookups
     def cr(regexp)
-      Phonelib.phone_regexp_cache[regexp] ||= Regexp.new(regexp)
+      Phonelib.phone_regexp_cache[regexp] ||= Regexp.new(regexp).freeze
     end
 
     # defines whether country can have double country prefix in number
-    def country_can_double_prefix?(country)
+    def country_can_dp?(country)
       Phonelib.phone_data[country] &&
-        Phonelib.phone_data[country][Core::DOUBLE_COUNTRY_PREFIX_FLAG]
+        Phonelib.phone_data[country][Core::DOUBLE_COUNTRY_PREFIX_FLAG] &&
+        !original_starts_with_plus?
     end
 
     # changes phone to with/without double country prefix
-    def changed_double_prefixed_phone(country, phone)
+    def changed_dp_phone(country, phone)
       data = Phonelib.phone_data[country]
       return if data.nil? || data[Core::DOUBLE_COUNTRY_PREFIX_FLAG].nil?
 
@@ -67,14 +72,15 @@ module Phonelib
     # * +phone+ - phone number being parsed
     # * +parsed+ - parsed regex match for phone
     def double_prefix_allowed?(data, phone, parsed = {})
-      data && data[Core::DOUBLE_COUNTRY_PREFIX_FLAG] &&
+      data[Core::DOUBLE_COUNTRY_PREFIX_FLAG] &&
         phone =~ cr("^#{data[Core::COUNTRY_CODE]}") &&
-        parsed && (parsed[:valid].nil? || parsed[:valid].empty?)
+        parsed && (parsed[:valid].nil? || parsed[:valid].empty?) &&
+        !original_starts_with_plus?
     end
 
     # Returns original number passed if it's a string or empty string otherwise
-    def original_string
-      @original.is_a?(String) ? @original : ''
+    def original_s
+      @original_s ||= @original.is_a?(String) ? @original : ''
     end
 
     # Get country that was provided or default country in needable format
@@ -83,7 +89,7 @@ module Phonelib
     #
     # * +country+ - country passed for parsing
     def country_or_default_country(country)
-      country ||= (original_string.start_with?('+') ? nil : Phonelib.default_country)
+      country ||= (original_starts_with_plus? ? nil : Phonelib.default_country)
       country && country.to_s.upcase
     end
 
@@ -97,11 +103,7 @@ module Phonelib
     def full_regex_for_data(data, type, country_optional = true)
       regex = []
       regex << "(#{data[Core::INTERNATIONAL_PREFIX]})?"
-      regex << if country_optional
-                 "(#{data[Core::COUNTRY_CODE]})?"
-               else
-                 data[Core::COUNTRY_CODE]
-               end
+      regex << "(#{data[Core::COUNTRY_CODE]})#{country_optional ? '?' : ''}"
       regex << "(#{data[Core::NATIONAL_PREFIX_FOR_PARSING] || data[Core::NATIONAL_PREFIX]})?"
       regex << "(#{data[Core::TYPES][Core::GENERAL][type]})"
 
@@ -165,22 +167,27 @@ module Phonelib
     # ==== Attributes
     #
     # * +number+ - phone number for validation
-    # * +possible_pattern+ - possible pattern for validation
-    # * +national_pattern+ - valid pattern for validation
+    # * +p_regex+ - possible regex pattern for validation
+    # * +v_regex+ - valid regex pattern for validation
     # * +not_valid+ - specifies that number is not valid by general desc pattern
-    def number_valid_and_possible?(number, possible_pattern, national_pattern, not_valid = false)
-      possible_match = number.match(cr("^(?:#{possible_pattern})$"))
-      possible = possible_match && possible_match.to_s.length == number.length
-
-      return [!not_valid && possible, possible] if possible_pattern == national_pattern
-      valid = false
-      if !not_valid && possible
-        # doing national pattern match only in case possible matches
-        national_match = number.match(cr("^(?:#{national_pattern})$"))
-        valid = national_match && national_match.to_s.length == number.length
-      end
+    def number_valid_and_possible?(number, p_regex, v_regex, not_valid = false)
+      possible = number_match?(number, p_regex)
+
+      return [!not_valid && possible, possible] if p_regex == v_regex
+      valid = !not_valid && possible && number_match?(number, v_regex)
 
       [valid && possible, possible]
     end
+
+    # Checks number against regex and compares match length
+    #
+    # ==== Attributes
+    #
+    # * +number+ - phone number for validation
+    # * +regex+ - regex for perfoming a validation
+    def number_match?(number, regex)
+      match = number.match(cr("^(?:#{regex})$"))
+      match && match.to_s.length == number.length
+    end
   end
 end

data/lib/phonelib/phone_formatter.rb

@@ -32,24 +32,23 @@ module Phonelib
     # 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]
+      @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 nil if sanitized.empty?
       return "+#{country_prefix_or_not}#{sanitized}" unless valid?
-      return "#{country_code}#{@national_number}" unless formatted
+      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]
+      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] }
-      else
-        national = @national_number
       end
 
       "+#{country_code} #{national}"
@@ -88,7 +87,7 @@ module Phonelib
       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]
+         format_match[1] == Core::AREA_CODE_MOBILE_TOKENS[country]
         take_group = 2
       end
       format_match[take_group]
@@ -98,7 +97,7 @@ module Phonelib
 
     # @private defines if phone can have area code
     def area_code_possible?
-      return false unless possible?
+      return false if impossible?
 
       # has national prefix
       return false unless @data[country][Core::NATIONAL_PREFIX] || country == 'IT'
@@ -126,10 +125,11 @@ module Phonelib
     def formatting_data
       return @formatting_data if defined?(@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')
+      data = @data[country]
+      format = data[:format]
+      prefix = data[Core::NATIONAL_PREFIX]
+      rule = format[Core::NATIONAL_PREFIX_RULE] ||
+             data[Core::NATIONAL_PREFIX_RULE] || '$1'
 
       # change rule's constants to values
       rule.gsub!(/(\$NP|\$FG)/, '$NP' => prefix, '$FG' => '$1')

data/lib/phonelib/version.rb

@@ -1,4 +1,4 @@
 module Phonelib
   # @private
-  VERSION = '0.6.10'
+  VERSION = '0.6.11'
 end

data/lib/validators/phone_validator.rb

@@ -43,21 +43,32 @@ class PhoneValidator < ActiveModel::EachValidator
   # Validation method
   def validate_each(record, attribute, value)
     return if options[:allow_blank] && value.blank?
-    country = options[:country_specifier].call(record) if options[:country_specifier]
 
-    phone = parse(value, country)
+    phone = parse(value, specified_country(record))
     valid = if simple_validation?
-              method = options[:possible] ? :possible? : :valid?
-              phone.send(method)
+              phone.send(validate_method)
             else
               (phone_types(phone) & types).size > 0
             end
 
-    record.errors.add(attribute, options[:message] || :invalid, options) unless valid
+    record.errors.add(attribute, message, options) unless valid
   end
 
   private
 
+  def message
+    options[:message] || :invalid
+  end
+
+  def validate_method
+    options[:possible] ? :possible? : :valid?
+  end
+
+  def specified_country(record)
+    return unless options[:country_specifier]
+    options[:country_specifier].call(record)
+  end
+
   # @private
   def simple_validation?
     options[:types].nil?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phonelib
 version: !ruby/object:Gem::Version
-  version: 0.6.10
+  version: 0.6.11
 platform: ruby
 authors:
 - Vadim Senderovich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-01 00:00:00.000000000 Z
+date: 2017-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake