telephone_number 0.1.0 → 0.2.0

data/lib/telephone_number/class_methods.rb

@@ -7,5 +7,9 @@ module TelephoneNumber
     def valid?(number, country, keys = [])
       parse(number, country).valid?(keys)
     end
+
+    def invalid?(*args)
+      !valid?(*args)
+    end
   end
 end

data/lib/telephone_number/data_importer.rb

@@ -28,19 +28,29 @@ module TelephoneNumber
     private
 
     def load_formats(country_data, territory)
-      country_data[TelephoneNumber::PhoneData::FORMATS] = territory.css("availableFormats numberFormat").map do |format|
+      country_data[PhoneData::FORMATS] = territory.css("availableFormats numberFormat").map do |format|
         format_hash = {}.tap do |fhash|
-          format.attributes.values.each { |attr| fhash[attr.name.to_sym] = attr.value.delete("\n ") }
-          format.elements.each { |child| fhash[child.name.to_sym] = child.text.delete("\n ") }
+          format.attributes.values.each do |attr|
+            key = underscore(attr.name).to_sym
+            fhash[key] = if key == PhoneData::NATIONAL_PREFIX_FORMATTING_RULE
+                            attr.value
+                          else
+                            attr.value.delete("\n ")
+                          end
+          end
+          format.elements.each do |child|
+            key = underscore(child.name).to_sym
+            fhash[key] = [PhoneData::FORMAT, PhoneData::INTL_FORMAT].include?(key) ? child.text : child.text.delete("\n ")
+          end
         end
       end
     end
 
     def load_validations(country_data, territory)
-      country_data[TelephoneNumber::PhoneData::VALIDATIONS] = {}
+      country_data[PhoneData::VALIDATIONS] = {}
       territory.elements.each do |element|
         next if element.name == "references" || element.name == "availableFormats"
-        country_data[TelephoneNumber::PhoneData::VALIDATIONS][underscore(element.name).to_sym] = {}.tap do |validation_hash|
+        country_data[PhoneData::VALIDATIONS][underscore(element.name).to_sym] = {}.tap do |validation_hash|
           element.elements.each{|child| validation_hash[underscore(child.name).to_sym] = child.text.delete("\n ")}
         end
       end
@@ -48,7 +58,12 @@ module TelephoneNumber
 
     def load_base_attributes(country_data, territory)
       territory.attributes.each do |key, value_object|
-        country_data[underscore(key).to_sym] = value_object.value
+        underscored_key = underscore(key).to_sym
+        country_data[underscored_key] = if  underscored_key == PhoneData::NATIONAL_PREFIX_FOR_PARSING
+                                          value_object.value.delete("\n ")
+                                        else
+                                          value_object.value
+                                        end
       end
     end
 

data/lib/telephone_number/formatter.rb

