phony 1.0.1 → 1.1.0

data/spec/lib/phony/country_codes_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Phony::CountryCodes do
+  
+  before(:all) do
+    @countries = Phony::CountryCodes.new
+  end
+  
+  describe 'split' do
+    it 'splits correctly' do
+      @countries.split('41443643532').should == ['41', '44', '364', '35', '32']
+    end
+  end
+  
+  describe 'remove_relative_zeros' do
+    it "should remove an ndc zero from an almost normalized number and return it" do
+      @countries.remove_relative_zeros!('410443643533').should == '41443643533'
+    end
+  end
+  
+  describe 'formatted' do
+    it 'formats correctly' do
+      @countries.formatted('41443643532', :format => :international, :spaces => :-).should == '+41-44-364-35-32'
+    end
+    it 'formats correctly' do
+      @countries.formatted('41443643532', :format => :international_relative, :spaces => :-).should == '0041-44-364-35-32'
+    end
+    it 'formats correctly' do
+      @countries.formatted('41443643532', :format => :national, :spaces => :-).should == '044-364-35-32'
+    end
+    context 'default' do
+      it "should format swiss numbers" do
+        @countries.formatted('41443643532').should == '+41 44 364 35 32'
+      end
+      it "should format swiss service numbers" do
+        @countries.formatted('41800112233').should == '+41 800 112 233'
+      end
+      it "should format austrian numbers" do
+        @countries.formatted('43198110').should == '+43 1 98110'
+      end
+      it "should format american numbers" do
+        @countries.formatted('18705551122').should == '+1 870 555 1122'
+      end
+    end
+    describe "international" do
+      it "should format north american numbers" do
+        @countries.formatted('18091231234', :format => :international).should == '+1 809 123 1234'
+      end
+      it "should format austrian numbers" do
+        @countries.formatted('43198110', :format => :international).should == '+43 1 98110'
+      end
+      it "should format austrian numbers" do
+        @countries.formatted('43198110', :format => :international_absolute).should == '+43 1 98110'
+      end
+      it "should format french numbers" do
+        @countries.formatted('33142278186', :format => :+).should == '+33 1 42 27 81 86'
+      end
+      it "should format austrian numbers" do
+        @countries.formatted('43198110', :format => :international_relative).should == '0043 1 98110'
+      end
+      it 'should format liechtensteiner numbers' do
+        @countries.formatted('4233841148', :format => :international_relative).should == '00423 384 11 48'
+      end
+      context 'with no spaces' do
+        it "should format north american numbers" do
+          Phony.formatted('18091231234', :format => :international, :spaces => '').should == '+18091231234'
+        end
+        it "should format austrian numbers" do
+          Phony.formatted('43198110', :format => :international, :spaces => '').should == '+43198110'
+        end
+        it "should format austrian numbers" do
+          Phony.formatted('43198110', :format => :international_absolute, :spaces => '').should == '+43198110'
+        end
+        it "should format french numbers" do
+          Phony.formatted('33142278186', :format => :+, :spaces => '').should == '+33142278186'
+        end
+        it "should format austrian numbers" do
+          Phony.formatted('43198110', :format => :international_relative, :spaces => '').should == '0043198110'
+        end
+        it 'should format liechtensteiner numbers' do
+          Phony.formatted('4233841148', :format => :international_relative, :spaces => '').should == '004233841148'
+        end
+      end
+      context 'with special spaces' do
+        it "should format swiss numbers" do
+          Phony.formatted('41443643532', :format => :international).should == '+41 44 364 35 32'
+        end
+        it "should format north american numbers" do
+          Phony.formatted('18091231234', :format => :international, :spaces => :-).should == '+1-809-123-1234'
+        end
+        it "should format austrian numbers" do
+          Phony.formatted('43198110', :format => :international, :spaces => :-).should == '+43-1-98110'
+        end
+        it "should format austrian numbers" do
+          Phony.formatted('43198110', :format => :international_absolute, :spaces => :-).should == '+43-1-98110'
+        end
+        it "should format french numbers" do
+          Phony.formatted('33142278186', :format => :+, :spaces => :-).should == '+33-1-42-27-81-86'
+        end
+        it "should format austrian numbers" do
+          Phony.formatted('43198110', :format => :international_relative, :spaces => :-).should == '0043-1-98110'
+        end
+        it 'should format liechtensteiner numbers' do
+          Phony.formatted('4233841148', :format => :international_relative, :spaces => :-).should == '00423-384-11-48'
+        end
+      end
+    end
+  end
+  
+end

