phonejack 1.2.0

data/lib/active_model/phonejack_validator.rb

@@ -0,0 +1,9 @@
+class PhonejackValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    country = options[:country].call(record) if options.key?(:country)
+    valid_types = options.fetch(:types, [])
+    args = [value, country, valid_types]
+
+    record.errors.add(attribute, :invalid) if Phonejack.invalid?(*args)
+  end
+end

data/lib/phonejack.rb

@@ -0,0 +1,17 @@
+require 'phonejack/version'
+require 'utilities/hash'
+require 'active_model/phonejack_validator' if defined?(ActiveModel)
+
+module Phonejack
+  autoload :DataImporter,      'phonejack/data_importer'
+  autoload :TestDataGenerator, 'phonejack/test_data_generator'
+  autoload :Parser,            'phonejack/parser'
+  autoload :Number,            'phonejack/number'
+  autoload :Formatter,         'phonejack/formatter'
+  autoload :Country,           'phonejack/country'
+  autoload :NumberFormat,      'phonejack/number_format'
+  autoload :NumberValidation,  'phonejack/number_validation'
+  autoload :ClassMethods,      'phonejack/class_methods'
+
+  extend ClassMethods
+end

data/lib/phonejack/class_methods.rb

@@ -0,0 +1,40 @@
+module Phonejack
+  module ClassMethods
+    attr_accessor :override_file, :default_format_string
+    attr_reader :default_format_pattern
+
+    def default_format_pattern=(format_string)
+      @default_format_pattern = Regexp.new(format_string)
+    end
+
+    def parse(number, country = detect_country(number))
+      Phonejack::Number.new(sanitize(number), country)
+    end
+
+    def valid?(number, country = detect_country(number), keys = [])
+      parse(number, country).valid?(keys)
+    end
+
+    def invalid?(*args)
+      !valid?(*args)
+    end
+
+    def sanitize(input_number)
+      input_number.to_s.gsub(/\D/, '')
+    end
+
+    def detect_country(number)
+      sanitized_number = sanitize(number)
+      detected_country = Country.all_countries.detect do |country|
+        sanitized_number.start_with?(country.country_code) && valid?(sanitized_number, country.country_id)
+      end
+
+      detected_country.country_id.to_sym if detected_country
+    end
+
+    # generates binary file from xml that user gives us
+    def generate_override_file(file)
+      DataImporter.new(file, override: true).import!
+    end
+  end
+end

data/lib/phonejack/country.rb

