phone 1.2.3 → 1.3.0.beta0

data/lib/phone.rb

@@ -1,5 +1,5 @@
 # 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'
@@ -9,34 +9,55 @@
 #   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')
-require File.join(File.dirname(__FILE__), 'errors')
+require "phone/country"
+require "phone/errors"
 
 module Phoner
   class Phone
-    NUMBER = '([0-9]{1,8})$'  
-    DEFAULT_AREA_CODE = '[0-9][0-9][0-9]' # any 3 digits
+    module ClassAttributes
+      attr_accessor :default_country_code
+      attr_accessor :default_area_code
+      attr_accessor :named_formats
+      attr_accessor :n1_length
+    end
+    extend ClassAttributes
 
-    attr_accessor :country_code, :area_code, :number, :extension
+    module ClassAttributeAccessors
+      def default_country_code
+        self.class.default_country_code
+      end
 
-    cattr_accessor :default_country_code
-    cattr_accessor :default_area_code  
-    cattr_accessor :named_formats
+      def default_area_code
+        self.class.default_area_code
+      end
 
-    # length of first number part (using multi number format)
-    cattr_accessor :n1_length
-    # default length of first number part
-    @@n1_length = 3
+      def named_formats
+        self.class.named_formats
+      end
+
+      def n1_length
+        self.class.n1_length
+      end
+    end
+    include ClassAttributeAccessors
+
+    NUMBER = '([0-9]{1,8})$'
+    DEFAULT_AREA_CODE = '[0-9][0-9][0-9]' # any 3 digits
 
-    @@named_formats = {
+    attr_accessor :country_code, :area_code, :number, :extension
+
+    self.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)    
+    # length of first number part (using multi number format)
+    # default length of first number part
+    self.n1_length = 3
+
+    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}
@@ -44,41 +65,39 @@ module Phoner
         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.number = hash_or_args[ keys[:number] ].to_s.strip
+      self.area_code = (hash_or_args[ keys[:area_code] ] || self.default_area_code).to_s.strip
+      self.country_code = (hash_or_args[ keys[:country_code] ] || self.default_country_code).to_s.strip
       self.extension = hash_or_args[ keys[:extension] ]
 
-      raise NumberError, "Must enter number" if self.number.blank?
-      raise AreaCodeError, "Must enter area code or set default area code" if self.area_code.blank?
-      raise CountryCodeError, "Must enter country code or set default country code" if self.country_code.blank?
+      raise BlankNumberError, "Must enter number" if self.number.empty?
+      raise AreaCodeError, "Must enter area code or set default area code" if self.area_code.empty?
+      raise CountryCodeError, "Must enter country code or set default country code" if self.country_code.empty?
     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?    
-        Country.load
-        extension = extract_extension(string)
-        string = normalize(string)
+    def self.parse(string, options={})
+      return if string.to_s.empty?
 
-        options[:country_code] ||= self.default_country_code
-        options[:area_code] ||= self.default_area_code         
+      Country.load
+      extension = extract_extension(string)
+      string = normalize(string)
 
-        parts = split_to_parts(string, options)      
+      options[:country_code] ||= self.default_country_code
+      options[:area_code] ||= self.default_area_code
 
-        pn = Phone.new(parts) if parts
-        if pn.present? and extension.present?
-          pn.extension = extension
-        end
-        return pn
-      end
+      parts = split_to_parts(string, options)
+
+      pn = Phone.new(parts.merge(:extension => extension)) if parts
+      return pn
     end
 
+
     # is this string a valid phone number?
-    def self.valid?(string)
+    def self.valid?(string, options = {})
       begin
-        parse(string).present?
+        !parse(string, options).nil?
       # if we encountered exceptions (missing country code, missing area code etc)
       rescue PhoneError
         return false
@@ -90,7 +109,7 @@ module Phoner
       country = detect_country(string)
 
       if country
-        options[:country_code] = country.country_code      
+        options[:country_code] = country.country_code
         string = string.gsub(country.country_code_regexp, '0')
       else
         if options[:country_code]
@@ -107,17 +126,20 @@ module Phoner
       end
 
       format = detect_format(string, country)
+      return nil if format.nil?
 
-      return nil if format.nil?    
+      # Override the format IF overriding options are not present
+      format = :short if options[:area_code].nil?
 
       parts = string.match formats(country)[format]
+      return nil if parts.nil?
 
-      case format  
+      case format
         when :short
-          {:number => parts[2], :area_code => parts[1], :country_code => options[:country_code]}            
+          {: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    
+          {:number => parts[1], :area_code => options[:area_code], :country_code => options[:country_code]}
+      end
     end
 
     # detect country from the string entered
@@ -129,7 +151,7 @@ module Phoner
           detected_country = country
         end
       end
-      detected_country    
+      detected_country
     end
 
     def self.formats(country)
@@ -139,7 +161,7 @@ module Phoner
         :short => Regexp.new('^0?(' + area_code_regexp + ')' + NUMBER),
         # 451588
         :really_short => Regexp.new('^' + NUMBER)
-      }    
+      }
     end
 
     # detect format (from FORMATS) of input string
@@ -201,8 +223,8 @@ module Phoner
     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:  
+    #
+    # 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)
@@ -214,7 +236,7 @@ module Phoner
     #
     # 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)    
+    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]
@@ -237,24 +259,24 @@ module Phoner
     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    
+    end
 
     private
 
     def format_number(fmt)
       result = fmt.gsub("%c", country_code || "").
              gsub("%a", area_code || "").