data/spec/lib/phony/country_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Phony::Country do
+  
+  describe "configured" do
+    context "with variable ndcs" do
+      before(:each) do
+        @country = Phony::Country.configured :local_format         => [3, 2, 2],
+                                             :service_local_format => [3, 3],
+                                             :ndc_fallback_length  => 4,
+                                             :ndc_mapping => {
+                                               :normal  => ['44'],
+                                               :service => ['800'],
+                                               :mobile  => ['76']
+                                             }
+      end
+      it 'works for normal numbers' do
+        @country.split('443643532').should == ['44', '364', '35', '32']
+      end
+      it 'works with service numbers' do
+        @country.split('800333666').should == ['800', '333', '666']
+      end
+      it 'works with mobile numbers' do
+        @country.split('764333532').should == ['76', '433', '35', '32']
+      end
+      it 'uses the fallback if it is not in the mapping' do
+        @country.split('123456789').should == ['1234', '567', '89']
+      end
+    end
+    context "with fixed ndcs" do
+      before(:each) do
+        @country = Phony::Country.fixed :ndc_length           => 2,
+                                        :local_format         => [3, 2, 2],
+                                        :service_local_format => [3, 3],
+                                        :service_ndcs         => ['800']
+      end
+      it 'works for non-service numbers' do
+        @country.split('443643532').should == ['44', '364', '35', '32']
+      end
+      it 'works for service numbers' do
+        @country.split('800333666').should == ['800', '333', '666']
+      end
+      it 'works with mobile numbers' do
+        @country.split('764333532').should == ['76', '433', '35', '32']
+      end
+      it 'uses a fixed length' do
+        @country.split('123456789').should == ['12', '345', '67', '89']
+      end
+    end
+  end
+  
+  context "without special cases" do
+    before(:each) do
+      national_splitter = Phony::NationalSplitters::Variable.new 4, { :normal => ['44'] }
+      local_splitter    = Phony::LocalSplitter.instance_for [3, 2, 2]
+      national_code     = Phony::NationalCode.new national_splitter, local_splitter
+      
+      @switzerland      = Phony::Country.new national_code
+    end
+    
+    describe "split" do
+      it "should handle ZH" do
+        @switzerland.split('443643532').should == ['44', '364', '35', '32']
+      end
+    end
+  end
+  
+  context "without special cases" do
+    before(:each) do
+      national_splitter         = Phony::NationalSplitters::Variable.new 4, { :normal => ['44'] }
+      local_splitter            = Phony::LocalSplitter.instance_for [3, 2, 2]
+      national_code             = Phony::NationalCode.new national_splitter, local_splitter
+      
+      special_national_splitter = Phony::NationalSplitters::Variable.new nil, { :service => ['800'] }
+      special_local_splitter    = Phony::LocalSplitter.instance_for [3, 3]
+      special_code              = Phony::NationalCode.new special_national_splitter, special_local_splitter
+      
+      @switzerland              = Phony::Country.new national_code, special_code
+    end
+    
+    describe "split" do
+      it "should handle ZH" do
+        @switzerland.split('443643532').should == ['44', '364', '35', '32']
+      end
+      it "should handle 800" do
+        @switzerland.split('800333666').should == ['800', '333', '666']
+      end
+    end
+  end
+  
+end

