elskwid-phone 0.9.9.2

data/lib/phone.rb

@@ -0,0 +1,249 @@
+# 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 File.join(File.dirname(__FILE__), 'support') unless defined? ActiveSupport
+require File.join(File.dirname(__FILE__), 'phone_country')
+class Phone
+  NUMBER = '([0-9]{1,8})$'  
+  DEFAULT_AREA_CODE = '[2-9][0-8][0-9]' # USA
+  
+  attr_accessor :country_code, :area_code, :number, :extension
+  
+  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",
+    :default_with_extension => "+%c%a%nx%x",
+    :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, :extension => :extension}
+    else
+      keys = {:number => 0, :area_code => 1, :country_code => 2, :extension => 3}
+    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      
+    self.extension = hash_or_args[ keys[:extension] ]
+
+    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
+      extension = extract_extension(string)
+      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
+      if pn.present? and extension.present?
+        pn.extension = extension
+      end
+      return pn
+    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
+    if arr.length > 1
+#      puts %Q{detect_format: more than one format found - #{arr.inspect}}
+      return :really_short
+    end
+    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
+
+  # pull off anything that look like an extension
+  #TODO: refactor things so this doesn't change string as a side effect
+  #
+  def self.extract_extension(string)
+    return nil if string.nil?
+    if string.sub! /[ ]*(ext|ex|x|xt|#|:)+[^0-9]*\(*([-0-9]{1,})\)*#?$/i, ''
+      extension = $2
+      return extension
+    end
+    #
+    # We already returned any recognizable extension.
+    # However, we might still have extra junk to the right
+    # of the phone number proper, so just chop it off.
+    #
+    idx = string.rindex(/[0-9]/)
+    return nil if idx.nil?
+    return nil if idx == (string.length - 1)      # at the end
+    string.slice!((idx+1)..-1)                    # chop it
+    return nil
+  end
+
+  # format area_code with trailing zero (e.g. 91 as 091)
+  # 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)
+  # * %f - first @@n1_length characters of number (configured through Phone.n1_length), default is 3 (512)
+  # * %l - last characters of number (5486)
+  # * %x - entire extension
+  #
+  # 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)
+    result = fmt.gsub("%c", country_code || "").
+           gsub("%a", area_code || "").
+           gsub("%A", area_code_long || "").           
+           gsub("%n", number || "").
+           gsub("%f", number1 || "").
+           gsub("%l", number2 || "").
+           gsub("%x", extension || "")
+    return result
+  end
+end

data/lib/phone_country.rb

@@ -0,0 +1,27 @@
+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/lib/support.rb

@@ -0,0 +1,78 @@
+require 'yaml'
+# support methods to remove dependencies on ActiveSupport
+class String
+  def present?
+    !blank?
+  end
+
+  def blank?
+    if respond_to?(:empty?) && respond_to?(:strip) 
+      empty? or strip.empty? 
+    elsif respond_to?(:empty?) 
+      empty? 
+    else 
+      !self 
+    end     
+  end
+end
+
+class Hash
+  alias_method :blank?, :empty? 
+
+  def present?
+    !blank?
+  end   
+end
+
+class Object
+  def present?
+    self.class!=NilClass
+  end
+end
+
+class NilClass #:nodoc: 
+  def blank? 
+    true 
+  end 
+
+  def present?
+    false
+  end
+end
+
+module Accessorize
+  module ClassMethods
+    def cattr_accessor(*syms)
+      syms.flatten.each do |sym|
+        class_eval(<<-EOS, __FILE__, __LINE__)
+          unless defined? @@#{sym}
+            @@#{sym} = nil
+          end
+
+          def self.#{sym}
+            @@#{sym}
+          end
+
+          def #{sym}=(value)
+            @@#{sym} = value
+          end
+
+          def self.#{sym}=(value)
+            @@#{sym} = value
+          end
+
+          def #{sym}
+            @@#{sym}
+          end
+        EOS
+      end
+    end    
+  end
+
+
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+  end
+end
+
+Object.send(:include, Accessorize)

data/test/countries/ba_test.rb

@@ -0,0 +1,10 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+## Bosnia and Herzegovina
+class BATest < Test::Unit::TestCase
+  
+  def test_local
+    parse_test('+387 33 25 02 33', '387', '33', '250233')
+  end
+  
+end

data/test/countries/de_test.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+## Germany
+class DETest < Test::Unit::TestCase
+
+  def test_local
+    parse_test('+49 714 1605832', '49', '714', '1605832')
+  end
+  
+  def test_mobile
+    parse_test('+49 162 3499558', '49', '162', '3499558')
+  end  
+  
+end

data/test/countries/fr_test.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+## France
+class FRTest < Test::Unit::TestCase
+
+  def test_local
+    parse_test('+33 4 75 06 07 07', '33', '4', '75060707')
+  end
+  
+  def test_mobile
+    parse_test('+33 6 11 22 33 44', '33', '6', '11223344')
+  end
+
+  def test_voip
+    parse_test('+33 9 11 22 33 44', '33', '9', '11223344')
+  end
+  
+end

data/test/countries/gb_test.rb

@@ -0,0 +1,196 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+# http://stakeholders.ofcom.org.uk/telecoms/numbering/guidance-tele-no/numbers-for-drama
+#
+# Geographic Area     Geographic Area Code  Telephone Number Range 
+# (1000 numbers in each range)
+# Leeds               0113                  496 0000 to 496 0999
+# Sheffield           0114                  496 0000 to 496 0999
+# Nottingham          0115                  496 0000 to 496 0999
+# Leicester           0116                  496 0000 to 496 0999
+# Bristol             0117                  496 0000 to 496 0999
+# Reading             0118                  496 0000 to 496 0999
+# Birmingham          0121                  496 0000 to 496 0999
+# Edinburgh           0131                  496 0000 to 496 0999
+# Glasgow             0141                  496 0000 to 496 0999
+# Liverpool           0151                  496 0000 to 496 0999
+# Manchester          0161                  496 0000 to 496 0999
+# London              020                   7946 0000 to 7946 0999
+# Tyneside/Durham                           
+#/Sunderland          0191                  498 0000 to 498 0999
+# Northern Ireland    028                   9018 0000 to 9018 0999
+# Cardiff             029                   2018 0000 to 2018 0999
+# No area             01632                 960000 to 960999
+#  
+# Other Telephone Numbers
+#  
+# Telephone Number Type   Telephone Number Range 
+# (1000 numbers in each range)
+# Mobile                  07700 900000 to 900999
+# Freephone               08081 570000 to 570999
+# Premium Rate Services   0909 8790000 to 8790999
+# UK Wide                 03069 990000 to 990999
+
+class GBTest < Test::Unit::TestCase
+  
+  ## SHORT CODES
+  # London              020                   7946 0000 to 7946 0999
+  def test_london
+    parse_test('+44 20 7946 0123', '44', '20', '79460123') 
+  end
+  
+  # Northern Ireland    028                   9018 0000 to 9018 0999
+  def test_northern_ireland
+    parse_test('+44 28 9018 0123', '44', '28', '90180123')
+  end
+  
+  # Cardiff             029                   2018 0000 to 2018 0999
+  def test_cardiff
+    parse_test('+44 29 2018 0123', '44', '29', '20180123')
+  end
+
+  # Leeds               0113                  496 0000 to 496 0999
+  def test_leeds
+    parse_test('+44 113 496 0123', '44', '113', '4960123')
+  end
+
+  # Sheffield           0114                  496 0000 to 496 0999
+  def test_sheffield
+    parse_test('+44 114 496 0123', '44', '114', '4960123')
+  end
+  
+  # Nottingham          0115                  496 0000 to 496 0999
+  def test_nottingham
+    parse_test('+44 115 496 0123', '44', '115', '4960123')
+  end
+  
+  # Leicester           0116                  496 0000 to 496 0999
+  def test_leicester
+    parse_test('+44 116 496 0123', '44', '116', '4960123')
+  end
+  
+  # Bristol             0117                  496 0000 to 496 0999
+  def test_bristol
+    parse_test('+44 117 496 0123', '44', '117', '4960123')
+  end
+  
+  # Reading             0118                  496 0000 to 496 0999
+  def test_reading
+    parse_test('+44 118 496 0123', '44', '118', '4960123')
+  end
+  
+  # Birmingham          0121                  496 0000 to 496 0999
+  def test_birmingham
+    parse_test('+44 121 496 0123', '44', '121', '4960123')
+  end
+  
+  # Edinburgh           0131                  496 0000 to 496 0999
+  def test_edinburgh
+    parse_test('+44 131 496 0123', '44', '131', '4960123')
+  end
+  
+  # Glasgow             0141                  496 0000 to 496 0999
+  def test_glasgow
+    parse_test('+44 141 496 0123', '44', '141', '4960123')
+  end
+  
+  # Liverpool           0151                  496 0000 to 496 0999
+  def test_liverpool
+    parse_test('+44 151 496 0123', '44', '151', '4960123')
+  end
+  
+  # Manchester          0161                  496 0000 to 496 0999
+  def test_manchester
+    parse_test('+44 161 496 0123', '44', '161', '4960123')
+  end
+  
+  # Tyneside/Durham                           
+  #/Sunderland          0191                  498 0000 to 498 0999
+  def test_tyneside
+    parse_test('+44 191 496 0123', '44', '191', '4960123')
+  end
+  
+  ## LONG CODES
+  
+  # 01202 — Bournemouth (BO)
+  def test_bournemouth
+    parse_test('+44 1202 96 0123', '44', '1202', '960123')
+  end
+  
+  # 01326 — Falmouth (FA)
+  def test_falmouth
+    parse_test('+44 1326 96 0123', '44', '1326', '960123')
+  end
+  
+  # 01420 — Alton (HA)
+  def test_alton
+    parse_test('+44 1420 96 0123', '44', '1420', '960123')
+  end
+  
+  # 01598 — Lynton (LY)
+  def test_lynton
+    parse_test('+44 1598 96 0123', '44', '1598', '960123')
+  end
+  
+  # 01637 — Newquay (NE)
+  def test_newquay
+    parse_test('+44 1637 96 0123', '44', '1637', '960123')
+  end
+  
+  # 01700 — Rothesay (RO)
+  def test_rothesay
+    parse_test('+44 1700 96 0123', '44', '1700', '960123')
+  end
+  
+  # 01951 — Colonsay
+  def test_colonsay
+    parse_test('+44 1951 96 0123', '44', '1951', '960123')
+  end
+  
+  # No area             01632                 960000 to 960999
+  def test_no_area
+    parse_test('+44 1632 96 0123', '44', '1632', '960123')
+  end
+  
+  # Personal numbering  070 xxxx xxxx
+  def test_personal_numbering
+    parse_test('+44 70 00001234', '44', '70', '00001234')
+  end
+  
+  # Mobile                  07700 900000 to 900999
+  def test_mobile
+    parse_test('+44 7700 900345', '44', '7700', '900345')
+  end
+  
+  def test_mobile_2
+    parse_test('+44 7778 900345', '44', '7778', '900345')
+  end
+  
+  # Freephone               08081 570000 to 570999
+  def test_freephone
+    parse_test('+44 808 1570123', '44', '808', '1570123')
+  end
+  
+  def test_freephone_2
+    parse_test('+44 873 1570123', '44', '873', '1570123')
+  end
+  
+  # Premium Rate Services   0909 8790000 to 8790999
+  def test_premium
+    parse_test('+44 909 8790999', '44', '909', '8790999')
+  end
+  
+  def test_premium2
+    parse_test('+44 910 8790123', '44', '910', '8790123')
+  end
+  
+  # UK Wide                 03069 990000 to 990999
+  def test_wide
+    parse_test('+44 306 9990123', '44', '306', '9990123')
+  end
+  
+  def test_wide_2
+    parse_test('+44 339 9990123', '44', '339', '9990123')
+  end
+  
+end