phony 1.9.0 → 2.19.14

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

@@ -16,13 +16,16 @@ describe Phony::NationalSplitters::Fixed do
       @splitter = Phony::NationalSplitters::Fixed.new 2
     end
     it 'splits correctly' do
-      @splitter.split('443643532').should == ['0', '44', '3643532']
+      @splitter.split('443643532').should == [nil, '44', '3643532']
     end
     it 'splits correctly even when the number is too long' do
-      @splitter.split('44364353211').should == ['0', '44', '364353211']
+      @splitter.split('44364353211').should == [nil, '44', '364353211']
     end
     it 'splits correctly even when the number is too short' do
-      @splitter.split('443').should == ['0', '44','3']
+      @splitter.split('443').should == [nil, '44','3']
+    end
+    it 'has a length of 2' do
+      @splitter.length.should == 2
     end
   end
   describe 'split' do
@@ -30,13 +33,16 @@ describe Phony::NationalSplitters::Fixed do
       @splitter = Phony::NationalSplitters::Fixed.new nil
     end
     it 'splits correctly' do
-      @splitter.split('443643532').should == ['0', '443643532']
+      @splitter.split('443643532').should == [nil, '443643532']
     end
     it 'splits correctly even when the number is too long' do
-      @splitter.split('44364353211').should == ['0', '44364353211']
+      @splitter.split('44364353211').should == [nil, '44364353211']
     end
     it 'splits correctly even when the number is too short' do
-      @splitter.split('443').should == ['0', '443']
+      @splitter.split('443').should == [nil, '443']
+    end
+    it 'has a length of nil' do
+      @splitter.length.should == nil
     end
   end
   

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

@@ -8,11 +8,21 @@ describe Phony::NationalSplitters::None do
     end
   end
   
-  describe 'split' do
+  context 'with instance' do
     let(:splitter) { described_class.instance_for }
-    it 'splits correctly into ndc and rest' do
-      splitter.split('123456789').should == [nil, false, '123456789']
+  
+    describe 'split' do
+      it 'splits correctly into ndc and rest' do
+        splitter.split('123456789').should == [nil, false, '123456789']
+      end
+    end
+    
+    describe 'length' do
+      it 'is always 0' do
+        splitter.length.should be_zero
+      end
     end
+    
   end
   
 end

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

@@ -15,7 +15,7 @@ describe Phony::NationalSplitters::Regex do
     context 'with on_fail 2' do
       let(:splitter) { described_class.instance_for(/^(123)\d+$/, 2) }
       it 'uses the on_fail_take' do
-        splitter.split('23456789').should == ['0', '23', '456789']
+        splitter.split('23456789').should == [nil, '23', '456789']
       end
     end
   end

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

@@ -8,16 +8,19 @@ describe Phony::NationalSplitters::Variable do
         @splitter = Phony::NationalSplitters::Variable.new 4, ['1', '316', '67', '68', '669', '711']
       end
       it "handles Vienna" do
-        @splitter.split('198110').should == ['0', '1', '98110']
+        @splitter.split('198110').should == [nil, '1', '98110']
       end
       it "handles some mobile services" do
-        @splitter.split('66914093902').should == ['0', '669', '14093902']
+        @splitter.split('66914093902').should == [nil, '669', '14093902']
       end
       it "handles Graz" do
-        @splitter.split('3161234567891').should == ['0', '316', '1234567891']
+        @splitter.split('3161234567891').should == [nil, '316', '1234567891']
       end
       it "handles Rohrau" do
-        @splitter.split('2164123456789').should == ['0', '2164', '123456789']
+        @splitter.split('2164123456789').should == [nil, '2164', '123456789']
+      end
+      it 'has an NDC length of 3' do
+        @splitter.length.should == (1..3)
       end
     end
     context 'special handling for using the variable size splitter for Swiss service numbers' do
