telephone_number 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: da8efdb23ca38191becf7d7a07a6387cce0530cf
-  data.tar.gz: 16577898ab4e8dccf7a85ed2bf0d2c2faa5a9a99
+  metadata.gz: 9176d842a4931a224fbc4e89bcf4f643e6bb4ab2
+  data.tar.gz: 88a4b6d3439017b5a9b68a15ae752c790373a475
 SHA512:
-  metadata.gz: 3ec45bf229dcceaab6b9893dac3f96352789d45d7923e45551ace2e8fc92da1efcdf71adb2e50350f84783d66d247af666e2be24af78242e7ac9fceb323a2792
-  data.tar.gz: 3502e8e65b905792c767a6fda80865085eb3fd59d13857f7eb3e82c5e3d800615dbc7fc23c30cccb9ae9f8e44604f74939cde6f2f2dc7d5fe907678c1d64aa27
+  metadata.gz: 6c1edb3e9c8f23ff5b8b43bf803995aac9c4c189c86ae453fe03c19d664af3bd8379be03c6aeaea8ad7f4a838efb1d0ac19dafb13bef84c90607a9af36bc51b4
+  data.tar.gz: c078804473a1a25106b6911b1bf379ca7727f5387a9dcfe8c34947c2f9b478bc1d868b083796943380497c631221355ef5f15f5ee0f6444bb518d01c909f9251

data/README.md

@@ -2,7 +2,13 @@
 
 # What is it?
 
-TelephoneNumber is global phone number validation gem based on Google's [libphonenumber](https://github.com/googlei18n/libphonenumber) library. We're currently providing parsing and validation functionality and are actively working on formatting as well as providing extended data.
+TelephoneNumber is global phone number validation gem based on Google's [libphonenumber](https://github.com/googlei18n/libphonenumber) library.
+
+## Demo
+
+Feel free to check out our demo!
+
+[Numberjack](http://numberjack.io)
 
 ## Installation
 

data/lib/telephone_number/class_methods.rb

@@ -1,15 +1,20 @@
 module TelephoneNumber
   module ClassMethods
-    def parse(number, country)
+    def parse(number, country = Parser.detect_country(number))
       TelephoneNumber::Number.new(number, country)
     end
 
-    def valid?(number, country, keys = [])
+    def valid?(number, country = Parser.detect_country(number), keys = [])
       parse(number, country).valid?(keys)
     end
 
     def invalid?(*args)
       !valid?(*args)
     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/telephone_number/data_importer.rb

@@ -1,16 +1,17 @@
 module TelephoneNumber
   require 'nokogiri'
   class DataImporter
-    attr_reader :data, :file
+    attr_reader :data, :file, :override
 
-    def initialize(file_name)
+    def initialize(file_name, override: false)
       @data = {}
       @file = File.open(file_name) { |f| Nokogiri::XML(f) }
+      @override = override
     end
 
-    def import!(override: false)
+    def import!
       parse_main_data
-      save_data_file(override: override)
+      save_data_file
     end
 
     def parse_main_data
@@ -28,7 +29,7 @@ module TelephoneNumber
     private
 
     def load_formats(country_data, territory)
-      country_data[PhoneData::FORMATS] = territory.css('availableFormats numberFormat').map do |format|
+      formats_arr = territory.css('availableFormats numberFormat').map do |format|
         {}.tap do |fhash|
           format.attributes.values.each do |attr|
             key = underscore(attr.name).to_sym
@@ -44,6 +45,9 @@ module TelephoneNumber
           end
         end
       end
+
+      return if override && formats_arr.empty?
+      country_data[PhoneData::FORMATS] = formats_arr
     end
 
     def load_validations(country_data, territory)
@@ -54,6 +58,7 @@ module TelephoneNumber
           element.elements.each { |child| validation_hash[underscore(child.name).to_sym] = child.text.delete("\n ") }
         end
       end
+      country_data.delete(PhoneData::VALIDATIONS) if country_data[PhoneData::VALIDATIONS].empty? && override
     end
 
     def load_base_attributes(country_data, territory)
@@ -68,7 +73,9 @@ module TelephoneNumber
     end
 
     def load_references(country_data, territory)
-      country_data[:references] = territory.css('references sourceUrl').map(&:text)
+      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)
@@ -81,7 +88,7 @@ module TelephoneNumber
       word
     end
 
-    def save_data_file(override: false)
+    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

data/lib/telephone_number/formatter.rb

@@ -1,13 +1,56 @@
 module TelephoneNumber