-             gsub("%A", area_code_long || "").           
+             gsub("%A", area_code_long || "").
              gsub("%n", number || "").
              gsub("%f", number1 || "").
              gsub("%l", number2 || "").
              gsub("%x", extension || "")
       return result
     end
-  end  
+  end
 end

data/lib/phone/country.rb

@@ -0,0 +1,45 @@
+require 'yaml'
+
+module Phoner
+  class Country < Struct.new(:name, :country_code, :char_2_code, :char_3_code, :area_code)
+    module All
+      attr_accessor :all
+    end
+    extend All
+
+    def all
+      self.class.all
+    end
+
+    def self.load
+      return self.all if !self.all.nil? && !self.all.empty?
+
+      data_file = File.expand_path(File.join('..','..','data', 'phone', 'countries.yml'), File.dirname(__FILE__))
+
+      self.all = {}
+      YAML.load(File.read(data_file)).each_pair do |key, c|
+        self.all[key] = Country.new(c[:name], c[:country_code], c[:char_2_code], c[:char_3_code], c[:area_code])
+      end
+      self.all
+    end
+
+    def to_s
+      name
+    end
+
+    def self.find_by_country_code(code)
+      self.all[code]
+    end
+    
+    def self.find_by_country_isocode(isocode)
+      if country = self.all.detect{|c|c[1].char_3_code.downcase == isocode}
+        country[1]
+      end
+    end
+
+    def country_code_regexp
+      @country_code_regexp ||= Regexp.new("^[+]#{country_code}")
+    end
+  end
+
+end

data/lib/phone/version.rb

@@ -0,0 +1,4 @@
+module Phone
+  # phone version
+  VERSION = "1.3.0.beta0"
+end

data/phone.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path("../lib/phone/version", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "phone"
+  gem.version       = Phone::VERSION
+  gem.summary       = %q{Phone number parsing, validation and formatting}
+  gem.description   = %q{Phone number parsing, validation and formatting in Ruby}
+  gem.license       = "MIT"
+  gem.authors       = ["Tomislav Carr", "Todd Eichel", "Don Morrison"]
+  gem.email         = ["tomislav@infinum.hr", "todd@toddeichel.com", "don@elskwid.net"]
+  gem.homepage      = "https://github.com/carr/phone#readme"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "bundler", "~> 1.2"
+  gem.add_development_dependency "minitest", "~> 5.0"
+  gem.add_development_dependency "rake", "~> 10.0"
+  gem.add_development_dependency "rubygems-tasks", "~> 0.2"
+  gem.add_development_dependency "yard", "~> 0.8"
+end

data/test/countries/au_test.rb

@@ -1,49 +1,49 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require "helper"
 
 # 0x 5551 reserved for fictitious use. (not including x=3)
 # 0x 7010 reserved for fictitious use.
 
 ## Australia
-class AUTest < Test::Unit::TestCase
-  
+class AUTest < Minitest::Test
+
   # 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')
   end
-  
+
   # 05 Universal/Personal numberings (uncommon)
   def test_personal
     parse_test('+61 5 5551 1234', '61', '5', '55511234')
   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

data/test/countries/ba_test.rb

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

data/test/countries/be_test.rb

@@ -1,8 +1,9 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+# -*- coding: utf-8 -*-
+require "helper"
 
 ## Belgium
-class BETest < Test::Unit::TestCase
-  
+class BETest < Minitest::Test
+
   ## single digit
   # 02:   Brussels (Bruxelles/Brussel)
   def test_brussels
@@ -20,7 +21,7 @@ class BETest < Test::Unit::TestCase
   def test_gent
     parse_test('+32 9 1234567', '32', '9', '1234567')
   end
-  
+
   ## two digit
   # 010:  Wavre (Waver)
   def test_wavre
@@ -45,7 +46,7 @@ class BETest < Test::Unit::TestCase
   def test_waremme
     parse_test('+32 19 123456', '32', '19', '123456')
   end
-  
+
   # 050:  Brugge (Bruges), Zeebrugge
   def test_brugge
     parse_test('+32 50 123456', '32', '50', '123456')
@@ -65,7 +66,7 @@ class BETest < Test::Unit::TestCase
   def test_oostende
     parse_test('+32 59 123456', '32', '59', '123456')
   end
-  
+
   # 060:  Chimay
   def test_chimay
     parse_test('+32 60 123456', '32', '60', '123456')
@@ -80,13 +81,13 @@ class BETest < Test::Unit::TestCase
   end
   # 068:  Ath (Aat)
   # 069:  Tournai (Doornik)
-  
+
   # 070:  Specialty Numbers (i.e. bus information or bank information)
   def test_specialty
     parse_test('+32 70 123456', '32', '70', '123456')
   end
   # 071:  Charleroi
-  
+
   # 081:  Namur (Namen)
   def test_namur
     parse_test('+32 81 123456', '32', '81', '123456')
@@ -103,14 +104,14 @@ class BETest < Test::Unit::TestCase
   def test_toll_free
     parse_test('+32 800 12345', '32', '800', '12345')
   end
-  
+
   # 090x: Premium numbers (0900, 0901, 0902, 0903, 0904, 0905, 0906, 0907, 0908, 0909)
   def test_premium_900
     parse_test('+32 900 12345', '32', '900', '12345')
   end
-  
+
   def test_premium_901
     parse_test('+32 901 12345', '32', '901', '12345')
   end
-  
+
 end