@@ -25,7 +28,10 @@ describe Phony::NationalSplitters::Variable do
         @splitter = Phony::NationalSplitters::Variable.new 2, ['800']
       end
       it "should handle swiss service numbers" do
-        @splitter.split('800223344').should == ['0', '800', '223344']
+        @splitter.split('800223344').should == [nil, '800', '223344']
+      end
+      it 'has an NDC length of 3' do
+        @splitter.length.should == (3..3)
       end
     end
   end

data/spec/lib/phony/trunk_code_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Phony::TrunkCode do
+  
+  describe '#format' do
+    it 'is correct' do
+      code = described_class.new('0')
+      expect(code.format('%s %s')).to eq '0'
+    end
+    it 'is correct' do
+      code = described_class.new('0', format: true)
+      expect(code.format('%s %s')).to eq '0'
+    end
+    it 'is correct' do
+      code = described_class.new('0', format: false)
+      expect(code.format('%s %s')).to eq nil
+    end
+    it 'is correct' do
+      code = described_class.new('06')
+      expect(code.format('%s %s')).to eq '06'
+    end
+    it 'is correct' do
+      code = described_class.new('06', format: true)
+      expect(code.format('%s %s')).to eq '06'
+    end
+    it 'is correct' do
+      code = described_class.new('06', format: false)
+      expect(code.format('%s %s')).to eq nil
+    end
+  end
+  
+  describe '#normalize' do
+    it 'is correct' do
+      code = described_class.new('0')
+      expect(code.normalize('0123')).to eq '0123'
+    end
+    it 'is correct' do
+      code = described_class.new('0', normalize: true)
+      expect(code.normalize('0123')).to eq '0123'
+    end
+    it 'is correct' do
+      code = described_class.new('0', normalize: false)
+      expect(code.normalize('0123')).to eq '0123'
+    end
+    it 'is correct' do
+      code = described_class.new('06')
+      expect(code.normalize('06123')).to eq '06123'
+    end
+    it 'is correct' do
+      code = described_class.new('06', normalize: true)
+      expect(code.normalize('06123')).to eq '06123'
+    end
+    it 'is correct' do
+      code = described_class.new('06', normalize: false)
+      expect(code.normalize('0123')).to eq '0123'
+    end
+  end
+  
+  describe '#split' do
+    it 'is correct' do
+      code = described_class.new('0')
+      expect(code.split('0123')).to eq [code, '0123']
+    end
+    it 'is correct' do
+      code = described_class.new('0', split: true)
+      expect(code.split('0123')).to eq [code, '123']
+    end
+    it 'is correct' do
+      code = described_class.new('0', split: false)
+      expect(code.split('0123')).to eq [code, '0123']
+    end
+    it 'is correct' do
+      code = described_class.new('06')
+      expect(code.split('06123')).to eq [code, '06123']
+    end
+    it 'is correct' do
+      code = described_class.new('06', split: true)
+      expect(code.split('06123')).to eq [code, '123']
+    end
+    it 'is correct' do
+      code = described_class.new('06', split: false)
+      expect(code.split('06123')).to eq [code, '06123']
+    end
+  end
+end

data/spec/lib/phony/vanity_spec.rb

@@ -4,31 +4,27 @@ 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
+  let(:vanity) { described_class }
+
+  describe '.replace' do
+    it 'replaces letters with digits' do
+      vanity.replace('1-800-HELLO').should == '1-800-43556'
     end
   end
   
-  describe "replace" do
-    it 'replaces all characters' do
-      Phony::Vanity.replace('0123456789abcdefghijklmnopqrstuvwxyz').should == '012345678922233344455566677778889999'
+  describe '.vanity?' do
+    it 'returns true on a vanity number' do
+      vanity.vanity?('800HELLOES').should == true
+    end
+    it 'returns false on a non-vanity number' do
+      vanity.vanity?('8004355637').should == false
     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
-      ]
+  describe '.normalized' do
+    it 'normalizes the vanity number' do
+      vanity.normalized('1-800-HELLO').should == '1800HELLO'
     end
   end
