phonie 2.1.2 → 3.0.0

data/.travis.yml

@@ -4,12 +4,10 @@ before_install: gem install bundler
 before_script: export RUBY_GC_MALLOC_LIMIT=90000000
 
 rvm:
-  - 1.8.7
-  - 1.9.2
   - 1.9.3
   - 2.0.0
-  - rbx-18mode
-  - rbx-19mode
-  - ruby-head
+  - 2.1.0
+  - jruby-19mode
+  - rbx-2.2.3
 
 script: rake

data/Changelog.md

@@ -0,0 +1,14 @@
+3.0.0
+=====
+
+* ActiveModel validator no longer modifies phone numbers on validation. Use a before_save to do that!
+* configuration changes from Phonie::Phone.default_country_code to Phonie.configuration.default_country_code
+* adds Phone#possible_valid_number? and Phone#is_valid_number?
+* removes Phone#matches_full_number? Phone#matches_local_number_with_area_code? and Phone#matches_local_number?
+
+2.1.2
+=====
+
+* fixes Mauritius parsing
+* Support new Ecuador mobile numbers
+* fix for Russian mobile number detection

data/Readme.rdoc

@@ -3,7 +3,6 @@ Parsing, validating and creating phone numbers
 
 == Install
 You can install the phone library as a gem
-    gem sources -a http://gemcutter.org
     gem install phonie
 
 == Initializing
@@ -11,7 +10,7 @@ You can initialize a new phone object with the number, area code, country code a
 
     Phonie::Phone.new('5125486', '91', '385')
 or
-    Phonie::Phone.new(:number => '5125486', :area_code => '91', :country_code => '385', :extension => '143')
+    Phonie::Phone.new(number: '5125486', area_code: '91', country_code: '385', extension: '143')
 
 == Parsing
 You can create a new phone object by parsing from a string. Phonie::Phone does it's best to detect the country and area codes:
@@ -19,31 +18,29 @@ You can create a new phone object by parsing from a string. Phonie::Phone does i
     Phonie::Phone.parse '00385915125486'
 
 If the country or area code isn't given in the string, you must set it, otherwise it doesn't work:
-    Phonie::Phone.parse '091/512-5486', :country_code => '385'
-    Phonie::Phone.parse '(091) 512 5486', :country_code => '385'
+    Phonie::Phone.parse '091/512-5486', country_code: '385'
+    Phonie::Phone.parse '(091) 512 5486', country_code: '385'
 
 If you feel that it's tedious, set the default country code once (in your config/environment.rb):
-    Phonie::Phone.default_country_code = '385'
+    Phonie.configuration.default_country_code = '385'
     Phonie::Phone.parse '091/512-5486'
     Phonie::Phone.parse '(091) 512 5486'
 
 Same goes for the area code:
-    Phonie::Phone.parse '451-588', :country_code => '385', :area_code => '47'
-or
-    Phonie::Phone.default_country_code = '385'
-    Phonie::Phone.default_area_code = '47'
+    Phonie::Phone.parse '451-588', country_code: '385', area_code: '47'
+
+Alternatively Phonie can be configured via a block
+    Phonie.configure do |config|
+      config.default_country_code = '385'
+      config.default_area_code = '47'
+    end
 
     Phonie::Phone.parse '451-588'
 
 === Automatic country and area code detection
-Like it's stated above, Phone does it's best to automatically detect the country and area code while parsing. Do do this, 
-phone uses data stored in <tt>data/countries.yml</tt>.
-
-Each country code can have a regular expression named <tt>area_code</tt> that describes how the area code for that 
-particular country looks like.
+Like it's stated above, Phone does it's best to automatically detect the country and area code while parsing. To do this, phone uses data stored in <tt>data/countries.yml</tt>.
 
-If an <tt>area_code</tt> regular expression isn't specified, the default, <tt>Phonie::Phone::DEFAULT_AREA_CODE</tt> (correct for
-the US) is used.
+Each country code can have a regular expression named <tt>area_code</tt> that describes how the area code for that particular country looks like.
 
 == Validating
 Validating is very relaxed, basically it strips out everything that's not a number or '+' character:
@@ -58,7 +55,7 @@ When given a string, it interpolates the string with the following fields:
 * %a - area_code (91)
 * %A - area_code with leading zero (091)
 * %n - number (5125486)
-* %f - first @@n1_length characters of number (configured through Phonie::Phone.n1_length), default is 3 (512)
+* %f - first @@n1_length characters of number (configured through Phonie.n1_length), default is 3 (512)
 * %l - last characters of number (5486)
 * %x - the extension number
 
@@ -76,8 +73,25 @@ You can add your own custom named formats like so:
     Phonie::Phone.named_formats[:short] = '%A/%n1-%n2'
     pn.format(:short) # => 091/512-5486
 
+== ActiveModel validator
+
+Phonie includes an ActiveModel validator. If you are using ActiveModel you can validate phone numbers like so:
+
+	class SomeModel
+	  include ActiveModel::Validations
+
+	  validates :phone_number, phone: true
+	end
+
+        model = SomeModel.new(phone_number: '')
+	model.valid? # false
+
+	model = SomeModel.new(phone_number: '+1 251 123 4567')
+	model.valid?  # true
+
+
 = TODO
-Parse testing for different countries. 
+Add definitions for more countries
 
 Currently tested on:
 [AE] UAE
@@ -176,9 +190,7 @@ More testing is needed to add support for missing countries, and improve support
 The best places to start is to read through the country tests and data/phone_countries.rb 
 
 = Other libraries
-This is based off a fork of the Phone gem (https://github.com/carr/phone), and was extensively modified for better support of country detection
-
-Another fork based off this one is available at https://github.com/capitainetrain/phoner It explictly requires ActiveSupport.
+This is based off a fork of the Phone gem (https://github.com/carr/phone), and was extensively modified for better support of country detection, and supports far more countries.
 
 = Contributors
 Tomislav Carr, Don Morrison, Michael Squires, Todd Eichel (Fooala, Inc.), chipiga, Etienne Samson, Luke Randall, Wesley Moxam

data/lib/phonie.rb

@@ -1,10 +1,7 @@
 require "phonie/version"
-require "phonie/support" unless defined? ActiveSupport
+require "phonie/configuration"
+require "phonie/formatter"
 require "phonie/phone"
+require "phonie/parser"
 require "phonie/country"
-require "phonie/railties/validator"
-
-module Phonie
-end
-
-Phonie::Country.load
+require "phonie/railties/validator" if defined? ActiveModel

data/lib/phonie/configuration.rb

@@ -0,0 +1,22 @@
+require 'singleton'
+
+module Phonie
+  class Configuration
+    include Singleton
+
+    attr_accessor :data_file_path, :default_area_code, :default_country_code, :n1_length
+ 
+    def initialize
+      @data_file_path = File.join(File.dirname(__FILE__), 'data', 'phone_countries.yml')
+      @n1_length = 3
+    end
+  end
+
+  def self.configure(&block)
+    yield configuration
+  end
+
+  def self.configuration
+    Configuration.instance
+  end
+end

data/lib/phonie/country.rb

@@ -1,115 +1,79 @@
+require 'forwardable'
+require 'yaml'
+
 module Phonie
-  class Country < Struct.new(:name, :country_code, :char_2_code, :iso_3166_code, :area_code, :local_number_format, :mobile_format, :full_number_length, :number_format, :national_dialing_prefix)
-    def self.load
-      data_file = File.join(File.dirname(__FILE__), 'data', 'phone_countries.yml')
-
-      all = []
-      YAML.load(File.read(data_file)).each do |c|
-        next unless c[:area_code] && c[:local_number_format]
-        all << Country.new(c[:name], c[:country_code], c[:char_2_code], c[:iso_3166_code], c[:area_code], c[:local_number_format], c[:mobile_format], c[:full_number_length], c[:number_format], c[:national_dialing_prefix])
+  class Country
+    extend Forwardable
+
+    attr_reader :name, :country_code, :char_2_code, :iso_3166_code, :parser
+    
+    def initialize(params)
+      @name          = params[:name]
+      @country_code  = params[:country_code]
+      @char_2_code   = params[:char_2_code]
+      @iso_3166_code = params[:iso_3166_code]
+      @parser        = Phonie::Parser.new(params)
+      @national_dialing_prefix = params[:national_dialing_prefix]
+    end
+
+    def_delegators :parser, :is_mobile?, :possible_valid_number?,
+	                    :is_valid_number?, :parse
+
+    def self.all
+      @@all ||= begin
+        YAML.load_file(Phonie.configuration.data_file_path).collect do |country_params|
+	  Country.new(country_params)
+        end.select {|country| country.valid? }
       end
-      all
     end
 
-    COUNTRIES = self.load
-    COUNTRIES_BY_PHONE_CODE   = COUNTRIES.inject(Hash.new){|h, c| (h[c.country_code] ||= []) << c; h }
-    COUNTRIES_BY_COUNTRY_CODE = Hash[*COUNTRIES.map{|c| [c.iso_3166_code.downcase, c] }.flatten]
-    COUNTRIES_BY_NAME         = Hash[*COUNTRIES.map{|c| [c.name.downcase, c] }.flatten]
+    def self.all_by_phone_code
+      @@all_by_phone_code ||= all.inject(Hash.new){|h, c| (h[c.country_code] ||= []) << c; h }
+    end
+
+    def self.all_by_country_code
+      @@all_by_country_name ||=  Hash[*all.map{|c| [c.iso_3166_code.downcase, c] }.flatten]
+    end
+
+    def self.all_by_name
+      @@all_by_name ||= Hash[*all.map{|c| [c.name.downcase, c] }.flatten]
+    end
 
     def self.find_all_by_phone_code(code)
-      COUNTRIES_BY_PHONE_CODE[code] || []
+      all_by_phone_code[code] || []
     end
 
     def self.find_by_country_code(code)
-      COUNTRIES_BY_COUNTRY_CODE[code.downcase] if code
+      all_by_country_code[code.downcase] if code
     end
 
     def self.find_by_name(name)
-      COUNTRIES_BY_NAME[name.downcase] if name
+      all_by_name[name.downcase] if name
     end
 
-    # detect country from the string entered
-    def self.detect(string, default_country_code, default_area_code)
+    # detect country from the passed phone number
+    def self.detect(phone_number, default_country_code, default_area_code)
       # use the default_country_code to try for a quick match
-      country = find_all_by_phone_code(default_country_code).find do |country|
-        country.matches_full_number?(string) ||
-          country.matches_local_number_with_area_code?(string) ||
-          country.matches_local_number?(string, default_area_code)
+      country = find_all_by_phone_code(default_country_code).find do |c|
+        c.possible_valid_number?(phone_number, default_area_code)
       end
 
       # then search all for a full match
-      country || COUNTRIES.find {|country| country.matches_full_number?(string) }
+      country || all.find {|country| country.is_valid_number?(phone_number) }
     end
 
     def to_s
       name
     end
 
-    def is_mobile?(number)
-      return true if mobile_format.nil?
-      number =~ mobile_number_regex ? true : false
-    end
-
-    # true if string contains country_code + area_code + local_number
-    def matches_full_number?(string)
-      string =~ full_number_regex && string =~ number_format_regex
-    end
-
-    # true if string contains area_code + local_number
-    def matches_local_number_with_area_code?(string)
-      string =~ area_code_number_regex && string =~ number_format_regex
-    end
-
-    # true if string contains only the local_number, but the default_area_code is valid
-    def matches_local_number?(string, default_area_code)
-      string =~ number_regex && default_area_code =~ area_code_regex
-    end
-
-    def parse(number, default_area_code)
-      if md = number.match(full_number_regex)
-        {:area_code => md[2], :number => md[-1]}
-      elsif md = number.match(area_code_number_regex)
-        {:area_code => md[1], :number => md[-1]}
-      elsif md = number.match(number_regex)
-        {:area_code => default_area_code, :number => md[1]}
-      else
-        {}
-      end
-    end
-
     def national_dialing_prefix
-      prefix = super
-      if prefix == "None"
-        nil
-      else
-        prefix
-      end
-    end
-
-    private
-
-    def number_format_regex
-      @number_format_regex ||= Regexp.new("^[+0]?(#{country_code})?(#{number_format})$")
-    end
-
-    def full_number_regex
-      @full_number_regex ||= Regexp.new("^[+]?(#{country_code})(#{area_code})(#{local_number_format})$")
-    end
-
-    def area_code_number_regex
-      @area_code_number_regex ||= Regexp.new("^0?(#{area_code})(#{local_number_format})$")
-    end
-
-    def area_code_regex
-      @area_code_regex ||= Regexp.new("^0?(#{area_code})$")
-    end
+      return nil if @national_dialing_prefix == "None"
 
-    def mobile_number_regex
-      @mobile_number_regex ||= Regexp.new("^(#{mobile_format})$")
+      @national_dialing_prefix
     end
 
-    def number_regex
-      @number_regex ||= Regexp.new("^(#{local_number_format})$")
+    def valid?
+      !!(name && parser.valid?)
     end
   end
 end

data/lib/phonie/formatter.rb

@@ -0,0 +1,54 @@
+# 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)
+module Phonie
+  class Formatter
+    attr_reader :format, :phone_number
+
+    def initialize(params)
+      @phone_number = params[:phone_number]
+      
+      format = params[:format]
+      @format = if format.respond_to?(:gsub)
+        format
+      else
+        self.class.named_formats[format]
+      end
+
+      raise ArgumentError.new("No valid format provided") if @format.nil?
+      raise ArgumentError.new("No valid phone number provided") if @phone_number.nil?
+    end
+
+    def self.named_formats
+      {
+        default: "+%c%a%n",
+        default_with_extension: "+%c%a%nx%x",
+        europe: '+%c (0) %a %f %l',
+        us: "(%a) %f-%l"
+      }
+    end
+
+    def to_s
+      pn = phone_number
+
+      format.gsub("%c", pn.country_code.to_s).
+        gsub("%a", pn.area_code.to_s).
+        gsub("%A", pn.area_code_long.to_s).
+        gsub("%n", pn.number.to_s).
+        gsub("%f", pn.number1.to_s).
+        gsub("%l", pn.number2.to_s).
+        gsub("%x", pn.extension.to_s)
+    end
+  end
+end

data/lib/phonie/parser.rb

@@ -0,0 +1,125 @@
+module Phonie
+  # Parser is responsible for parsing and verifying phone numbers
+  class Parser
+    attr_reader :area_code, :country_code, :local_number_format, :mobile_format, :number_format
+
+    # Creates a new phone number parser based on a hash of +params+
+    # The +params+ hash requires
+    # * area_code
+    # * country_code - a number representing the International Subscriber Dialling code
+    # * local_number_format - a regex describing a local phone number (minus country and area code)
+    # * number_format - a regex describing a valid phone number
+    # * mobile_format (optional) - a regex describing a mobile phone number
+    def initialize(params)
+      @area_code           = params[:area_code]
+      @country_code        = params[:country_code]
+      @local_number_format = params[:local_number_format]
+      @mobile_format       = params[:mobile_format]
+      @number_format       = params[:number_format]
+    end
+
+    # Test if a phone +number+ might be for a mobile phone
+    # Can produce false positives, and some countries have
+    # portable numbers between landlines and mobile phones
+    # in which case this will always be true
+    def is_mobile?(number)
+      return true if mobile_format.nil?
+      number =~ mobile_number_regex ? true : false
+    end
+
+    # Test if +phone_number+ is valid
+    def is_valid_number?(phone_number)
+      matches_full_number?(phone_number)
+    end
+
+    # Parse a pass phone +number+ returning it's area_code & number as a
+    # hash if valid.
+    # Optionally a +default_area_code+ may be passed in order to
+    # allow parsing local number numbers for a known area code
+    def parse(number, default_area_code = nil)
+      parse_full_match(number) ||
+      parse_area_code_match(number) ||
+      parse_with_default(number, default_area_code) ||
+      {}
+    end
+
+    # Test if a phone number could possibly be valid by testing
+    # if it's matches a number without a country code, and optionally
+    # testing for a local number against a default_area_code
+    def possible_valid_number?(phone_number, default_area_code = nil)
+      matches_full_number?(phone_number) ||
+      matches_local_number_with_area_code?(phone_number) ||
+      matches_local_number?(phone_number, default_area_code)
+    end
+
+    # Test that a parser is valid and is capable of parsing phone numbers
+    def valid?
+      !!(country_code && area_code && local_number_format && number_format)
+    end
+
+    private
+
+    # true if string contains country_code + area_code + local_number
+    def matches_full_number?(string)
+      string =~ full_number_regex && string =~ number_format_regex
+    end
+
+    # true if string contains area_code + local_number
+    def matches_local_number_with_area_code?(string)
+      string =~ area_code_number_regex && string =~ number_format_regex
+    end
+
+    # true if string contains only the local_number, but the default_area_code is valid
+    def matches_local_number?(string, default_area_code)
+      string =~ number_regex && default_area_code =~ area_code_regex
+    end
+
+    def parse_full_match(number)
+      match = number.match(full_number_regex)
+      return nil unless match
+
+      { area_code: match[2],
+        number:    match[-1] }
+    end
+
+    def parse_area_code_match(number)
+      match = number.match(area_code_number_regex)
+      return nil unless match
+
+      { area_code: match[1],
+        number:    match[-1] }
+    end
+
+    def parse_with_default(number, default_area_code)
+      match = number.match(number_regex)
+      return nil unless match
+
+      { area_code: default_area_code,
+        number:    match[1] }
+    end
+
+    def number_format_regex
+      @number_format_regex ||= Regexp.new("^[+0]?(#{country_code})?(#{number_format})$")
+    end
+
+    def full_number_regex
+      @full_number_regex ||= Regexp.new("^[+]?(#{country_code})(#{area_code})(#{local_number_format})$")
+    end
+
+    def area_code_number_regex
+      @area_code_number_regex ||= Regexp.new("^0?(#{area_code})(#{local_number_format})$")
+    end
+
+    def area_code_regex
+      @area_code_regex ||= Regexp.new("^0?(#{area_code})$")
+    end
+
+    def mobile_number_regex
+      @mobile_number_regex ||= Regexp.new("^(#{mobile_format})$")
+    end
+
+    def number_regex
+      @number_regex ||= Regexp.new("^(#{local_number_format})$")
+    end
+  end
+end

data/lib/phonie/phone.rb

@@ -1,5 +1,3 @@
-require 'active_model'
-
 # An object representing a phone number.
 #
 # The phone number is recorded in 3 separate parts:
@@ -8,64 +6,40 @@ require 'active_model'
 # * 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
+#   Phonie.configuration.default_country_code
+#   Phonie.configuration.default_area_code
 #
+
 module Phonie
   class Phone
     EXTENSION = /[ ]*(ext|ex|x|xt|#|:)+[^0-9]*\(*([-0-9]{1,})\)*#?$/i
 
-    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"
-    }
-
-    include ActiveModel::Validations
-    validates :country_code, :presence => true
-    validates :area_code, :presence => true
-    validates :number, :presence => true
-
-    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
+    attr_reader :country_code, :area_code, :errors, :number, :extension, :country
+
+    def initialize(*args)
+      params = normalize_args(args)
 
-      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] ]
+      @number       = params[:number]
+      @area_code    = params[:area_code]
+      @country_code = params[:country_code]
+      @extension    = params[:extension]
+      @country      = params[:country]
+      @errors = {}
     end
 
     def self.parse!(string, options = {})
-      pn = parse(string, options)
-      raise ArgumentError.new("#{string} is not a valid phone number") unless pn && pn.valid?
-      pn
+      phone_number = parse(string, options)
+      raise ArgumentError.new("#{string} is not a valid phone number") unless phone_number && phone_number.valid?
+      phone_number
     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 unless string.present?
+      return if string.nil?
 
-      options[:country_code] ||= self.default_country_code
-      options[:area_code]    ||= self.default_area_code
+      options[:country_code] ||= Phonie.configuration.default_country_code
+      options[:area_code]    ||= Phonie.configuration.default_area_code
 
       extension = extract_extension(string)
       normalized = normalize(string)
@@ -101,36 +75,17 @@ module Phonie
 
     # first n characters of :number
     def number1
-      number[0...self.class.n1_length]
+      number[0...Phonie.configuration.n1_length]
     end
 
     # everything left from number after the first n characters (see number1)
     def number2
-      n2_length = number.size - self.class.n1_length
+      n2_length = number.size - Phonie.configuration.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 ArgumentError.new("The format #{fmt} doesn't exist") unless named_formats.has_key?(fmt)
-        format_number named_formats[fmt]
-      else
-        format_number(fmt)
-      end
+      Formatter.new(format: fmt, phone_number: self).to_s
     end
 
     # the default format is "+%c%a%n"