data/spec/lib/phony/local_splitter_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Phony::LocalSplitter do
+  
+  describe 'instance_for' do
+    it 'caches' do
+      Phony::LocalSplitter.instance_for([3,2,2]).should equal(Phony::LocalSplitter.instance_for([3,2,2]))
+    end
+    it 'caches correctly' do
+      Phony::LocalSplitter.instance_for([1,2,3]).should_not equal(Phony::LocalSplitter.instance_for([9,9,9]))
+    end
+    it 'caches correctly' do
+      Phony::LocalSplitter.instance_for.should equal(Phony::LocalSplitter.instance_for)
+    end
+  end
+  
+  describe 'split' do
+    context "without format" do
+      before(:each) do
+        @splitter = Phony::LocalSplitter.new
+      end
+      it 'splits correctly' do
+        @splitter.split('3643532').should == ['364','35','32']
+      end
+      it 'splits correctly even when the number is too long' do
+        @splitter.split('3643532111').should == ['364','35','32']
+      end
+      it 'splits correctly even when the number is too short' do
+        @splitter.split('364353').should == ['364','35','3'] # TODO Redo correctly.
+      end
+    end
+    context "with format" do
+      before(:each) do
+        @splitter = Phony::LocalSplitter.new [3, 2, 2]
+      end
+      it 'splits correctly' do
+        @splitter.split('3643532').should == ['364','35','32']
+      end
+      it 'splits correctly even when the number is too long' do
+        @splitter.split('3643532111').should == ['364','35','32']
+      end
+      it 'splits correctly even when the number is too short' do
+        @splitter.split('364353').should == ['364','35','3'] # TODO Redo correctly.
+      end
+    end
+  end
+  
+end

data/spec/lib/phony/national_code_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Phony::NationalCode do
+  
+  describe 'split' do
+    context 'with fixed ndc (Swiss)' do
+      before(:each) do
+        national_splitter = Phony::NationalSplitters::Fixed.instance_for 2
+        local_splitter    = Phony::LocalSplitter.instance_for [3, 2, 2]
+        
+        @national         = Phony::NationalCode.new national_splitter, local_splitter
+      end
+      it 'splits correctly' do
+        @national.split('443643532').should == ['44', '364', '35', '32']
+      end
+      it 'splits correctly' do
+        @national.split('44364353').should == ['44', '364', '35', '3']
+      end
+    end
+    context 'with fixed ndc (French)' do
+      before(:each) do
+        national_splitter = Phony::NationalSplitters::Fixed.instance_for 1
+        local_splitter    = Phony::LocalSplitter.instance_for [2, 2, 2, 2]
+        
+        @national         = Phony::NationalCode.new national_splitter, local_splitter
+      end
+      it 'splits correctly' do
+        @national.split('142278186').should == ['1', '42', '27', '81', '86']
+      end
+      it 'splits correctly' do
+        @national.split('14227818').should == ['1', '42', '27', '81', '8']
+      end
+    end
+  end
+  
+end

data/spec/lib/phony/national_splitters/fixed_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Phony::NationalSplitters::Fixed do
+  
+  describe 'instance_for' do
+    it 'caches' do
+      Phony::NationalSplitters::Fixed.instance_for(3).should equal(Phony::NationalSplitters::Fixed.instance_for(3))
+    end
+    it 'caches correctly' do
+      Phony::NationalSplitters::Fixed.instance_for(1).should_not equal(Phony::NationalSplitters::Fixed.instance_for(2))
+    end
+  end
+  
+  describe 'split' do
+    before(:each) do
+      @splitter = Phony::NationalSplitters::Fixed.new 2
+    end
+    it 'splits correctly' do
+      @splitter.split('443643532').should == ['44', '3643532']
+    end
+    it 'splits correctly even when the number is too long' do
+      @splitter.split('44364353211').should == ['44', '364353211']
+    end
+    it 'splits correctly even when the number is too short' do
+      @splitter.split('443').should == ['44','3']
+    end
+  end
+  describe 'split' do
+    before(:each) do
+      @splitter = Phony::NationalSplitters::Fixed.new nil
+    end
+    it 'splits correctly' do
+      @splitter.split('443643532').should == ['443643532']
+    end
+    it 'splits correctly even when the number is too long' do
+      @splitter.split('44364353211').should == ['44364353211']
+    end
+    it 'splits correctly even when the number is too short' do
+      @splitter.split('443').should == ['443']
+    end
+  end
+  
+end

