tfe-phone 0.9.9.1

data/lib/phone.rb

@@ -0,0 +1,213 @@
+# An object representing a phone number.
+# 
+# The phone number is recorded in 3 separate parts:
+# * country_code - e.g. '385', '386'
+# * area_code - e.g. '91', '47'
+# * number - e.g. '5125486', '451588'
+#
+# All parts are mandatory, but country code and area code can be set for all phone numbers using
+#   Phone.default_country_code
+#   Phone.default_area_code
+#
+require 'active_support'
+require File.join(File.dirname(__FILE__), 'phone_country')
+class Phone    
+  NUMBER = '([^0][0-9]{1,7})$'  
+  DEFAULT_AREA_CODE = '[2-9][0-8][0-9]' # USA
+  
+  attr_accessor :country_code, :area_code, :number
+  
+  cattr_accessor :default_country_code
+  cattr_accessor :default_area_code  
+  cattr_accessor :named_formats
+  
+  # length of first number part (using multi number format)
+  cattr_accessor :n1_length
+  # default length of first number part
+  @@n1_length = 3
+  
+  @@named_formats = {
+    :default => "+%c%a%n",
+    :europe => '+%c (0) %a %f %l',
+    :us => "(%a) %f-%l"
+  }
+  
+  def initialize(*hash_or_args)    
+    if hash_or_args.first.is_a?(Hash)
+      hash_or_args = hash_or_args.first
+      keys = {:number => :number, :area_code => :area_code, :country_code => :country_code}
+    else
+      keys = {:number => 0, :area_code => 1, :country_code => 2}
+    end
+    
+    self.number = hash_or_args[ keys[:number] ]
+    self.area_code = hash_or_args[ keys[:area_code] ] || self.default_area_code
+    self.country_code = hash_or_args[ keys[:country_code] ] || self.default_country_code      
+
+    raise "Must enter number" if self.number.blank?
+    raise "Must enter area code or set default area code" if self.area_code.blank?
+    raise "Must enter country code or set default country code" if self.country_code.blank?    
+  end
+  
+  # create a new phone number by parsing a string
+  # the format of the string is detect automatically (from FORMATS)
+  def self.parse(string, options={})       
+    if string.present?    
+      PhoneCountry.load
+      string = normalize(string)
+      
+      options[:country_code] ||= self.default_country_code
+      options[:area_code] ||= self.default_area_code         
+      
+      parts = split_to_parts(string, options)      
+      
+      pn = Phone.new(parts) if parts
+    end
+  end
+  
+  # is this string a valid phone number?
+  def self.valid?(string)
+    begin
+      parse(string).present?
+    rescue RuntimeError # if we encountered exceptions (missing country code, missing area code etc)
+      return false
+    end
+  end
+  
+  # split string into hash with keys :country_code, :area_code and :number
+  def self.split_to_parts(string, options = {})
+    country = detect_country(string)
+    
+    if country
+      options[:country_code] = country.country_code      
+      string = string.gsub(country.country_code_regexp, '0')
+    else
+      if options[:country_code]
+        country = PhoneCountry.find_by_country_code options[:country_code]
+      end
+    end
+    
+    if country.nil?
+      if options[:country_code].nil?
+        raise "Must enter country code or set default country code"
+      else
+        raise "Could not find country with country code #{options[:country_code]}"
+      end
+    end
+            
+    format = detect_format(string, country)
+    
+    return nil if format.nil?    
+
+    parts = string.match formats(country)[format]
+
+    case format  
+      when :short
+        {:number => parts[2], :area_code => parts[1], :country_code => options[:country_code]}            
+      when :really_short
+        {:number => parts[1], :area_code => options[:area_code], :country_code => options[:country_code]}                      
+    end    
+  end
+  
+  # detect country from the string entered
+  def self.detect_country(string)
+    detected_country = nil
+    # find if the number has a country code
+    PhoneCountry.all.each_pair do |country_code, country|
+      if string =~ country.country_code_regexp
+        detected_country = country
+      end
+    end
+    detected_country    
+  end
+  
+  def self.formats(country)
+    area_code_regexp = country.area_code || DEFAULT_AREA_CODE
+    {
+      # 047451588, 013668734
+      :short => Regexp.new('^0(' + area_code_regexp + ')' + NUMBER),
+      # 451588
+      :really_short => Regexp.new('^' + NUMBER)
+    }    
+  end
+  
+  # detect format (from FORMATS) of input string
+  def self.detect_format(string_with_number, country)
+    arr = []
+    formats(country).each_pair do |format, regexp|
+      arr << format if string_with_number =~ regexp
+    end
+    
+    raise "Detected more than 1 format for #{string_with_number}" if arr.size > 1
+    arr.first
+  end
+  
+  # fix string so it's easier to parse, remove extra characters etc.
+  def self.normalize(string_with_number)
+    string_with_number.gsub("(0)", "").gsub(/[^0-9+]/, '').gsub(/^00/, '+')
+  end
+  
+  # format area_code with trailing zero (e.g. 91 as 091)
+  def area_code_long
+    "0" + area_code if area_code
+  end
+  
+  # first n characters of :number
+  def number1
+    number[0...self.class.n1_length]
+  end
+  
+  # everything left from number after the first n characters (see number1)
+  def number2
+    n2_length = number.size - self.class.n1_length
+    number[-n2_length, n2_length]
+  end
+  
+  # Formats the phone number.
+  # 
+  # if the method argument is a String, it is used as a format string, with the following fields being interpolated:  
+  #
+  # * %c - country_code (385)
+  # * %a - area_code (91)
+  # * %A - area_code with leading zero (091)
+  # * %n - number (5125486)
+  # * %n1 - first @@n1_length characters of number (configured through Phone.n1_length), default is 3 (512)
+  # * %n2 - last characters of number (5486)
+  #
+  # if the method argument is a Symbol, it is used as a lookup key for a format String in Phone.named_formats
+  #   pn.format(:europe)
+  def format(fmt)    
+    if fmt.is_a?(Symbol)
+      raise "The format #{fmt} doesn't exist'" unless named_formats.has_key?(fmt)
+      format_number named_formats[fmt]
+    else
+      format_number(fmt)
+    end
+  end
+  
+  # the default format is "+%c%a%n"
+  def to_s
+    format(:default)
+  end
+  
+  # does this number belong to the default country code?
+  def has_default_country_code?
+    country_code == self.class.default_country_code
+  end
+  
+  # does this number belong to the default area code?
+  def has_default_area_code?
+    area_code == self.class.default_area_code
+  end
+  
+  private
+  
+  def format_number(fmt)
+    fmt.gsub("%c", country_code || "").
+           gsub("%a", area_code || "").
+           gsub("%A", area_code_long || "").           
+           gsub("%n", number || "").
+           gsub("%f", number1 || "").
+           gsub("%l", number2 || "")                          
+  end
+end