@@ -140,12 +95,17 @@ module Phonie
 
     # does this number belong to the default country code?
     def has_default_country_code?
-      country_code == self.class.default_country_code
+      country_code == Phonie.configuration.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
+      area_code == Phonie.configuration.default_area_code
+    end
+
+    def valid?
+      validate
+      errors.empty?
     end
 
     # comparison of 2 phone objects
@@ -156,6 +116,33 @@ module Phonie
 
     private
 
+    def defaults
+      { area_code:    Phonie.configuration.default_area_code,
+	country_code: Phonie.configuration.default_country_code }
+    end
+
+    def normalize_args(args)
+      hash = if args.first.respond_to?(:key?)
+	args.first
+      else
+        {}.tap do |h|
+          h[:number] =       args[0] if args.length > 0
+          h[:area_code] =    args[1] if args.length > 1
+          h[:country_code] = args[2] if args.length > 2
+          h[:extension] =    args[3] if args.length > 3
+          h[:country] =      args[4] if args.length > 4
+	end
+      end
+
+      defaults.merge(hash)
+    end
+
+    def validate
+      [:country_code, :area_code, :number].each do |field|
+	errors[field] = ["can't be blank"] if send(field).to_s == ''
+      end
+    end
+
     # 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])
@@ -172,15 +159,5 @@ module Phonie
       return unless string && string.match(EXTENSION)
       Regexp.last_match[2]
     end