-  
+
 end

data/spec/lib/phony_spec.rb

@@ -1,288 +1,70 @@
-# encoding: utf-8
-#
 require 'spec_helper'
 
-describe Phony do
-
-  describe 'nil cases' do
-    it "should raise on normalize nil" do
-      expect {
-        Phony.normalize(nil)
-      }.to raise_error(ArgumentError, "Phone number cannot be nil. Use e.g. number && Phony.normalize(number).")
-    end
-    it "should raise on format nil" do
-      expect {
-        Phony.format(nil)
-      }.to raise_error(ArgumentError, "Phone number cannot be nil. Use e.g. number && Phony.format(number).")
-    end
-    it "should raise on split nil" do
-      expect {
-        Phony.split(nil)
-      }.to raise_error(ArgumentError, "Phone number cannot be nil. Use e.g. number && Phony.split(number).")
-    end
+describe Phony::NormalizationError do
+  it 'is correctly raised on normalize' do
+    expect do
+      Phony.normalize('000')
+    end.to raise_error(Phony::NormalizationError)
   end
-
-  describe "normalize" do
-    describe "some examples" do
-      it "should normalize a too short number" do
-        Phony.normalize('+972').should == '972'
-      end
-      it "should normalize an already normalized number" do
-        Phony.normalize('41443643533').should == '41443643533'
-      end
-      it "should normalize a format number" do
-        Phony.normalize('+41 44 364 35 33').should == '41443643533'
-      end
-      it "should normalize a 00 number" do
-        Phony.normalize('0041 44 364 35 33').should == '41443643533'
-      end
-      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
-        Phony.normalize('John: +41 44 364 35 33').should == '41443643533'
-      end
-      it "should normalize one of these crazy american numbers" do
-        Phony.normalize('1 (703) 451-5115').should == '17034515115'
-      end
-      it "should normalize another one of these crazy american numbers" do
-        Phony.normalize('1-888-407-4747').should == '18884074747'
-      end
-      it "should normalize a number with colons" do
-        Phony.normalize('1.906.387.1698').should == '19063871698'
-      end
-      it "should normalize a number with optional ndc" do
-        Phony.normalize('+41 (044) 364 35 33').should == '41443643533'
-      end
-      it "should normalize a number with erroneous zero inside" do
-        Phony.normalize('+410443643533').should == '41443643533'
-      end
-      it "should not normalize a number with a correct zero inside" do
-        Phony.normalize('+390909709511').should == '390909709511'
-      end
-    end
+  it 'is correctly raised on normalize' do
+    expect do
+      Phony.normalize('000')
+    end.to raise_error(%Q{Phony could not normalize the given number. Is it a phone number?})
   end
-
-  describe 'formatted' do
-    it 'is an alias of format' do
-      Phony.formatted('41443643532').should == '+41 44 364 35 32'
-    end
+  it 'is correctly raised on normalize!' do
+    expect do
+      Phony.normalize!('000')
+    end.to raise_error(Phony::NormalizationError)
   end
-
-  describe "format" do
-    describe "default" do
-      it "should format swiss numbers" do
-        Phony.format('41443643532').should == '+41 44 364 35 32'
-      end
-      # TODO
-      #
-      it "should format swiss service numbers" do
-        Phony.format('41800112233').should == '+41 800 112 233'
-      end
-      it "should format austrian numbers" do
-        Phony.format('43198110').should == '+43 1 98110'
-      end
-      it "should format american numbers" do
-        Phony.format('18705551122').should == '+1 870 555 1122'
-      end
-    end
-    describe "international" do
-      it "should format north american numbers" do
-        Phony.format('18091231234', :format => :international).should == '+1 809 123 1234'
-      end
-      it "should format austrian numbers" do
-        Phony.format('43198110', :format => :international).should == '+43 1 98110'
-      end
-      it "should format austrian numbers" do
-        Phony.format('43198110', :format => :international_absolute).should == '+43 1 98110'
-      end
-      it "should format french numbers" do
-        Phony.format('33142278186', :format => :+).should == '+33 1 42 27 81 86'
-      end
-      it "should format austrian numbers" do
-        Phony.format('43198110', :format => :international_relative).should == '0043 1 98110'
-      end
-      it 'should format liechtensteiner numbers' do
-        Phony.format('4233841148', :format => :international_relative).should == '00423 384 11 48'
-      end
-      context 'with no spaces' do
-        it "should format north american numbers" do
-          Phony.format('18091231234', :format => :international, :spaces => '').should == '+18091231234'
-        end
-        it "should format austrian numbers" do
-          Phony.format('43198110', :format => :international, :spaces => '').should == '+43198110'
-        end
-        it "should format austrian numbers" do
-          Phony.format('43198110', :format => :international_absolute, :spaces => '').should == '+43198110'
-        end
-        it "should format french numbers" do
-          Phony.format('33142278186', :format => :+, :spaces => '').should == '+33142278186'
-        end
-        it "should format austrian numbers" do
-          Phony.format('43198110', :format => :international_relative, :spaces => '').should == '0043198110'
-        end
-        it 'should format liechtensteiner numbers' do
-          Phony.format('4233841148', :format => :international_relative, :spaces => '').should == '004233841148'
-        end
-      end
-      context 'with special spaces' do
-        it "should format swiss numbers" do
-          Phony.format('41443643532', :format => :international).should == '+41 44 364 35 32'
-        end
-        it "should format north american numbers" do
-          Phony.format('18091231234', :format => :international, :spaces => :-).should == '+1-809-123-1234'
-        end
-        it "should format austrian numbers" do
-          Phony.format('43198110', :format => :international, :spaces => :-).should == '+43-1-98110'
-        end
-        it "should format austrian numbers" do
-          Phony.format('43198110', :format => :international_absolute, :spaces => :-).should == '+43-1-98110'
-        end
-        it "should format french numbers" do
-          Phony.format('33142278186', :format => :+, :spaces => :-).should == '+33-1-42-27-81-86'
-        end
-        it "should format austrian numbers" do
-          Phony.format('43198110', :format => :international_relative, :spaces => :-).should == '0043-1-98110'
-        end
-        it 'should format liechtensteiner numbers' do
-          Phony.format('4233841148', :format => :international_relative, :spaces => :-).should == '00423-384-11-48'
-        end
-      end
-      describe '"unsupported" countries' do
-        it 'should format as a single block' do
-          Phony.format('88032155605220').should == '+880 32155605220'
-        end
-        it 'should format as a single block, regardless of format' do
-          Phony.format('8801819372205', :format => :international).should == '+880 1819372205'
-        end
-        it 'should format as a single block, respecting custom spaces' do
-          Phony.format('8801819372205', :spaces => :-).should == '+880-1819372205'
-        end
-        it 'should format as a single block, even without spaces' do
-          Phony.format('8801819372205', :spaces => '').should == '+8801819372205'
-        end
-      end
-    end
-    describe "national" do
-      it "should format swiss numbers" do
-        Phony.format('41443643532', :format => :national).should == '044 364 35 32'
-      end
-      # TODO
-      #
-      it "should format swiss service numbers" do
-        Phony.format('41800112233', :format => :national).should == '0800 112 233'
-      end
-      it "should format austrian numbers" do
-        Phony.format('43198110', :format => :national).should == '01 98110'
-      end
-      it "should format US numbers without a leading zero" do
-        Phony.format('14159224711', :format => :national).should == '415 922 4711'
-      end
-    end
-    describe "local" do
-      it "should format swiss numbers" do
-        Phony.format('41443643532', :format => :local).should == '364 35 32'
-      end
-      it "should format german numbers" do
-        Phony.format('493038625454', :format => :local).should == '386 25454'
-      end
-    end
+  it 'is correctly raised on normalize!' do
+    expect do
+      Phony.normalize!('000')
+    end.to raise_error(%Q{Phony could not normalize the given number. Is it a phone number?})
   end