@@ -0,0 +1,60 @@
+module TelephoneNumber
+  module Formatter
+    def build_national_number(formatted: true)
+      return normalized_number if !valid? || format.nil?
+      captures = normalized_number.match(Regexp.new(format[PhoneData::PATTERN])).captures
+      national_prefix_formatting_rule = format[PhoneData::NATIONAL_PREFIX_FORMATTING_RULE] \
+                                         || country_data[PhoneData::NATIONAL_PREFIX_FORMATTING_RULE]
+
+      format_string = format[PhoneData::FORMAT].gsub(/(\$\d)/) { |cap| "%#{cap.reverse}s" }
+      formatted_string = sprintf(format_string, *captures)
+      captures.delete(PhoneData::MOBILE_TOKEN_COUNTRIES[country])
+
+      if national_prefix_formatting_rule
+        national_prefix_string = national_prefix_formatting_rule.dup
+        national_prefix_string.gsub!(/\$NP/, country_data[PhoneData::NATIONAL_PREFIX])
+        national_prefix_string.gsub!(/\$FG/, captures[0])
+        formatted_string.sub!(captures[0], national_prefix_string)
+      end
+
+      formatted ? formatted_string : sanitize(formatted_string)
+    end
+
+    def build_e164_number(formatted: true)
+      formatted_string = "+#{country_data[PhoneData::COUNTRY_CODE]}#{normalized_number}"
+      formatted ? formatted_string : sanitize(formatted_string)
+    end
+
+    def build_international_number(formatted: true)
+      return normalized_number if !valid? || format.nil?
+      captures = normalized_number.match(Regexp.new(format[PhoneData::PATTERN])).captures
+      key = format.fetch(PhoneData::INTL_FORMAT, 'NA') != 'NA' ? PhoneData::INTL_FORMAT : PhoneData::FORMAT
+      format_string = format[key].gsub(/(\$\d)/) { |cap| "%#{cap.reverse}s" }
+      "+#{country_data[PhoneData::COUNTRY_CODE]} #{sprintf(format_string, *captures)}"
+    end
+
+    private
+
+    def extract_format
+      native_country_format = detect_format(country.to_sym)
+      return native_country_format if native_country_format
+
+      # This means we couldn't find an applicable format so we now need to scan through the hierarchy
+      parent_country_code = PhoneData.phone_data.detect do |country_code, country_data|
+        country_data[PhoneData::COUNTRY_CODE] == PhoneData.phone_data[self.country.to_sym][PhoneData::COUNTRY_CODE] \
+          && country_data[PhoneData::MAIN_COUNTRY_FOR_CODE] == 'true'
+      end
+      detect_format(parent_country_code[0])
+    end
+
+    def detect_format(country_code)
+      PhoneData.phone_data[country_code.to_sym][PhoneData::FORMATS].detect do |format|
+        (format[PhoneData::LEADING_DIGITS].nil? \
+          || normalized_number =~ Regexp.new("^(#{format[PhoneData::LEADING_DIGITS]})")) \
+          && normalized_number =~ Regexp.new("^(#{format[PhoneData::PATTERN]})$")
+      end
+    end
+  end
+end
+
+

data/lib/telephone_number/number.rb

@@ -1,27 +1,59 @@
 module TelephoneNumber
   class Number
     include TelephoneNumber::Parser
+    include TelephoneNumber::Formatter
 
-    attr_reader :original_number, :country, :e164_number, :national_number
+    attr_reader :original_number, :normalized_number, :country, :country_data
 
     def initialize(number, country)
       return unless number && country
 
-      @original_number = sanitize(number)
+      @original_number = sanitize(number).freeze
       @country = country.upcase.to_sym
-      @national_number, @e164_number = extract_number_types(@original_number, @country)
+      @country_data = PhoneData.phone_data[@country]
+
+      # normalized_number is basically a "best effort" at national number without
+      # any formatting. This is what we will use to derive formats, validations and
+      # basically anything else that uses google data
+      @normalized_number = build_normalized_number
     end
 
     def valid_types
-      @valid_types ||= validate(e164_number, country)
+      @valid_types ||= validate
     end
 
     def valid?(keys = [])
       keys.empty? ? !valid_types.empty? : !(valid_types & keys.map(&:to_sym)).empty?
     end
 
+    def national_number(formatted: true)
+      if formatted
+        @formatted_national_number ||= build_national_number
+      else
+        @unformatted_national_number ||= build_national_number(formatted: false)
+      end
+    end
+
+    def e164_number(formatted: true)
+      if formatted
+        @formatted_e164_number ||= build_e164_number
+      else
+        @e164_number ||= build_e164_number(formatted: false)
+      end
+    end
+
+    def international_number(formatted: true)
+      if formatted
+        @formatted_international_number ||= build_international_number
+      else
+        @international_number ||= build_international_number(formatted: false)
+      end
+    end
+
+    private
+
     def format
-      @format ||= extract_format(national_number, country)
+      @format ||= extract_format
     end
   end
 end

data/lib/telephone_number/parser.rb

@@ -1,39 +1,68 @@
 module TelephoneNumber
   module Parser
-    KEYS_TO_SKIP = [TelephoneNumber::PhoneData::GENERAL,
-                    TelephoneNumber::PhoneData::AREA_CODE_OPTIONAL]
+    KEYS_TO_SKIP = [PhoneData::GENERAL, PhoneData::AREA_CODE_OPTIONAL]
 
     def sanitize(input_number)
       return input_number.gsub(/[^0-9]/, "")
     end
 