-
-    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 || "").
-        gsub("%x", extension || "")
-    end
   end
 end

data/lib/phonie/railties/validator.rb

@@ -2,14 +2,6 @@ I18n.load_path += Dir.glob( File.expand_path('../locales/*.{rb,yml}', __FILE__)
 
 class PhoneValidator < ActiveModel::EachValidator
   def validate_each(object, attribute, value)
-    return if value.blank?
-    phone = Phonie::Phone.parse(value)
-
-    if phone.nil?
-      object.errors.add(attribute, :invalid_phone_number)
-    else
-      formated = phone.format( phone.extension ? :default_with_extension : :default)
-      object.send("#{attribute}=", formated) if object.respond_to?("#{attribute}=")
-    end
+    object.errors.add(attribute, :invalid_phone_number) unless Phonie::Phone.valid?(value)
   end
-end
+end

data/lib/phonie/version.rb

@@ -1,3 +1,3 @@
 module Phonie
-  VERSION = '2.1.2'
+  VERSION = '3.0.0'
 end

data/phonie.gemspec

@@ -16,8 +16,7 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.require_paths = ["lib"]
 
-  s.add_dependency 'activemodel'
-
+  s.add_development_dependency 'activemodel'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'nokogiri'
 end

data/test/countries/bd_test.rb

@@ -9,7 +9,7 @@ class BDTest < Phonie::TestCase
   end
 
   def test_with_default_country
-    Phonie::Phone.default_country_code = '880'
+    Phonie.configuration.default_country_code = '880'
     parse_test('1715379982', '880', '171', '5379982', 'Bangladesh', true)
     parse_test('1191573647', '880', '119', '1573647', 'Bangladesh', true)
     parse_test('21915736', '880', '2', '1915736', 'Bangladesh', false)

data/test/countries/ca_test.rb

@@ -8,13 +8,13 @@ class CATest < Phonie::TestCase
   end
 
   def test_long_with_default_country_code
-    Phonie::Phone.default_country_code = '1'
+    Phonie.configuration.default_country_code = '1'
     parse_test('9059735100', '1', '905', '9735100', 'Canada')
   end
 
   def test_short_with_default_country_code_and_area_code
-    Phonie::Phone.default_country_code = '1'
-    Phonie::Phone.default_area_code = '416'
+    Phonie.configuration.default_country_code = '1'
+    Phonie.configuration.default_area_code = '416'
     parse_test('9735100', '1', '416', '9735100', 'Canada')
   end
 end

data/test/countries/hr_test.rb

@@ -29,43 +29,42 @@ class HRTest < Phonie::TestCase
   end
 
   def test_short_without_special_characters_with_country
-    Phonie::Phone.default_country_code = '385'
+    Phonie.configuration.default_country_code = '385'
     parse_test('044885047', '385', '44', '885047')
   end
 
   def test_zagreb_short_without_special_characters_with_country
-    Phonie::Phone.default_country_code = '385'
+    Phonie.configuration.default_country_code = '385'
     parse_test('013668734', '385', '1', '3668734')
   end
 
   def test_long_with_zero_in_brackets
-    Phonie::Phone.default_country_code = nil
+    Phonie.configuration.default_country_code = nil
     parse_test('+385 (0)1 366 8111', '385', '1', '3668111')
   end
 
   def test_has_default_country_code
-    Phonie::Phone.default_country_code = '385'
+    Phonie.configuration.default_country_code = '385'
 
     assert_equal Phonie::Phone.parse('+38547451588').has_default_country_code?, true
     assert_equal Phonie::Phone.parse('+16472228242').has_default_country_code?, false
   end
 
   def test_has_default_area_code
-    Phonie::Phone.default_country_code = '385'
-    Phonie::Phone.default_area_code = '47'
+    Phonie.configuration.default_country_code = '385'
+    Phonie.configuration.default_area_code = '47'
 
     assert_equal Phonie::Phone.parse('047/451-588').has_default_area_code?, true
     assert_equal Phonie::Phone.parse('032/336-1456').has_default_area_code?, false
   end
 
   def test_validates
-    Phonie::Phone.default_country_code = nil
     assert_equal Phonie::Phone.valid?('00385915125486'), true
     assert_equal Phonie::Phone.valid?('+385915125486'), true
     assert_equal Phonie::Phone.valid?('+385 (91) 512 5486'), true
     assert_equal Phonie::Phone.valid?('+38547451588'), true
 
-    Phonie::Phone.default_country_code = '385'
+    Phonie.configuration.default_country_code = '385'
     assert_equal Phonie::Phone.valid?('0915125486'), true
     assert_equal Phonie::Phone.valid?('091/512-5486'), true
     assert_equal Phonie::Phone.valid?('091/512-5486'), true

data/test/countries/in_test.rb

@@ -14,18 +14,18 @@ class INTest < Phonie::TestCase
   end
 
   def test_long_with_default_country_code
-    Phonie::Phone.default_country_code = '91'
+    Phonie.configuration.default_country_code = '91'
     parse_test('9124459000', '91', '9124', '459000')
   end
 
   def test_short_with_default_country_code_and_area_code
-    Phonie::Phone.default_country_code = '91'
-    Phonie::Phone.default_area_code = '9124'
+    Phonie.configuration.default_country_code = '91'
+    Phonie.configuration.default_area_code = '9124'
     parse_test('4529000', '91', '9124', '4529000')
   end
 
   def test_lengths
-    Phonie::Phone.default_country_code = '91'
+    Phonie.configuration.default_country_code = '91'
 
     phone = Phonie::Phone.parse("919812344")
     assert_nil phone

data/test/countries/pt_test.rb

@@ -51,7 +51,7 @@ class PTTest < Phonie::TestCase
 
   # 707-708: Premium Numbers
   def test_707
-    Phonie::Phone.default_country_code = '351'
+    Phonie.configuration.default_country_code = '351'
     parse_test('707 123 456', '351', '707', '123456')
   end
 
@@ -59,17 +59,17 @@ class PTTest < Phonie::TestCase
 
   # 800: Numero verde ("Green Number")
   def test_800
-    Phonie::Phone.default_country_code = '351'
+    Phonie.configuration.default_country_code = '351'
     parse_test('800 123 456', '351', '800', '123456')
   end
   # 808: Numero azul ("Blue Number")
   def test_808
-    Phonie::Phone.default_country_code = '351'
+    Phonie.configuration.default_country_code = '351'
     parse_test('808 123 456', '351', '808', '123456')
   end
   # 809: Custo partilhado ("Shared cost")
   def test_809
-    Phonie::Phone.default_country_code = '351'
+    Phonie.configuration.default_country_code = '351'
     parse_test('809 123 456', '351', '809', '123456', 'Portugal', false)
   end
 
@@ -108,14 +108,13 @@ class PTTest < Phonie::TestCase
   end
 
   def test_validates
-    Phonie::Phone.default_country_code = nil
     assert_equal Phonie::Phone.valid?('00351211234567'), true
     assert_equal Phonie::Phone.valid?('00351911234567'), true
     assert_equal Phonie::Phone.valid?('+351931234567'), true
     assert_equal Phonie::Phone.valid?('+351 (911) 123 456'), true
     assert_equal Phonie::Phone.valid?('+351921123456'), true
 
-    Phonie::Phone.default_country_code = '351'
+    Phonie.configuration.default_country_code = '351'
     assert_equal Phonie::Phone.valid?('(931) 234-567'), true
     assert_equal Phonie::Phone.valid?('(211) 234 567'), true
     assert_equal Phonie::Phone.valid?('232-123-456'), true

data/test/countries/us_test.rb

@@ -12,13 +12,15 @@ class USTest < Phonie::TestCase
   end
 
   def test_long_with_default_country_code
-    Phonie::Phone.default_country_code = '1'
+    Phonie.configuration.default_country_code = '1'
     parse_test('2069735100', '1', '206', '9735100', 'United States')
   end
 
   def test_short_with_default_country_code_and_area_code
-    Phonie::Phone.default_country_code = '1'
-    Phonie::Phone.default_area_code = '206'
+    Phonie.configure do |config|
+      config.default_country_code = '1'
+      config.default_area_code = '206'
+    end
     parse_test('9735100', '1', '206', '9735100', 'United States')
   end
 end

data/test/phone_test.rb

@@ -7,16 +7,13 @@ class PhoneTest < Phonie::TestCase
   end
 
   def test_number_without_country_code_initialize
-    Phonie::Phone.default_country_code = nil
-
     pn = Phonie::Phone.new '5125486', '91'
     assert !pn.valid?
     assert_equal ["can't be blank"], pn.errors[:country_code]
   end
 
   def test_number_without_area_code_initialize
-    Phonie::Phone.default_country_code = '1'
-    Phonie::Phone.default_area_code = nil
+    Phonie.configuration.default_country_code = '1'
 
     pn = Phonie::Phone.new '451588'
     assert !pn.valid?
@@ -24,8 +21,8 @@ class PhoneTest < Phonie::TestCase
   end
 
   def test_number_with_default_area_code_initialize
-    Phonie::Phone.default_country_code = '385'
-    Phonie::Phone.default_area_code = '47'
+    Phonie.configuration.default_country_code = '385'
+    Phonie.configuration.default_area_code = '47'
 
     pn = Phonie::Phone.new '451588'
     assert pn.number == '451588'
@@ -34,7 +31,7 @@ class PhoneTest < Phonie::TestCase
   end
 
   def test_number_with_default_country_code_initialize
-    Phonie::Phone.default_country_code = '386'
+    Phonie.configuration.default_country_code = '386'
 
     pn = Phonie::Phone.new '5125486', '91'
     assert pn.number == '5125486'
@@ -43,7 +40,7 @@ class PhoneTest < Phonie::TestCase
   end
 
   def test_number_with_country_code_initialize
-    Phonie::Phone.default_country_code = '387'
+    Phonie.configuration.default_country_code = '387'
 
     pn = Phonie::Phone.new '5125486', '91', '385'
     assert pn.number == '5125486'
@@ -57,8 +54,6 @@ class PhoneTest < Phonie::TestCase
   end
 
   def test_parse_short_without_special_characters_without_country
-    Phonie::Phone.default_country_code = nil
-
     assert_nil Phonie::Phone.parse "0915125486"
 
     assert_raise ArgumentError do
@@ -67,8 +62,6 @@ class PhoneTest < Phonie::TestCase
   end
 
   def test_parse_short_with_special_characters_without_country
-    Phonie::Phone.default_country_code = nil
-
     assert_nil Phonie::Phone.parse "091/512-5486"
 
     assert_raise ArgumentError do
@@ -77,31 +70,28 @@ class PhoneTest < Phonie::TestCase
   end
 
   def test_to_s
-    Phonie::Phone.default_country_code = nil
     pn = Phonie::Phone.new '5125486', '91', '385'
     assert pn.to_s == '+385915125486'
   end
 
   def test_to_s_without_country_code
-    Phonie::Phone.default_country_code = '385'
+    Phonie.configuration.default_country_code = '385'
     pn = Phonie::Phone.new '5125486', '91'
     assert pn.format("0%a%n") == '0915125486'
   end
 
   def test_format_special_with_country_code
-    Phonie::Phone.default_country_code = nil
     pn = Phonie::Phone.new '5125486', '91', '385'
     assert pn.format("+ %c (%a) %n") == '+ 385 (91) 5125486'
   end
 
   def test_format_special_without_country_code
-    Phonie::Phone.default_country_code = '385'
+    Phonie.configuration.default_country_code = '385'
     pn = Phonie::Phone.new '5125486', '91'
     assert_equal '091/512-5486', pn.format("%A/%f-%l")
   end
 
   def test_format_with_symbol_specifier
-    Phonie::Phone.default_country_code = nil
     pn = Phonie::Phone.new '5125486', '91', '385'
     assert_equal '+385 (0) 91 512 5486', pn.format(:europe)
   end

data/test/railties/validator_test.rb

@@ -1,37 +1,39 @@
 require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-
 require 'active_model'
 require 'phonie/railties/validator'
-class SomeModel < Struct.new(:phone)
+
+class SomeModel < Struct.new(:phone_number)
   include ActiveModel::Validations
-  validates :phone, phone: true
+  validates :phone_number, phone: true
 end
 
+class SomeOtherModel < Struct.new(:phone_number)
+  include ActiveModel::Validations
+  validates :phone_number, phone: true, allow_blank: true
+end
 
 class PhoneValidatorTest < Phonie::TestCase
   def test_blank_phone
-    assert SomeModel.new(nil).valid?
-    assert SomeModel.new('').valid?
+    assert SomeModel.new(nil).invalid?
+    assert SomeModel.new('').invalid?
+    assert SomeOtherModel.new(nil).valid?
+    assert SomeOtherModel.new('').valid?
   end
 
   def test_valid_model
     model = SomeModel.new('+1 251 123 4567')
     assert model.valid?
-
-    assert model.phone == '+12511234567'
   end
 
   def test_valid_number_with_extension
     model = SomeModel.new('+1 251 123 4567 ex 1234')
     assert model.valid?
-
-    assert model.phone == '+12511234567x1234'
   end
 
   def test_invalid_model
     model = SomeModel.new('+1 251 123 456')
     assert model.invalid?
 
-    assert !model.errors[:phone].empty?
+    assert !model.errors[:phone_number].empty?
   end
 end

data/test/test_helper.rb

@@ -23,8 +23,10 @@ end
 class Phonie::TestCase < Test::Unit::TestCase
 
   def setup
-    Phonie::Phone.default_country_code = nil
-    Phonie::Phone.default_area_code = nil
+    Phonie.configure do |config|
+      config.default_country_code = nil
+      config.default_area_code = nil
+    end
   end
 
   def default_test

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phonie
 version: !ruby/object:Gem::Version
-  version: 2.1.2
+  version: 3.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-27 00:00:00.000000000 Z
+date: 2014-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -23,7 +23,7 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
@@ -76,18 +76,21 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .travis.yml
+- Changelog.md
 - Gemfile
 - LICENSE
 - Rakefile
 - Readme.rdoc
 - lib/phonie.rb
+- lib/phonie/configuration.rb
 - lib/phonie/country.rb
 - lib/phonie/data/phone_countries.yml
+- lib/phonie/formatter.rb
+- lib/phonie/parser.rb
 - lib/phonie/phone.rb
 - lib/phonie/railties/locales/en.yml
 - lib/phonie/railties/locales/es.yml
 - lib/phonie/railties/validator.rb
-- lib/phonie/support.rb
 - lib/phonie/version.rb
 - phonie.gemspec
 - tasks/tests.rake
@@ -214,7 +217,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 453458853538770825
+      hash: 2987221699007223305
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -223,7 +226,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 453458853538770825
+      hash: 2987221699007223305
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23

data/lib/phonie/support.rb

@@ -1,78 +0,0 @@
-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)