+end
 
-  context 'minimal cases' do
-    context 'normalizing' do
-      it 'handles completely crazy "numbers"' do
-        Phony.normalize('Hello, I am Cora, the 41th parrot, and 044 is my 364 times 35 funky number. 32.').should == '41443643532'
-      end
-    end
-    context 'splitting' do
-      it 'handles completely missing numbers well enough' do
-        Phony.split('4144').should == ['41', '44', '']
-      end
-      it 'handles a missing number part' do
-        Phony.split('4144364').should == ['41', '44', '364']
-      end
-      it 'handles a missing number part' do
-        Phony.split('414436435').should == ['41', '44', '364', '35']
-      end
-    end
-    context 'formatting' do
-      it 'handles completely missing numbers well enough' do
-        Phony.format('4144').should == '+41 44 '
-      end
-      it 'handles a missing number part' do
-        Phony.format('4144364').should == '+41 44 364'
-      end
-      it 'handles a missing number part' do
-        Phony.format('414436435').should == '+41 44 364 35'
-      end
-    end
-    context '"unsupported" countries' do
-      it 'handles formatting' do
-        Phony.format('88032155605220').should == '+880 32155605220'
-      end
-      it 'handles normalizing' do
-        Phony.normalize('+880-321 5560 5220').should == '88032155605220'
-      end
-    end
+describe Phony::SplittingError do
+  it 'is correctly raised on split' do
+    expect do
+      Phony.split('000')
+    end.to raise_error(Phony::SplittingError)
   end
-
-  context "speed" do
-    before(:each) do
-      @phone_numbers = [
-        '41443643532',
-        '18091231234',
-        '43198110',
-        '33142278186',
-        '4233841148'
-      ]
-    end
-    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 'is fast' do
-        performance_of { @phone_numbers.each { |number| Phony.normalize(number) } }.should < 0.00016
-      end
-    end
-    describe 'format' do
-      it 'is fast' do
-        number = @phone_numbers.first
-        performance_of { Phony.format(number) }.should < 0.000075
-      end
-      it 'is fast' do
-        performance_of { @phone_numbers.each { |number| Phony.format(number) } }.should < 0.00016
-      end
-    end
+  it 'is correctly raised on split' do
+    expect do
+      Phony.split('000')
+    end.to raise_error(%Q{Phony could not split the given number. Is "000" a phone number?})
   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 '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('41800SUCCESSMATCH').should == '41800782237762824'} # Allow for call-through numbers (>= 1.6.0)
-      it {Phony.vanity_to_number('4180BLA').should == '4180252'} # Does not check for validity of number.
-    end
+  it 'is correctly raised on split!' do
+    expect do
+      Phony.split!('000')
+    end.to raise_error(Phony::SplittingError)
+  end
+  it 'is correctly raised on split!' do
+    expect do
+      Phony.split!('000')
+    end.to raise_error(%Q{Phony could not split the given number. Is it a phone number?})
   end
-
 end
+
+describe Phony::FormattingError do
+  it 'is correctly raised on format' do
+    expect do
+      Phony.format('000')
+    end.to raise_error(Phony::FormattingError)
+  end
+  it 'is correctly raised on format' do
+    expect do
+      Phony.format('000')
+    end.to raise_error(%Q{Phony could not format the given number. Is it a phone number?})
+  end
+  it 'is correctly raised on format!' do
+    expect do
+      Phony.format!('000')
+    end.to raise_error(Phony::FormattingError)
+  end
+  it 'is correctly raised on format!' do
+    expect do
+      Phony.format!('000')
+    end.to raise_error(%Q{Phony could not format the given number. Is it a phone number?})
+  end
+end