data/spec/lib/phony/national_splitters/variable_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Phony::NationalSplitters::Variable do
+  
+  describe 'split' do
+    context 'normal' do
+      before(:each) do
+        @splitter = Phony::NationalSplitters::Variable.new 4, :normal  => ['1', '316'],
+                                                              :mobile  => ['67', '68',],
+                                                              :service => ['669', '711']
+      end
+      it "handles Vienna" do
+        @splitter.split('198110').should == ['1', '98110']
+      end
+      it "handles some mobile services" do
+        @splitter.split('66914093902').should == ['669', '14093902']
+      end
+      it "handles Graz" do
+        @splitter.split('3161234567891').should == ['316', '1234567891']
+      end
+      it "handles Rohrau" do
+        @splitter.split('2164123456789').should == ['2164', '123456789']
+      end
+    end
+    context 'special handling for using the variable size splitter for Swiss service numbers' do
+      before(:each) do
+        @splitter = Phony::NationalSplitters::Variable.new 2, :service => ['800']
+      end
+      it "should handle swiss service numbers" do
+        @splitter.split('800223344').should == ['800', '223344']
+      end
+    end
+  end
+  
+end

data/spec/lib/phony/vanity_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Phony::Vanity do
+  
+  describe "vanity?" do
+    it 'recognizes a vanity number' do
+      Phony::Vanity.vanity?('800HELLOWORLD').should == true
+    end
+    it 'recognizes a non vanity number' do
+      Phony::Vanity.vanity?('444443322').should == false
+    end
+  end
+  
+  describe "replace" do
+    it 'replaces all characters' do
+      Phony::Vanity.replace('0123456789abcdefghijklmnopqrstuvwxyz').should == '012345678922233344455566677778889999'
+    end
+  end
+  
+  describe 'mapping' do
+    it 'caches' do
+      Phony::Vanity.mapping.should equal(Phony::Vanity.mapping)
+    end
+    it 'returns the right thing' do
+      Phony::Vanity.mapping.should == [
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.freeze,
+        '2223334445556667777888999922233344455566677778889999'.freeze
+      ]
+    end
+  end
+  
+end

data/spec/lib/phony_spec.rb

@@ -4,6 +4,49 @@ require 'spec_helper'
 
 describe Phony do
   
+  describe "split" do
+    it "should handle austrian numbers" do
+      Phony.split('43198110').should == ['43', '1', '98110']
+    end
+    it "should handle egyptian numbers" do
+      Phony.split('20233453756').should == ['20', '2', '33453756']
+    end
+    it "should handle french numbers" do
+      Phony.split('33112345678').should == ['33', '1', '12','34','56','78']
+    end
+    it "should handle german numbers" do
+      Phony.split('4976112345').should == ['49', '761', '123', '45']
+    end
+    it "should handle greek numbers" do
+      Phony.split('3022631234').should == ['30', '2263', '1234']
+    end
+    it "should handle hungarian numbers" do
+      Phony.split('3612345678').should == ['36', '1', '234', '5678']
+    end
+    it "should handle italian numbers" do
+      Phony.split('3928061371').should == ['39', '2', '806', '1371']
+    end
+    it "should handle polish numbers" do
+      Phony.split('48121123123').should == ['48', '12', '1', '123', '123']
+    end
+    it "should handle swiss numbers" do
+      Phony.split('41443643532').should == ['41', '44', '364', '35', '32']
+    end
+    it "should handle US numbers" do
+      Phony.split('15551115511').should == ['1', '555', '111', '5511']
+    end
+    it "should handle new zealand numbers" do
+      Phony.split('6491234567').should == ['64', '9', '123', '4567']
+    end
+    
+    it "should handle french service numbers" do
+      Phony.split('33812345678').should == ['33', '8', '12','34','56','78']
+    end
+    it "should handle swiss service numbers" do
+      Phony.split('41800334455').should == ['41', '800', '334', '455']
+    end
+  end
+  
   describe "normalize" do
     describe "some examples" do
       it "should normalize an already normalized number" do
@@ -15,7 +58,7 @@ describe Phony do
       it "should normalize a formatted number" do
         Phony.normalize('+41 44 364 35 33').should == '41443643533'
       end
-      it "should normalize a special service number" do
+      it "should normalize a service number" do
         Phony.normalize('+41 800 11 22 33').should == '41800112233'
       end
       it "should remove characters from the number" do
@@ -33,231 +76,21 @@ describe Phony do
       it "should normalize a number with optional ndc" do
         Phony.normalize('+41 (044) 364 35 33').should == '41443643533'
       end
