superp-phone 1.1

data/lib/country.rb

@@ -0,0 +1,120 @@
+module Phoner
+  class Country < Struct.new(:name, :country_code, :char_2_code, :char_3_code, :area_code, :local_number_format, :mobile_format, :full_number_length, :number_format)
+    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|
+        next unless c[:area_code] && c[:local_number_format]
+        @@all << Country.new(c[:name], c[:country_code], c[:char_2_code], c[:char_3_code], c[:area_code], c[:local_number_format], c[:mobile_format], c[:full_number_length], c[:number_format])
+      end
+      @@all
+    end
+
+    def to_s
+      name
+    end
+
+    def self.find_all_by_phone_code(code)
+      return [] if code.nil?
+      @@all.select {|c| c.country_code == code }
+    end
+
+    def self.find_by_country_code(code)
+      return nil if code.nil?
+      @@all.each {|c| return c if c.char_3_code.downcase == code.downcase }
+      nil
+    end
+
+    def self.find_by_name(name)
+      return nil if name.nil?
+      @@all.each {|c| return c if c.name.downcase == name.downcase }
+      nil
+    end
+
+    # detect country from the string entered
+    def self.detect(string, default_country_code, default_area_code)
+      Country.find_all_by_phone_code(default_country_code).each do |country|
+        return country if country.matches_local_number?(string, default_area_code)
+      end
+
+      # find if the number has a country code
+      Country.all.each do |country|
+        return country if country.matches_full_number?(string)
+      end
+      return nil
+    end
+
+    def is_mobile?(number)
+      return true if mobile_format.nil?
+      number =~ mobile_number_regex ? true : false
+    end
+
+    def matches_local_number?(string, default_area_code)
+      ((string =~ full_number_regexp ||
+       string =~ area_code_number_regexp) && string =~ number_format_regex) ||
+      ((string =~ number_regex) && (default_area_code =~ area_code_regex))
+    end
+
+    def matches_full_number?(string)
+      string =~ full_number_regexp && string =~ number_format_regex
+    end
+
+    def number_parts(number, default_area_code)
+      number_part = if default_area_code
+        number.match(number_regex)
+        $1
+      else
+        nil
+      end
+
+      if number_part.nil?
+        matches = number.match(area_code_number_regexp)
+        area_part = $1
+        number_part = matches.to_a.last
+      end
+
+      if number_part.nil?
+        matches = number.match(full_number_regexp)
+        country_part, area_part = $1, $2
+        number_part = matches.to_a.last
+      end
+
+      area_part ||= default_area_code
+
+      raise "Could not determine area code" if area_part.nil?
+      raise "Could not determine number" if number_part.nil?
+
+      {:number => number_part, :area_code => area_part, :country_code => country_code, :country => self}
+    end
+
+    private
+    def number_format_regex
+      Regexp.new("^[+0]?(#{country_code})?(#{number_format})$")
+    end
+
+    def full_number_regexp
+      Regexp.new("^[+]?(#{country_code})(#{area_code})(#{local_number_format})$")
+    end
+
+    def area_code_number_regexp
+      Regexp.new("^0?(#{area_code})(#{local_number_format})$")
+    end
+
+    def area_code_regex
+      Regexp.new("^0?(#{area_code})$")
+    end
+
+    def mobile_number_regex
+      Regexp.new("^0?(#{mobile_format})$")
+    end
+
+    def number_regex
+      Regexp.new("^(#{local_number_format})$")
+    end
+  end
+end

data/lib/phone.rb

@@ -0,0 +1,218 @@
+# 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__), 'country')
+
+module Phoner
+  class Phone
+    attr_accessor :country_code, :area_code, :number, :extension, :country
+
+    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 = {:country => :country, :number => :number, :area_code => :area_code, :country_code => :country_code, :extension => :extension}
+      else
+        keys = {:number => 0, :area_code => 1, :country_code => 2, :extension => 3, :country => 4}
+      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] ]
+      self.country = hash_or_args[ keys[:country] ]
+
+      # Santity checks
+      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
+
+    def self.parse!(string, options={})
+        parse(string, options.merge(:raise_exception_on_error => true))
+    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={})
+      return nil unless string.present?
+
+      Country.load
+
+      extension = extract_extension(string)
+      normalized = normalize(string)
+
+      options[:country_code] ||= self.default_country_code
+      options[:area_code] ||= self.default_area_code
+
+      parts = split_to_parts(normalized, options)
+
+      pn = Phone.new(parts) if parts
+      if pn.present? and extension.present?
+        pn.extension = extension
+      end
+      pn
+    end
+
+    # is this string a valid phone number?
+    def self.valid?(string, options = {})
+      begin
+        parse(string, options).present?
+      rescue
+        false  # don't raise exceptions on parse errors
+      end
+    end
+
+    def self.is_mobile?(string, options = {})
+      pn = parse(string, options)
+      return false if pn.nil?
+      pn.is_mobile?
+    end
+
+    private
+    # split string into hash with keys :country_code, :area_code and :number
+    def self.split_to_parts(string, options = {})
+      country = Country.detect(string, options[:country_code], options[:area_code])
+
+      if country.nil?
+        raise "Could not determine country" if options[:raise_exception_on_error]
+        return nil
+      end
+
+      country.number_parts(string, options[:area_code])
+    end
+
+    # fix string so it's easier to parse, remove extra characters etc.
+    def self.normalize(string_with_number)
+      string_with_number.sub(extension_regex, '').gsub(/\(0\)|[^0-9+]/, '').gsub(/^00/, '+')
+    end
+
+    def self.extension_regex
+      /[ ]*(ext|ex|x|xt|#|:)+[^0-9]*\(*([-0-9]{1,})\)*#?$/i
+    end
+
+    # pull off anything that look like an extension
+    #
+    def self.extract_extension(string)
+      return nil if string.nil?
+      if string.match extension_regex
+        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
+
+    public # instance methods
+
+    def area_code_long
+      "0" + area_code if area_code
+    end
+
+    # For many countries it's not apparent from the number
+    # Will return false positives rather than false negatives.
+    def is_mobile?
+      country.is_mobile? "#{area_code}#{number}"
+    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
+
+    # comparison of 2 phone objects
+    def ==(other)
+      methods = [:country_code, :area_code, :number, :extension]
+      methods.all? { |method| other.respond_to?(method) && send(method) == other.send(method) }
+    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
+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/au_test.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+# 0x 5551 reserved for fictitious use. (not including x=3)
+# 0x 7010 reserved for fictitious use.
+
+## Australia
+class AUTest < Phoner::TestCase
+
+  # 00 Emergency and International access
+  # 01 Alternate phone services
+  # 014 Satellite phone services
+  # 016 Paging [+3D or +6D]
+  # 018 Analogue (AMPS) mobile phone - few numbers still in use [+6D]
+  # 0198 Data networks [+2D or +6D] - e.g. 0198 379 000 is the Dial-Up POP number for iiNet
+
+  # 02 Central East region (NSW, ACT)
+  def test_central_east
+    parse_test('+61 2 5551 1234', '61', '2', '55511234')
+  end
+
+  # 03 South-east region (VIC, TAS)
+  def test_south_east
+    parse_test('+61 3 5551 1234', '61', '3', '55511234')
+  end
+
+  # 04 Mobile services (Digital - GSM, CDMA, 3G)
+  def test_mobile
+    parse_test('+61 4 5551 1234', '61', '4', '55511234', 'Australia', true)
+  end
+
+  # 05 Universal/Personal numberings (uncommon)
+  def test_personal
+    parse_test('+61 5 5551 1234', '61', '5', '55511234', 'Australia', false)
+  end
+
+  # 07 North-east region (QLD)
+  def test_north_east
+    parse_test('+61 7 5551 1234', '61', '7', '55511234')
+  end
+
+  # 08 Central and West region (SA, NT, WA)
+  def test_central
+    parse_test('+61 8 5551 1234', '61', '8', '55511234')
+  end
+
+  # (Geographical region boundaries do not exactly follow state borders.)
+  # 1 Non-geographic numbers
+end