-    def extract_number_types(input_number, country)
-      country_data = TelephoneNumber::PhoneData.phone_data[country.to_sym]
+    # returns an array of valid types for the normalized number
+    # if array is empty, we can assume that the number is invalid
+    def validate
+      return [] unless country_data
+      applicable_keys = country_data[PhoneData::VALIDATIONS].reject{ |key, _value| KEYS_TO_SKIP.include?(key) }
+      applicable_keys.map do |phone_type, validations|
+        full = "^(#{validations[PhoneData::VALID_PATTERN]})$"
+        phone_type.to_sym if normalized_number =~ Regexp.new(full)
+      end.compact
+    end
 
-      return [input_number, nil] unless country_data
-      country_code = country_data[TelephoneNumber::PhoneData::COUNTRY_CODE]
+    private
 
-      reg_string  = "^(#{country_code})?"
-      reg_string += "(#{country_data[TelephoneNumber::PhoneData::NATIONAL_PREFIX]})?"
-      reg_string += "(#{country_data[TelephoneNumber::PhoneData::VALIDATIONS]\
-                        [TelephoneNumber::PhoneData::GENERAL]\
-                        [TelephoneNumber::PhoneData::VALID_PATTERN]})$"
+    def build_normalized_number
+      return original_number unless country_data
+      country_code = country_data[PhoneData::COUNTRY_CODE]
+
+      number_with_correct_prefix = parse_prefix
 
-      match_result = input_number.match(Regexp.new(reg_string)) || []
+      reg_string  = "^(#{country_code})?"
+      reg_string << "(#{country_data[PhoneData::NATIONAL_PREFIX]})?"
+      reg_string << "(#{country_data[PhoneData::VALIDATIONS][PhoneData::GENERAL][PhoneData::VALID_PATTERN]})$"
 
+      match_result = number_with_correct_prefix.match(Regexp.new(reg_string))
+      return original_number unless match_result
       prefix_results = [match_result[1], match_result[2]]
-      without_prefix = input_number.sub(prefix_results.join, "")
-      [without_prefix, "#{country_code}#{without_prefix}"]
+      number_with_correct_prefix.sub(prefix_results.join, '')
     end
 
-    def validate(normalized_number, country)
-      country_data = TelephoneNumber::PhoneData.phone_data[country.to_sym]
-      return [] unless country_data
-      applicable_keys = country_data[TelephoneNumber::PhoneData::VALIDATIONS].reject{ |key, _value| KEYS_TO_SKIP.include?(key) }
-      applicable_keys.map do |phone_type, validations|
-        full = "^(#{country_data[TelephoneNumber::PhoneData::COUNTRY_CODE]})(#{validations[TelephoneNumber::PhoneData::VALID_PATTERN]})$"
-        phone_type if normalized_number =~ Regexp.new(full)
-      end.compact
+    def parse_prefix
+      return original_number unless country_data[:national_prefix_for_parsing]
+      duped = original_number.dup
+      match_object = duped.match(Regexp.new(country_data[:national_prefix_for_parsing]))
+
+      # we need to do the "start_with?" here because we need to make sure it's not finding
+      # something in the middle of the number. However, we can't modify the regex to do this
+      # for us because it will offset the match groups that are referenced in the transform rules
+      return original_number unless match_object && duped.start_with?(match_object[0])
+      if country_data[:national_prefix_transform_rule]
+        transform_national_prefix(duped, match_object)
+      else
+        duped.sub!(match_object[0], '')
+      end
+    end
+
+    def transform_national_prefix(duped, match_object)
+      if PhoneData::MOBILE_TOKEN_COUNTRIES.include?(country) && match_object.captures.any?
+        sprintf(build_format_string, duped.sub!(match_object[0], match_object[1]))
+      elsif match_object.captures.none?
+        duped.sub!(match_object[0], '')
+      else
+        sprintf(build_format_string, *match_object.captures)
+      end
+    end
+
+    def build_format_string
+      country_data[:national_prefix_transform_rule].gsub(/(\$\d)/) {|cap| "%#{cap.reverse}s"}
     end
   end
 end