-    end
-  end
-  
-  describe "remove_relative_zeros" do
-    it "should remove an ndc zero from an almost normalized number and return it" do
-      in_the Phony do
-        remove_relative_zeros!('410443643533').should == '41443643533'
+      it "should normalize a number with erroneous zero inside" do
+        Phony.normalize('+410443643533').should == '41443643533'
       end
     end
   end
   
-  describe "formatted_cc_ndc" do
-    describe "international" do
-      it "should return an internationally formatted cc-ndc combo" do
-        in_the Phony do
-          formatted_cc_ndc('41', '44', nil).should == '+41 44 '
-        end
-      end
-      it "should return an internationally formatted cc-ndc combo" do
-        in_the Phony do
-          formatted_cc_ndc('41', '44', :international_absolute).should == '+41 44 '
-        end
-      end
-      it "should return an internationally formatted cc-ndc combo" do
-        in_the Phony do
-          formatted_cc_ndc('41', '44', :international).should == '+41 44 '
-        end
-      end
-      it "should return an internationally formatted cc-ndc combo" do
-        in_the Phony do
-          formatted_cc_ndc('41', '44', :+).should == '+41 44 '
-        end
-      end
-      it "should return an relative internationally formatted cc-ndc combo" do
-        in_the Phony do
-          formatted_cc_ndc('41', '44', :international_relative).should == '0041 44 '
-        end
-      end
-      it "should return an internationally formatted cc-ndc combo (for special service number)" do
-        in_the Phony do
-          formatted_cc_ndc('41', '800', :international_absolute).should == '+41 800 '
-        end
-      end
-      context 'with a different space character' do
-        it "should return an internationally formatted cc-ndc combo (for special service number), with special space" do
-          in_the Phony do
-            formatted_cc_ndc('41', '800', :international_absolute, :-).should == '+41-800-'
-          end
-        end
-      end
-      context 'if the ndc is blank' do
-        it "should have only one space at the end (not two) / international" do
-          in_the Phony do
-            formatted_cc_ndc('423', '', :international).should == '+423 '
-          end
-        end
-        it "should have only one space at the end (not two) / international relative" do
-          in_the Phony do
-            formatted_cc_ndc('423', '', :international_relative).should == '00423 '
-          end
-        end
-        it "should have only one space at the end (not two) / national" do
-          in_the Phony do
-            formatted_cc_ndc('423', '', :national).should == ''
-          end
-        end
-        
-      end
-    end
-    describe "national" do
-      it "should return a nationally formatted cc-ndc combo" do
-        in_the Phony do
-          formatted_cc_ndc('41', '44', :national).should == '044 '
-        end
-      end
-      it "should return a nationally formatted cc-ndc combo (for special service number)" do
-        in_the Phony do
-          formatted_cc_ndc('41', '800', :national).should == '0800 '
-        end
-      end
-    end
-    describe "local" do
-      it "should return a locally formatted cc-ndc combo" do
-        in_the Phony do
-          formatted_cc_ndc('41', '44', :local).should == ''
-        end
-      end
-    end
-  end
-
-  describe "split" do
-    it "should handle austrian numbers" do
-      Phony.split('43198110').should == ['43', '1', '98110']
-    end
-    it "should handle french numbers" do
-      Phony.split('33112345678').should == ['33', '1', '12','34','56','78']
-    end
-    it "should handle german numbers" do
-      Phony.split('4976112345').should == ['49', '761', '123', '45']
-    end
-    it "should handle italian numbers opinionatedly" do
-      Phony.split('3928061371').should == ['39', '280', '613', '71']
-    end
-    it "should handle swiss numbers" do
-      Phony.split('41443643532').should == ['41', '44', '364', '35', '32']
-    end
-    it "should handle US numbers" do
-      Phony.split('15551115511').should == ['1', '555', '111', '5511']
-    end
-    it "should handle new zealand numbers" do
-      Phony.split('6491234567').should == ['64', '9', '123', '4567']
-    end
-    it "should handle swiss special services numbers" do
-      Phony.split('41800334455').should == ['41', '800', '33', '44', '55']
-    end
-  end
-  
-  describe "split_cc" do
-    it "should handle partial numbers" do
-      Phony.split_cc('4').should == ['', '']
-    end
-    it "should handle partial numbers" do
-      Phony.split_cc('43').should == ['43', '']
-    end
-    it "should handle partial numbers" do
-      Phony.split_cc('431').should == ['43', '1']
-    end
-    it "should handle partial numbers" do
-      Phony.split_cc('4319').should == ['43', '19']
-    end
-    it "should handle partial numbers" do
-      Phony.split_cc('43198').should == ['43', '198']
-    end
-    it "should handle partial numbers" do
-      Phony.split_cc('431981').should == ['43', '1981']
-    end
-    it "should handle partial numbers" do
-      Phony.split_cc('4319811').should == ['43', '19811']
-    end
-    
-    it "should handle austrian numbers" do
-      Phony.split_cc('43198110').should == ['43', '198110']
-    end
-    it "should handle french numbers" do
-      Phony.split_cc('33112345678').should == ['33', '112345678']
-    end
-    it "should handle german numbers" do
-      Phony.split_cc('4976112345').should == ['49', '76112345']
-    end
-    it "should handle italian numbers opinionatedly" do
-      Phony.split_cc('3928061371').should == ['39', '28061371']
-    end
-    it "should handle swiss numbers" do
-      Phony.split_cc('41443643532').should == ['41', '443643532']
-    end
-    it "should handle swiss special services numbers" do
-      Phony.split_cc('41800223344').should == ['41', '800223344']
-    end
-    it "should handle US numbers" do
-      Phony.split_cc('15551115511').should == ['1', '5551115511']
-    end
-    it "should handle new zealand numbers" do
-      Phony.split_cc('6491234567').should == ['64', '91234567']
-    end
-    it 'should handle Liechtenstein' do
-      Phony.split_cc('4233841148').should == ['423', '3841148']
-    end
-  end
-  
-  describe "split_cc_ndc" do
-    it "should handle partial numbers" do
-      Phony.split_cc_ndc('4').should == ['', '', '']
-    end
-    it "should handle partial numbers" do
-      Phony.split_cc_ndc('43').should == ['43', '', '']
-    end
-    it "should handle partial numbers" do
-      Phony.split_cc_ndc('431').should == ['43', '1', '']
-    end
-    it "should handle partial numbers" do
-      Phony.split_cc_ndc('4319').should == ['43', '1', '9']
-    end
-    it "should handle partial numbers" do
-      Phony.split_cc_ndc('43198').should == ['43', '1', '98']
-    end
-    it "should handle partial numbers" do
-      Phony.split_cc_ndc('431981').should == ['43', '1', '981']
-    end
-    it "should handle partial numbers" do
-      Phony.split_cc_ndc('4319811').should == ['43', '1', '9811']
-    end
-    
-    it "should handle austrian numbers" do
-      Phony.split_cc_ndc('43198110').should == ['43', '1', '98110']
-    end
-    it "should handle french numbers" do
-      Phony.split_cc_ndc('33112345678').should == ['33', '1', '12345678']
-    end
-    it "should handle german numbers" do
-      Phony.split_cc_ndc('4976112345').should == ['49', '761', '12345']
-    end
-    it "should handle italian numbers opinionatedly" do
-      Phony.split_cc_ndc('3928061371').should == ['39', '280', '61371']
-    end
-    it "should handle swiss numbers" do
-      Phony.split_cc_ndc('41443643532').should == ['41', '44', '3643532']
-    end
-    it "should handle swiss special services numbers" do
-      Phony.split_cc_ndc('41800112233').should == ['41', '800', '112233']
-    end
-    it "should handle US numbers" do
-      Phony.split_cc_ndc('15551115511').should == ['1', '555', '1115511']
-    end
-    it "should handle new zealand numbers" do
-      Phony.split_cc_ndc('6491234567').should == ['64', '9', '1234567']
-    end
-  end
-  
   describe "formatted" do
     describe "default" do
       it "should format swiss numbers" do
         Phony.formatted('41443643532').should == '+41 44 364 35 32'
       end