data/lib/phone_country.rb

@@ -0,0 +1,28 @@
+require 'active_support'
+class PhoneCountry < Struct.new(:name, :country_code, :char_2_code, :area_code)
+  cattr_accessor :all
+  
+  def self.load
+    return @@all if @@all.present?
+    
+    data_file = File.join(File.dirname(__FILE__), '..', 'data', 'phone_countries.yml')
+    
+    @@all = {}
+    YAML.load(File.read(data_file)).each_pair do |key, c|
+      @@all[key] = PhoneCountry.new(c[:name], c[:country_code], c[:char_2_code], c[:area_code])
+    end
+    @@all
+  end
+  
+  def to_s
+    name
+  end
+  
+  def self.find_by_country_code(code)
+    @@all[code]    
+  end
+  
+  def country_code_regexp
+    Regexp.new("^[+]#{country_code}")    
+  end
+end

data/test/phone_country_test.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class PhoneCountryTest < Test::Unit::TestCase
+  def test_parse_germany_local
+    pn = Phone.parse('+49 714 1605832')    
+
+    assert_equal pn.country_code, '49'
+    assert_equal pn.area_code, '714'
+    assert_equal pn.number, '1605832'
+  end
+  
+  def test_parse_germany_mobile
+    pn = Phone.parse('+49 162 3499558')
+
+    assert_equal pn.country_code, '49'
+    assert_equal pn.area_code, '162'
+    assert_equal pn.number, '3499558'
+  end  
+  
+  def test_parse_hungary_mobile
+    pn = Phone.parse('+36 30 5517999')    
+
+    assert_equal pn.country_code, '36'
+    assert_equal pn.area_code, '30'
+    assert_equal pn.number, '5517999'
+  end  
+  
+  def test_parse_slovenia_local
+    #Maribor
+    pn = Phone.parse '+ 386 2 23 46 611'
+    
+    assert_equal pn.country_code, '386'
+    assert_equal pn.area_code, '2'
+    assert_equal pn.number, '2346611'    
+  end
+  
+  def test_parse_slovenia_local_2
+    # Koper
+    pn = Phone.parse '+ 386 5 23 46 611'
+    
+    assert_equal pn.country_code, '386'
+    assert_equal pn.area_code, '5'
+    assert_equal pn.number, '2346611'    
+  end  
+  
+  def test_parse_slovenia_mobile
+    # Mobitel
+    pn = Phone.parse('+386 51 258999')    
+
+    assert_equal pn.country_code, '386'
+    assert_equal pn.area_code, '51'
+    assert_equal pn.number, '258999'
+  end
+  
+  def test_parse_serbia_local
+    # Beograd
+    pn = Phone.parse('+381 11 24 33 836')
+
+    assert_equal pn.country_code, '381'
+    assert_equal pn.area_code, '11'
+    assert_equal pn.number, '2433836'
+  end
+  
+  
+  def test_parse_serbia_mobile
+    # mts
+    pn = Phone.parse('+381 648542987')
+
+    assert_equal pn.country_code, '381'
+    assert_equal pn.area_code, '64'
+    assert_equal pn.number, '8542987'
+  end  
+  
+  def test_parse_bosnia_local
+    pn = Phone.parse '+387 33 25 02 33'
+    
+    assert_equal pn.country_code, '387'
+    assert_equal pn.area_code, '33'
+    assert_equal pn.number, '250233'    
+  end
+
+  def test_parse_south_africa_local
+    # Telkom
+    pn = Phone.parse('+27 11 555 5555')
+
+    assert_equal pn.country_code, '27'
+    assert_equal pn.area_code, '11'
+    assert_equal pn.number, '5555555'
+  end
+
+  def test_parse_south_africa_mobile
+    # Vodacom
+    pn = Phone.parse('+27 82 555 5555')
+
+    assert_equal pn.country_code, '27'
+    assert_equal pn.area_code, '82'
+    assert_equal pn.number, '5555555'
+  end
+
+  def test_parse_south_africa_tollfree
+    # Telkom
+    pn = Phone.parse('+27 800 123 321')
+
+    assert_equal pn.country_code, '27'
+    assert_equal pn.area_code, '800'
+    assert_equal pn.number, '123321'
+  end
+end