data/lib/telephone_number/phone_data.rb

@@ -1,25 +1,32 @@
 module TelephoneNumber
   module PhoneData
-    VALIDATIONS = :validations.freeze
+    AREA_CODE_OPTIONAL = :area_code_optional.freeze
+    COUNTRY_CODE = :country_code.freeze
+    FIXED_LINE = :fixed_line.freeze
     FORMATS = :formats.freeze
+    FORMAT = :format.freeze
     GENERAL = :general_desc.freeze
+    INTERNATIONAL_PREFIX = :international_prefix.freeze
+    INTL_FORMAT = :intl_format.freeze
+    LEADING_DIGITS = :leading_digits.freeze
+    MAIN_COUNTRY_FOR_CODE = :main_country_for_code.freeze
+    MOBILE = :mobile.freeze
+    MOBILE_TOKEN_COUNTRIES = { AR: '9' }.freeze
+    NATIONAL_PREFIX = :national_prefix.freeze
+    NATIONAL_PREFIX_FOR_PARSING = :national_prefix_for_parsing.freeze
+    NATIONAL_PREFIX_FORMATTING_RULE = :national_prefix_formatting_rule.freeze
+    NO_INTERNATIONAL_DIALING = :no_international_dialling.freeze
+    PATTERN = :pattern
+    PERSONAL_NUMBER = :personal_number.freeze
+    POSSIBLE_PATTERN = :possible_number_pattern.freeze
     PREMIUM_RATE = :premium_rate.freeze
-    TOLL_FREE = :toll_free.freeze
     SHARED_COST = :shared_cost.freeze
-    VOIP = :voip.freeze
-    PERSONAL_NUMBER = :personal_number.freeze
+    TOLL_FREE = :toll_free.freeze
     UAN = :uan.freeze
-    VOICEMAIL = :voicemail.freeze
-    FIXED_LINE = :fixed_line.freeze
-    MOBILE = :mobile.freeze
-    NO_INTERNATIONAL_DIALING = :no_international_dialling.freeze
-    AREA_CODE_OPTIONAL = :area_code_optional.freeze
+    VALIDATIONS = :validations.freeze
     VALID_PATTERN = :national_number_pattern.freeze
-    POSSIBLE_PATTERN = :possible_number_pattern.freeze
-    NATIONAL_PREFIX = :national_prefix.freeze
-    COUNTRY_CODE = :country_code.freeze
-    LEADING_DIGITS = :leading_digits.freeze
-    INTERNATIONAL_PREFIX = :international_prefix.freeze
+    VOICEMAIL = :voicemail.freeze
+    VOIP = :voip.freeze
 
     def self.phone_data
       @@phone_data ||= load_data

data/lib/telephone_number/test_data_generator.rb