-      it "should format swiss special services numbers" do
-        Phony.formatted('41800112233').should == '+41 800 11 22 33'
+      # TODO
+      #
+      it "should format swiss service numbers" do
+        Phony.formatted('41800112233').should == '+41 800 112 233'
       end
       it "should format austrian numbers" do
         Phony.formatted('43198110').should == '+43 1 98110'
@@ -333,8 +166,10 @@ describe Phony do
       it "should format swiss numbers" do
         Phony.formatted('41443643532', :format => :national).should == '044 364 35 32'
       end
-      it "should format swiss special services numbers" do
-        Phony.formatted('41800112233', :format => :national).should == '0800 11 22 33'
+      # TODO
+      #
+      it "should format swiss service numbers" do
+        Phony.formatted('41800112233', :format => :national).should == '0800 112 233'
       end
       it "should format austrian numbers" do
         Phony.formatted('43198110', :format => :national).should == '01 98110'
@@ -350,30 +185,74 @@ describe Phony do
     end
   end
   
-  describe 'regarding vanity' do
-    describe 'vanity_number?' do
-      it {Phony.vanity_number?('0800 WEGGLI').should be_true}
-      it {Phony.vanity_number?('0800WEGGLI').should be_true}
-      it {Phony.vanity_number?('0848 SUCCESSMATCH').should be_true}
-      it {Phony.vanity_number?('080 NO NO NO').should be_false}
-      it {Phony.vanity_number?('0900 KURZ').should be_false}
+  context "speed" do
+    before(:each) do
+      @phone_numbers = [
+        '41443643532',
+        '18091231234',
+        '43198110',
+        '33142278186',
+        '4233841148'
+      ]
     end