data/test/phone_test.rb

@@ -0,0 +1,207 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class PhoneTest < Test::Unit::TestCase
+  
+  def test_number_without_country_code_initialize    
+    Phone.default_country_code = nil
+    
+    assert_raise RuntimeError do
+      pn = Phone.new '5125486', '91'
+    end
+  end
+  
+  def test_number_without_country_and_area_code_initialize    
+    Phone.default_country_code = nil
+    Phone.default_area_code = nil    
+    
+    assert_raise RuntimeError do
+      pn = Phone.new '451588'
+    end
+  end  
+  
+  def test_number_with_default_area_code_initialize    
+    Phone.default_country_code = '385'
+    Phone.default_area_code = '47'    
+    
+    pn = Phone.new '451588'
+    assert pn.number == '451588'
+    assert pn.area_code == '47'    
+    assert pn.country_code == '385' 
+  end    
+  
+  def test_number_with_default_country_code_initialize
+    Phone.default_country_code = '386'
+    
+    pn = Phone.new '5125486', '91'
+    assert pn.number == '5125486'
+    assert pn.area_code == '91'    
+    assert pn.country_code == '386'    
+  end  
+  
+  def test_number_with_country_code_initialize
+    Phone.default_country_code = '387'
+    
+    pn = Phone.new '5125486', '91', '385'
+    assert pn.number == '5125486'
+    assert pn.area_code == '91'
+    assert pn.country_code == '385'
+  end  
+  
+  def test_parse_empty
+    assert_equal Phone.parse(''), nil
+    assert_equal Phone.parse(nil), nil
+  end
+  
+  def test_parse_long_without_special_characters
+    pn = Phone.parse "+385915125486"
+    
+    assert_equal pn.number, '5125486'
+    assert_equal pn.area_code, '91'
+    assert_equal pn.country_code, '385'    
+  end
+  
+  def test_parse_zagreb_long_without_special_characters
+    pn = Phone.parse "+38513668734"
+    
+    assert_equal pn.number, '3668734'
+    assert_equal pn.area_code, '1'
+    assert_equal pn.country_code, '385'    
+  end  
+  
+  def test_parse_long_with_special_characters
+    pn = Phone.parse "+ 385 (91) 512 / 5486 "
+    
+    assert pn.number == '5125486'
+    assert pn.area_code == '91'
+    assert pn.country_code == '385'    
+  end  
+  
+  def test_parse_long_with_leading_zeros
+    pn = Phone.parse "00385915125486"
+    
+    assert pn.number == '5125486'
+    assert pn.area_code == '91'
+    assert pn.country_code == '385'    
+  end  
+  
+  def test_parse_zagreb_long_with_leading_zeros
+    pn = Phone.parse "0038513668734"
+    
+    assert pn.number == '3668734'
+    assert pn.area_code == '1'
+    assert pn.country_code == '385'    
+  end     
+  
+  def test_parse_short_without_special_characters_without_country
+    Phone.default_country_code = nil
+     
+    assert_raise RuntimeError do   
+      pn = Phone.parse "0915125486"
+    end
+  end  
+  
+  def test_parse_short_without_special_characters_with_country
+    Phone.default_country_code = '385'
+        
+    pn = Phone.parse "044885047"
+    
+    assert_equal pn.number, '885047'
+    assert_equal pn.area_code, '44'
+    assert pn.country_code == '385'
+  end  
+  
+  def test_parse_zagreb_short_without_special_characters_with_country
+    Phone.default_country_code = '385'
+        
+    pn = Phone.parse "013668734"
+    
+    assert_equal pn.number, '3668734'
+    assert_equal pn.area_code, '1'
+    assert_equal pn.country_code, '385'
+  end     
+  
+  def test_parse_short_with_special_characters_without_country
+    Phone.default_country_code = nil
+        
+    assert_raise RuntimeError do
+      pn = Phone.parse "091/512-5486"
+    end
+  end      
+  
+  def test_parse_long_with_zero_in_brackets
+    Phone.default_country_code = nil
+    
+    pn = Phone.parse '+385 (0)1 366 8111'    
+    assert_equal pn.country_code, '385'
+    assert_equal pn.area_code, '1'
+    assert_equal pn.number, '3668111'
+  end
+  
+  
+  
+  def test_to_s
+    Phone.default_country_code = nil    
+    pn = Phone.new '5125486', '91', '385'
+    assert pn.to_s == '+385915125486'
+  end  
+  
+  def test_to_s_without_country_code
+    Phone.default_country_code = '385'   
+    pn = Phone.new '5125486', '91'
+    assert pn.format("0%a%n") == '0915125486'
+  end
+  
+  def test_format_special_with_country_code
+    Phone.default_country_code = nil    
+    pn = Phone.new '5125486', '91', '385'
+    assert pn.format("+ %c (%a) %n") == '+ 385 (91) 5125486'
+  end  
+  
+  def test_format_special_without_country_code
+    Phone.default_country_code = '385'    
+    pn = Phone.new '5125486', '91'
+    assert_equal pn.format("%A/%f-%l"), '091/512-5486'
+  end  
+  
+  def test_format_with_symbol_specifier
+    Phone.default_country_code = nil    
+    pn = Phone.new '5125486', '91', '385'
+    assert_equal pn.format(:europe), '+385 (0) 91 512 5486'
+  end    
+  
+  def test_doesnt_validate
+    assert_equal Phone.valid?('asdas'), false
+    assert_equal Phone.valid?('385915125486'), false
+  end
+  
+  def test_validates
+    Phone.default_country_code = nil
+    assert_equal Phone.valid?('00385915125486'), true                    
+    assert_equal Phone.valid?('+385915125486'), true
+    assert_equal Phone.valid?('+385 (91) 512 5486'), true                  
+    assert_equal Phone.valid?('+38547451588'), true            
+
+    Phone.default_country_code = '385'    
+    assert_equal Phone.valid?('0915125486'), true
+    assert_equal Phone.valid?('091/512-5486'), true
+    assert_equal Phone.valid?('091/512-5486'), true
+    assert_equal Phone.valid?('091 512 54 86'), true    
+    assert_equal Phone.valid?('091-512-54-86'), true    
+    assert_equal Phone.valid?('047/451-588'), true    
+  end
+  
+  def test_has_default_country_code
+    Phone.default_country_code = '385'
+    
+    assert_equal Phone.parse('+38547451588').has_default_country_code?, true
+    assert_equal Phone.parse('+38647451588').has_default_country_code?, false
+  end
+  
+  def test_has_default_area_code
+    Phone.default_country_code = '385'    
+    Phone.default_area_code = '47'
+    
+    assert_equal Phone.parse('047/451-588').has_default_area_code?, true
+    assert_equal Phone.parse('032/336-1456').has_default_area_code?, false
+  end  
+end