@@ -0,0 +1,91 @@
+module TelephoneNumber
+  require 'nokogiri'
+  require 'httparty'
+  require 'yaml'
+
+  class TestDataGenerator
+    URL =  "https://libphonenumber.appspot.com/phonenumberparser?number=%s&country=%s".freeze
+    COUNTRIES = {
+                  AR: %w(111512345678 380151234567 299154104587 01112345678),
+                  AU: %w(0467703037),
+                  BR: %w(011992339376 1123456789 11961234567),
+                  BY: %w(80152450911 294911911 152450911),
+                  CA: %w(16135550119 16135550171 16135550112 16135550194
+                         16135550122 16135550131 15146708700 14169158200),
+                  CL: %w(961234567 221234567),
+                  CN: %w(15694876068 13910503766 15845989469 05523245954 04717158875 03748086894),
+                  CO: %w(3211234567 12345678),
+                  CR: %w(22123456 83123456),
+                  DE: %w(15222503070),
+                  FR: %w(0607114556),
+                  GB: %w(448444156790 442079308181 442076139800 442076361000
+                         07780991912 442076299400 442072227888),
+                  HK: %w(64636251),
+                  IE: %w(0863634875),
+                  MX: %w(4423593227 14423593227),
+                  IN: %w(915622231515 912942433300 912912510101 911126779191
+                         912224818000 917462223999 912266653366 912266325757
+                         914066298585 911242451234 911166566162 911123890606
+                         911123583754 5622231515 2942433300 2912510101
+                         1126779191 2224818000 7462223999 2266653366
+                         2266325757 4066298585 1242451234 1166566162
+                         1123890606 1123583754 09176642499),
+                  JP: %w(312345678 9012345678),
+                  SG: %w(96924755),
+                  US: %w(16502530000 14044879000 15123435283 13032450086 16175751300
+                         3175083345 13128404100 12485934000 19497941600 14257395600 13103106000
+                         16086699600 12125650000 14123456700 14157360000 12068761800
+                         12023461100 3175082333)
+                }.freeze
+
+    def self.import!
+      output_hash = {}
+      fetch_data(output_hash)
+      write_file(output_hash)
+      true
+    end
+
+    def self.fetch_data(output_hash)
+      COUNTRIES.each do |key, value|
+        output_hash[key] = {}
+
+        value.each_with_index do |num, counter|
+          page = HTTParty.get(sprintf(URL, num, key.to_s))
+          parsed_page = Nokogiri::HTML.parse(page)
+          body = parsed_page.elements.first.elements.css('body').first
+          parsed_data = parse_remote_data(counter, body.elements.css('table')[2])
+          output_hash[key].merge!(parsed_data)
+        end
+      end
+      return output_hash
+    end
+
+    def self.parse_remote_data(counter, table)
+      output = { counter.to_s => {} }
+      table.elements.each do |row|
+        next if row.elements.one?
+        key = case row.elements.css('th').text
+              when 'E164 format'
+                :e164_formatted
+              when 'National format'
+                :national_formatted
+              when 'International format'
+                :international_formatted
+              end
+
+        output[counter.to_s][key] = row.elements.css('td').text if key
+      end
+      return output
+    end
+
+    def self.write_file(data)
+      File.open('test/valid_numbers.yml', 'w') do |file|
+        file.write "# This file is generated automatically by TestDataGenerator. \n" \
+          "# Any changes made to this file will be overridden next time test data is generated. \n" \
+          "# Please edit TestDataGenerator if you need to add test cases. \n"
+
+        file.write data.to_yaml
+      end
+    end
+  end
+end

data/lib/telephone_number/version.rb

@@ -1,3 +1,3 @@
 module TelephoneNumber
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/telephone_number.rb

@@ -2,8 +2,10 @@ require "telephone_number/version"
 
 module TelephoneNumber
   autoload :DataImporter, 'telephone_number/data_importer'
+  autoload :TestDataGenerator, 'telephone_number/test_data_generator'
   autoload :Parser, 'telephone_number/parser'
   autoload :Number, 'telephone_number/number'
+  autoload :Formatter, 'telephone_number/formatter'
   autoload :PhoneData, 'telephone_number/phone_data'
   autoload :ClassMethods, 'telephone_number/class_methods'
 

data/telephone_number.gemspec

@@ -26,5 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pry"
   spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "nokogiri"
+  spec.add_development_dependency "httparty"
   spec.add_development_dependency "minitest-focus"
+  spec.add_development_dependency 'coveralls'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: telephone_number
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - MOBI Wireless Management
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-20 00:00:00.000000000 Z
+date: 2017-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest-focus
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - adam.fernung@mobiwm.com
@@ -118,12 +146,13 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".hound.yml"
+- ".rubocop.default.yml"
+- ".rubocop.yml"
 - ".ruby-version"
-- ".ruby.yml"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
-- LICENSE.txt
+- LICENSE
 - README.md
 - Rakefile
 - bin/console
@@ -133,12 +162,13 @@ files:
 - lib/telephone_number.rb
 - lib/telephone_number/class_methods.rb
 - lib/telephone_number/data_importer.rb
+- lib/telephone_number/formatter.rb
 - lib/telephone_number/number.rb
 - lib/telephone_number/parser.rb
 - lib/telephone_number/phone_data.rb
+- lib/telephone_number/test_data_generator.rb
 - lib/telephone_number/version.rb
 - telephone_number.gemspec
-- telephone_number_data_file.xml
 homepage: https://github.com/mobi/telephone_number
 licenses:
 - MIT