-    
-    describe 'vanity_to_number' do
-      before(:each) do
-        @number = stub(:number)
+    describe 'split' do
+      it 'is fast' do
+        number = @phone_numbers.first
+        performance_of { Phony.split(number) }.should < 0.00005
+      end
+      it 'is fast' do
+        performance_of { @phone_numbers.each { |number| Phony.split(number) } }.should < 0.00015
+      end
+    end
+    describe 'normalize' do
+      it 'is fast' do
+        number = @phone_numbers.first
+        performance_of { Phony.normalize(number) }.should < 0.0001
       end
-      it "should delegate to Phony::Vanity.replace" do
-        Phony::Vanity.should_receive(:replace).with(@number)
-        Phony.vanity_to_number @number
+      it 'is fast' do
+        performance_of { @phone_numbers.each { |number| Phony.normalize(number) } }.should < 0.00015
       end
     end
+    describe 'formatted' do
+      it 'is fast' do
+        number = @phone_numbers.first
+        performance_of { Phony.formatted(number) }.should < 0.000075
+      end
+      it 'is fast' do
+        performance_of { @phone_numbers.each { |number| Phony.formatted(number) } }.should < 0.00015
+      end
+    end
+  end
+  
+  # describe "service?" do
+  # 
+  # end
+  # describe "mobile?" do
+  #   # TODO Test dirty numbers.
+  #   #
+  #   it 'is correct' do
+  #     Phony.mobile?('49172123456').should == true
+  #   end
+  #   it 'is correct' do
+  #     Phony.mobile?('12172123456').should == false
+  #   end
+  # end
+  
+  describe 'vanity' do
+    describe 'vanity_number?' do
+      it {Phony.vanity?('41800 WEGGLI').should be_true}
+      it {Phony.vanity?('41800WEGGLI').should be_true}
+      it {Phony.vanity?('41848 SUCCESSMATCH').should be_true}
+      it {Phony.vanity?('4180 NO NO NO').should be_false}
+      it {Phony.vanity?('41900 KURZ').should be_false}
+      it {Phony.vanity?('41 44 364 35 32').should be_false}
+    end
     
-    describe 'replace_vanity' do
-      it {Phony::Vanity.replace('0800 WEGGLI').should == '0800 934454'}
-      it {Phony::Vanity.replace('0800weggli').should == '0800934454'}
-      it {Phony::Vanity.replace('0800SUCCESSMATCH').should == '0800782237762824'}
-      it {Phony::Vanity.replace('080BLA').should == '080252'} #replace_vanity does not check for validity of number
+    describe 'vanity_to_number' do
+      it {Phony.vanity_to_number('41800WEGGLI').should == '41800934454'}
+      it {Phony.vanity_to_number('41800weggli').should == '41800934454'}
+      it {Phony.vanity_to_number('41800SUCCESSMATCH').should == '41800782237'} # Cut off according to the swiss norms.
+      it {Phony.vanity_to_number('4180BLA').should == '4180252'} # Does not check for validity of number.
     end
   end