@@ -0,0 +1,67 @@
+module Phonejack
+  class Country
+    attr_reader :country_code, :national_prefix, :national_prefix_formatting_rule,
+                :national_prefix_for_parsing, :national_prefix_transform_rule, :international_prefix,
+                :formats, :validations, :mobile_token, :country_id, :general_validation, :main_country_for_code
+
+    MOBILE_TOKEN_COUNTRIES = { AR: '9' }
+
+    def initialize(data_hash)
+      @country_code = data_hash[:country_code]
+      @country_id = data_hash[:id]
+      @formats = data_hash.fetch(:formats, []).map { |format| NumberFormat.new(format) }
+      @general_validation = NumberValidation.new(:general_desc, data_hash[:validations][:general_desc]) if data_hash.fetch(:validations, {})[:general_desc]
+      @international_prefix = Regexp.new(data_hash[:international_prefix]) if data_hash[:international_prefix]
+      @main_country_for_code = data_hash[:main_country_for_code] == 'true'
+      @mobile_token = MOBILE_TOKEN_COUNTRIES[@country_id.to_sym]
+      @national_prefix = data_hash[:national_prefix]
+      @national_prefix_formatting_rule = data_hash[:national_prefix_formatting_rule]
+      @national_prefix_for_parsing = Regexp.new(data_hash[:national_prefix_for_parsing]) if data_hash[:national_prefix_for_parsing]
+      @national_prefix_transform_rule = data_hash[:national_prefix_transform_rule]
+      @validations = data_hash.fetch(:validations, {})
+                              .except(:general_desc, :area_code_optional)
+                              .map { |name, data| NumberValidation.new(name, data) }
+    end
+
+    def detect_format(number)
+      native_format = formats.detect do |format|
+        number =~ Regexp.new("^(#{format.leading_digits})") && number =~ Regexp.new("^(#{format.pattern})$")
+      end
+
+      return native_format if native_format || main_country_for_code
+      parent_country.detect_format(number) if parent_country
+    end
+
+    def parent_country
+      return if main_country_for_code
+      Country.all_countries.detect do |country|
+        country.country_code == self.country_code && country.main_country_for_code
+      end
+    end
+
+    def full_general_pattern
+      %r{^(#{country_code})?(#{national_prefix})?(?<national_num>#{general_validation.pattern})$}
+    end
+
+    def self.phone_data
+      @phone_data ||= load_data
+    end
+
+    def self.find(country_id)
+      data = phone_data[country_id.to_s.upcase.to_sym]
+      new(data) if data
+    end
+
+    def self.load_data
+      data_file = "#{File.dirname(__FILE__)}/../../data/telephone_number_data_file.dat"
+      main_data = Marshal.load(File.binread(data_file))
+      override_data = {}
+      override_data = Marshal.load(File.binread(Phonejack.override_file)) if Phonejack.override_file
+      return main_data.deep_deep_merge!(override_data)
+    end
+
+    def self.all_countries
+      @all_countries ||= phone_data.values.map {|data| new(data)}
+    end
+  end
+end

data/lib/phonejack/data_importer.rb

@@ -0,0 +1,96 @@
+module Phonejack
+  require 'nokogiri'
+  class DataImporter
+    attr_reader :data, :file, :override
+
+    def initialize(file_name, override: false)
+      @data = {}
+      @file = File.open(file_name) { |f| Nokogiri::XML(f) }
+      @override = override
+    end
+
+    def import!
+      parse_main_data
+      save_data_file
+    end
+
+    def parse_main_data
+      file.css('territories territory').each do |territory|
+        country_code = territory.attributes['id'].value.to_sym
+        @data[country_code] ||= {}
+
+        load_base_attributes(@data[country_code], territory)
+        load_references(@data[country_code], territory)
+        load_validations(@data[country_code], territory)
+        load_formats(@data[country_code], territory)
+      end
+    end
+
+    private
+
+    def load_formats(country_data, territory)
+      formats_arr = territory.css('availableFormats numberFormat').map do |format|
+        {}.tap do |fhash|
+          format.attributes.values.each do |attr|
+            key = underscore(attr.name).to_sym
+            fhash[key] = if key == :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] = [:format, :intl_format].include?(key) ? child.text : child.text.delete("\n ")
+          end
+        end
+      end
+
+      return if override && formats_arr.empty?
+      country_data[:formats] = formats_arr
+    end
+
+    def load_validations(country_data, territory)
+      country_data[:validations] = {}
+      territory.elements.each do |element|
+        next if element.name == 'references' || element.name == 'availableFormats'
+        country_data[: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
+      country_data.delete(:validations) if country_data[:validations].empty? && override
+    end
+
+    def load_base_attributes(country_data, territory)
+      territory.attributes.each do |key, value_object|
+        underscored_key = underscore(key).to_sym
+        country_data[underscored_key] = if underscored_key == :national_prefix_for_parsing
+                                          value_object.value.delete("\n ")
+                                        else
+                                          value_object.value
+                                        end
+      end
+    end
+
+    def load_references(country_data, territory)
+      ref_arr = territory.css('references sourceUrl').map(&:text)
+      return if override && ref_arr.empty?
+      country_data[:references] = ref_arr
+    end
+
+    def underscore(camel_cased_word)
+      return camel_cased_word unless camel_cased_word =~ /[A-Z-]|::/
+      word = camel_cased_word.to_s.gsub(/::/, '/')
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr!('-', '_')
+      word.downcase!
+      word
+    end
+
+    def save_data_file
+      data_file = override ? 'telephone_number_data_override_file.dat' : "#{File.dirname(__FILE__)}/../../data/telephone_number_data_file.dat"
+      File.open(data_file, 'wb+') { |f| Marshal.dump(@data, f) }
+    end
+  end
+end

data/lib/phonejack/formatter.rb

@@ -0,0 +1,76 @@
+module Phonejack
+  class Formatter
+
+    attr_reader :normalized_number, :country, :valid, :original_number
+
+    def initialize(number_obj)
+      @normalized_number = number_obj.normalized_number
+      @country = number_obj.country
+      @valid = number_obj.valid?
+      @original_number = number_obj.original_number
+    end
+
+    def national_number(formatted: true)
+      return original_or_default if !valid? || !number_format
+      build_national_number(formatted: formatted)
+    end
+
+    def e164_number(formatted: true)
+      return original_or_default if !valid?
+      build_e164_number(formatted: formatted)
+    end
+
+    def international_number(formatted: true)
+      return original_or_default if !valid? || !number_format
+      build_international_number(formatted: formatted)
+    end
+
+    alias_method :valid?, :valid
+
+    private
+
+    def number_format
+      @number_format ||= country.detect_format(normalized_number)
+    end
+
+    def build_national_number(formatted: true)
+      captures = normalized_number.match(number_format.pattern).captures
+      national_prefix_formatting_rule = number_format.national_prefix_formatting_rule || country.national_prefix_formatting_rule
+
+      formatted_string = format(ruby_format_string(number_format.format), *captures)
+      captures.delete(country.mobile_token)
+
+      if national_prefix_formatting_rule
+        national_prefix_string = national_prefix_formatting_rule.dup
+        national_prefix_string.gsub!(/\$NP/, country.national_prefix)
+        national_prefix_string.gsub!(/\$FG/, captures[0])
+        formatted_string.sub!(captures[0], national_prefix_string)
+      end
+
+      formatted ? formatted_string : Phonejack.sanitize(formatted_string)
+    end
+
+    def build_e164_number(formatted: true)
+      formatted_string = "+#{country.country_code}#{normalized_number}"
+      formatted ? formatted_string : Phonejack.sanitize(formatted_string)
+    end
+
+    def build_international_number(formatted: true)
+      return original_or_default if !valid? || number_format.nil?
+      captures = normalized_number.match(number_format.pattern).captures
+      key = number_format.intl_format || number_format.format
+      formatted_string = "+#{country.country_code} #{format(ruby_format_string(key), *captures)}"
+      formatted ? formatted_string : Phonejack.sanitize(formatted_string)
+    end
+
+    def ruby_format_string(format_string)
+      format_string.gsub(/(\$\d)/) { |cap| "%#{cap.reverse}s" }
+    end
+
+    def original_or_default
+      return original_number unless Phonejack.default_format_string && Phonejack.default_format_pattern
+      captures = original_number.match(Phonejack.default_format_pattern).captures
+      format(ruby_format_string(Phonejack.default_format_string), *captures)
+    end
+  end
+end

data/lib/phonejack/number.rb

@@ -0,0 +1,17 @@
+module Phonejack
+  class Number
+    extend Forwardable
+
+    attr_reader :country, :parser, :formatter, :original_number
+
+    delegate [:valid?, :valid_types, :normalized_number] => :parser
+    delegate [:national_number, :e164_number, :international_number] => :formatter
+
+    def initialize(number, country)
+      @original_number = number
+      @country = Country.find(country)
+      @parser = Parser.new(self)
+      @formatter = Formatter.new(self)
+    end
+  end
+end

data/lib/phonejack/number_format.rb

@@ -0,0 +1,14 @@
+module Phonejack
+  class NumberFormat
+
+    attr_reader :pattern, :leading_digits, :format, :national_prefix_formatting_rule, :intl_format
+
+    def initialize(data_hash)
+      @pattern = Regexp.new(data_hash[:pattern]) if data_hash[:pattern]
+      @leading_digits = Regexp.new(data_hash[:leading_digits]) if data_hash[:leading_digits]
+      @format = data_hash[:format]
+      @intl_format = data_hash[:intl_format]
+      @national_prefix_formatting_rule = data_hash[:national_prefix_formatting_rule]
+    end
+  end
+end

data/lib/phonejack/number_validation.rb

@@ -0,0 +1,10 @@
+module Phonejack
+  class NumberValidation
+    attr_reader :name, :pattern
+
+    def initialize(name, data_hash)
+      @name = name
+      @pattern = data_hash[:national_number_pattern]
+    end
+  end
+end

data/lib/phonejack/parser.rb

@@ -0,0 +1,68 @@
+module Phonejack
+  class Parser
+    attr_reader :original_number, :normalized_number, :country
+
+    def initialize(number_obj)
+      @original_number = number_obj.original_number
+      @country = number_obj.country
+      @normalized_number = build_normalized_number if @country
+    end
+
+    def valid_types
+      @valid_types ||= validate
+    end
+
+    def valid?(keys = [])
+      keys.empty? ? !valid_types.empty? : !(valid_types & keys.map(&:to_sym)).empty?
+    end
+
+    private
+
+    # 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
+    def build_normalized_number
+      match_result = parse_prefix.match(country.full_general_pattern)
+      match_result ? match_result[:national_num] : original_number
+    end
+
+    # 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
+      country.validations.select do |validation|
+        normalized_number =~ Regexp.new("^(#{validation.pattern})$")
+      end.map(&:name)
+    end
+
+    def parse_prefix
+      return original_number unless country.national_prefix_for_parsing
+      duped = original_number.dup
+      match_object = duped.match(country.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.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 country.mobile_token && match_object.captures.any?
+        format(build_format_string, duped.sub!(match_object[0], match_object[1]))
+      elsif match_object.captures.none?
+        duped.sub!(match_object[0], '')
+      else
+        format(build_format_string, *match_object.captures)
+      end
+    end
+
+    def build_format_string
+      country.national_prefix_transform_rule.gsub(/(\$\d)/) { |cap| "%#{cap.reverse}s" }
+    end
+  end
+end

data/lib/phonejack/test_data_generator.rb

@@ -0,0 +1,116 @@
+module Phonejack
+  require 'nokogiri'
+  require 'httparty'
+  require 'yaml'
+
+  class TestDataGenerator
+    URL =  "https://libphonenumber.appspot.com/phonenumberparser?number=%s&country=%s".freeze
+    COUNTRIES = {
+                  AE: %w(971529933171 971553006144 971551000291),
+                  AR: %w(111512345678 380151234567 299154104587 01112345678),
+                  AU: %w(0467703037),
+                  BE: %w(32498485960 32477702206 32474095692),
+                  BO: %w(59178500348 59178006138 59178006139),
+                  BR: %w(011992339376 1123456789 11961234567),
+                  BY: %w(80152450911 294911911 152450911),
+                  CA: %w(16135550119 16135550171 16135550112 16135550194
+                         16135550122 16135550131 15146708700 14169158200),
+                  CH: %w(41794173875 41795061129 41795820985),
+                  CL: %w(961234567 221234567),
+                  CN: %w(15694876068 13910503766 15845989469 05523245954 04717158875 03748086894),
+                  CO: %w(3211234567 12345678),
+                  CR: %w(22123456 83123456),
+                  DE: %w(15222503070),
+                  DK: %w(4524453744 4551622172 4542428484),
+                  EC: %w(593992441504 593984657155 593984015053),
+                  EE: %w(37253629280 37253682997 37254004517),
+                  ES: %w(34606217800 34667751353 34646570628),
+                  FR: %w(0607114556),
+                  GB: %w(448444156790 442079308181 442076139800 442076361000
+                         07780991912 442076299400 442072227888),
+                  HK: %w(64636251),
+                  HU: %w(36709311285 36709311279 36709311206),
+                  IE: %w(0863634875),
+                  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),
+                  IT: %w(393478258998 393440161350),
+                  JP: %w(312345678 9012345678),
+                  KR: %w(821036424812 821053812833 821085894820),
+                  MX: %w(4423593227 14423593227),
+                  NL: %w(31610958780 31610000852 31611427604),
+                  NO: %w(4792272668 4797065876 4792466013),
+                  NZ: %w(64212715077 6421577017 64212862111),
+                  PE: %w(51994156035 51987527881 51972737259),
+                  PH: %w(639285588185 639285588262 639285548190),
+                  PL: %w(48665666003 48885882321 48885889958),
+                  QA: %w(97470482288 97474798678),
+                  RO: %w(40724242563 40727798526 40727735377),
+                  SA: %w(966503891468 966501543349 966500939012),
+                  SE: %w(46708922920 46723985268 46761001966),
+                  SG: %w(96924755),
+                  TR: %w(905497728782 905497728780 905497728781),
+                  TT: %w(18687804765 18687804843 18687804752),
+                  TW: %w(886905627933 886905627901 886905627925),
+                  US: %w(16502530000 14044879000 15123435283 13032450086 16175751300
+                         3175083345 13128404100 12485934000 19497941600 14257395600 13103106000
+                         16086699600 12125650000 14123456700 14157360000 12068761800
+                         12023461100 3175082333),
+                  VE: %w(584149993108 584248407260 584248271518),
+                  ZA: %w(27826187617 27823014578 27828840632)
+                }.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(format(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