-  module Formatter
+  class Formatter
+    extend Forwardable
+
+    attr_reader :normalized_number, :phone_data, :valid
+
+    delegate [:country_data, :country] => :phone_data
+
+    def initialize(number_obj, phone_data)
+      @normalized_number = number_obj.normalized_number
+      @phone_data = phone_data
+      @valid = number_obj.valid?
+    end
+
+    def national_number(formatted: true)
+      if formatted
+        @formatted_national_number ||= build_national_number
+      else
+        @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
+
+    alias_method :valid?, :valid
+
+    private
+
+    def number_format
+      @number_format ||= extract_number_format
+    end
+
     def build_national_number(formatted: true)
       return normalized_or_default if !valid? || number_format.nil?
       captures = normalized_number.match(Regexp.new(number_format[PhoneData::PATTERN])).captures
       national_prefix_formatting_rule = number_format[PhoneData::NATIONAL_PREFIX_FORMATTING_RULE] \
                                          || country_data[PhoneData::NATIONAL_PREFIX_FORMATTING_RULE]
 
-      format_string = number_format[PhoneData::FORMAT].gsub(/(\$\d)/) { |cap| "%#{cap.reverse}s" }
-      formatted_string = format(format_string, *captures)
+      formatted_string = format(ruby_format_string(number_format[PhoneData::FORMAT]), *captures)
       captures.delete(PhoneData::MOBILE_TOKEN_COUNTRIES[country])
 
       if national_prefix_formatting_rule
@@ -17,30 +60,31 @@ module TelephoneNumber
         formatted_string.sub!(captures[0], national_prefix_string)
       end
 
-      formatted ? formatted_string : sanitize(formatted_string)
+      formatted ? formatted_string : Parser.sanitize(formatted_string)
     end
 
     def build_e164_number(formatted: true)
+      return normalized_or_default if !country_data || normalized_number.empty?
       formatted_string = "+#{country_data[PhoneData::COUNTRY_CODE]}#{normalized_number}"
-      formatted ? formatted_string : sanitize(formatted_string)
+      formatted ? formatted_string : Parser.sanitize(formatted_string)
     end
 
     def build_international_number(formatted: true)
       return normalized_or_default if !valid? || number_format.nil?
       captures = normalized_number.match(Regexp.new(number_format[PhoneData::PATTERN])).captures
       key = number_format.fetch(PhoneData::INTL_FORMAT, 'NA') != 'NA' ? PhoneData::INTL_FORMAT : PhoneData::FORMAT
-      format_string = number_format[key].gsub(/(\$\d)/) { |cap| "%#{cap.reverse}s" }
-      formatted_string = "+#{country_data[PhoneData::COUNTRY_CODE]} #{format(format_string, *captures)}"
-      formatted ? formatted_string : sanitize(formatted_string)
+      formatted_string = "+#{country_data[PhoneData::COUNTRY_CODE]} #{format(ruby_format_string(number_format[key]), *captures)}"
+      formatted ? formatted_string : Parser.sanitize(formatted_string)
     end
 
-    private
+    def ruby_format_string(format_string)
+      format_string.gsub(/(\$\d)/) { |cap| "%#{cap.reverse}s" }
+    end
 
     def normalized_or_default
-      return normalized_number if !TelephoneNumber.default_format_string || !TelephoneNumber.default_format_pattern
+      return normalized_number unless TelephoneNumber.default_format_string && TelephoneNumber.default_format_pattern
       captures = normalized_number.match(TelephoneNumber.default_format_pattern).captures
-      format_string = TelephoneNumber.default_format_string.gsub(/(\$\d)/) { |cap| "%#{cap.reverse}s" }
-      format(format_string, *captures)
+      format(ruby_format_string(TelephoneNumber.default_format_string), *captures)
     end
 
     def extract_number_format

data/lib/telephone_number/number.rb

@@ -1,59 +1,16 @@
 module TelephoneNumber
   class Number
-    include TelephoneNumber::Parser
-    include TelephoneNumber::Formatter
+    extend Forwardable
 
-    attr_reader :original_number, :normalized_number, :country, :country_data
+    attr_reader :phone_data, :parser, :formatter
 
-    def initialize(number, country)
-      return unless number && country
-
-      @original_number = sanitize(number).freeze
-      @country = country.upcase.to_sym
-      @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
-    end
-
-    def valid?(keys = [])
-      keys.empty? ? !valid_types.empty? : !(valid_types & keys.map(&:to_sym)).empty?
-    end
+    delegate [:valid?, :valid_types, :normalized_number] => :parser
+    delegate [:national_number, :e164_number, :international_number] => :formatter
 
-    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 number_format
-      @number_format ||= extract_number_format
+    def initialize(number, country)
+      @phone_data = PhoneData.new(country)
+      @parser = Parser.new(number, @phone_data)
+      @formatter = Formatter.new(self, @phone_data)
     end
   end
 end

data/lib/telephone_number/parser.rb

@@ -1,11 +1,39 @@
 module TelephoneNumber
-  module Parser
+  class Parser
     KEYS_TO_SKIP = [PhoneData::GENERAL, PhoneData::AREA_CODE_OPTIONAL]
+    extend Forwardable
 
-    def sanitize(input_number)
-      return input_number.gsub(/[^0-9]/, '')
+    delegate [:country_data, :country] => :phone_data
+    attr_reader :sanitized_number, :original_number, :normalized_number, :phone_data
+
+    def initialize(original_number, phone_data)
+      @sanitized_number = self.class.sanitize(original_number)
+      @phone_data = phone_data
+      @original_number = original_number
+      @normalized_number = build_normalized_number
+    end
+
+    def valid_types
+      @valid_types ||= validate
+    end
+
+    def valid?(keys = [])
+      keys.empty? ? !valid_types.empty? : !(valid_types & keys.map(&:to_sym)).empty?
+    end
+
+    def self.detect_country(number)
+      sanitized_number = sanitize(number)
+      detected_country = PhoneData.phone_data.detect(->{[]}) do |two_letter, value|
+        sanitized_number =~ Regexp.new("^#{value[:country_code]}") && new(sanitized_number, PhoneData.new(two_letter)).valid?
+      end.first
     end
 
+    def self.sanitize(input_number)
+      return input_number.to_s.gsub(/\D/, '')
+    end
+
+    private
+
     # returns an array of valid types for the normalized number
     # if array is empty, we can assume that the number is invalid
     def validate
@@ -17,10 +45,11 @@ module TelephoneNumber
       end.compact
     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
-      return original_number unless country_data
+      return sanitized_number unless country_data
       country_code = country_data[PhoneData::COUNTRY_CODE]
 
       number_with_correct_prefix = parse_prefix
@@ -30,20 +59,20 @@ module TelephoneNumber
       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
+      return sanitized_number unless match_result
       prefix_results = [match_result[1], match_result[2]]
       number_with_correct_prefix.sub(prefix_results.join, '')
     end
 
     def parse_prefix
-      return original_number unless country_data[:national_prefix_for_parsing]
-      duped = original_number.dup
+      return sanitized_number unless country_data[:national_prefix_for_parsing]
+      duped = sanitized_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])
+      return sanitized_number unless match_object && duped.start_with?(match_object[0])
       if country_data[:national_prefix_transform_rule]
         transform_national_prefix(duped, match_object)
       else

data/lib/telephone_number/phone_data.rb

@@ -1,5 +1,5 @@
 module TelephoneNumber
-  module PhoneData
+  class PhoneData
     AREA_CODE_OPTIONAL = :area_code_optional
     COUNTRY_CODE = :country_code
     FIXED_LINE = :fixed_line
@@ -28,6 +28,8 @@ module TelephoneNumber
     VOICEMAIL = :voicemail
     VOIP = :voip
 
+    attr_reader :country_data, :country
+
     def self.phone_data
       @@phone_data ||= load_data
     end
@@ -39,6 +41,11 @@ module TelephoneNumber
       override_data = Marshal.load(File.binread(TelephoneNumber.override_file)) if TelephoneNumber.override_file
       return main_data.deep_deep_merge!(override_data)
     end
+
+    def initialize(country)
+      @country = country.to_s.upcase.to_sym
+      @country_data = self.class.phone_data[@country]
+    end
   end
 end
 

data/lib/telephone_number/version.rb

@@ -1,3 +1,3 @@
 module TelephoneNumber
-  VERSION = "0.3.0"
+  VERSION = "1.0.0"
 end

data/lib/telephone_number.rb

@@ -1,5 +1,6 @@
 require 'telephone_number/version'
 require 'utilities/hash'
+require 'forwardable'
 
 module TelephoneNumber
   autoload :DataImporter, 'telephone_number/data_importer'
@@ -44,11 +45,4 @@ module TelephoneNumber
   def self.default_format_pattern
     @@default_format_pattern
   end
-
-
-  # generates binary file from xml that user gives us
-  def self.generate_override_file(file)
-    DataImporter.new(file).import!(override: true)
-  end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: telephone_number
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - MOBI Wireless Management
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-14 00:00:00.000000000 Z
+date: 2017-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler