phony 2.20.2 → 2.20.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53a198dfed227f85433f10698121865171a91f11cbb7392aaed13f256e60ef90
-  data.tar.gz: 943807c4e1d75b405da5c39876285c551fea05a135f3b618ae7d0529e723653b
+  metadata.gz: 27443f0af2d18a25a1b9056a1a09e77dffd8e8669346d974a3970cdfe9931ee4
+  data.tar.gz: b5d22d65bb38fcb66b8f966716e5a5ee582d272a53b418b3ed20070ce90a74c1
 SHA512:
-  metadata.gz: 3837520d9b0bcf6e249512af63d6e8cbb2b4e9960103577ff451b2aada44aab61f0c557af6cfdd4617d433670ec6030272ea8bc988c4d3e02bdcf433d2b41864
-  data.tar.gz: b790b37631700657e0afeb07d2bbb688fcf2ff72f00759112259f848f9b9edee4c4d40c17e68843d6e24ab3aee96beb23deb37b59708a3520c06bab3e7fa2f97
+  metadata.gz: 5ee83977f8d9f5b8ccbcbbea65976ff20456fd35f4adca206e91b9efe4838cf80bef3a15b8cd837e093f4cfedca43a757e7ecd2c941abae9d08c0d54f217c930
+  data.tar.gz: 30760e746ca05cadc07b41e404507537a18f516938b9701a18ecedd6a56d14f9f1eb39eee754d8121679e7217514be356f250292a7d7a9bad7a89efcc98168c4

data/lib/phony/countries.rb

@@ -363,7 +363,15 @@ Phony.define do
     trunk('', :normalize => false) |
     fixed(2) >> split(2,2,2,2)
 
-  country '226', none >> split(4,4) # Burkina Faso http://www.wtng.info/wtng-226-bf.html
+  # Burkina Faso
+  # http://www.wtng.info/wtng-226-bf.html
+  # https://en.wikipedia.org/wiki/Telephone_numbers_in_Burkina_Faso
+  #
+  # There is no trunk code for this country and several of the mobile prefixes start with 0
+  country '226',
+    trunk('', normalize: false) |
+    none >> split(2,2,2,2)
+
   country '227', none >> split(4,4) # Niger http://www.wtng.info/wtng-227-ne.html
   country '228', none >> split(4,4) # Togolese Republic http://www.wtng.info/wtng-228-tg.html
   country '229', none >> split(4,4) # Benin http://www.itu.int/oth/T0202000017/en

data/spec/functional/config_spec.rb

@@ -18,27 +18,27 @@ describe 'Phony::Config' do
     it 'does not fail when loading all' do
       Phony::Config.load
       
-      Phony.split('15551115511').should == ['1', '555', '111', '5511']
+      expect(Phony.split('15551115511')).to eq ['1', '555', '111', '5511']
     end
     it 'raises when a CC is used that has not been loaded.' do
       Phony::Config.load('41')
       
-      expect { Phony.split('15551115511') }.to raise_error
+      expect { Phony.split('15551115511') }.to raise_error(Phony::SplittingError)
     end
     it 'raises when a CC is used that has not been loaded.' do
       Phony::Config.load(only: ['41'])
       
-      expect { Phony.split('15551115511') }.to raise_error
+      expect { Phony.split('15551115511') }.to raise_error(Phony::SplittingError)
     end
     it 'raises when a CC is used that has not been loaded.' do
       Phony::Config.load(except: ['1'])
       
-      expect { Phony.split('15551115511') }.to raise_error
+      expect { Phony.split('15551115511') }.to raise_error(Phony::SplittingError)
     end
     it 'does not raise when a CC is used that has been loaded.' do
       Phony::Config.load(except: ['41'])
       
-      Phony.split('15551115511').should == ['1', '555', '111', '5511']
+      expect(Phony.split('15551115511')).to eq ['1', '555', '111', '5511']
     end
   end
 end

data/spec/functional/plausibility_spec.rb

@@ -25,11 +25,11 @@ describe 'plausibility' do
           incorrect = [shortest.sub(/\d\s*\z/, '')] # , longest + '0']
 
           correct.each do |value|
-            Phony.plausible?(value).should be_truthy,
+            expect(Phony.plausible?(value)).to be_truthy,
               "It should validate #{value}, but does not."
           end
           incorrect.each do |value|
-            Phony.plausible?(value).should be_falsey,
+            expect(Phony.plausible?(value)).to be_falsey,
               "It should not validate #{value}, but does."
           end
         end
@@ -38,7 +38,7 @@ describe 'plausibility' do
           invalid = [*sample]
 
           invalid.each do |value|
-            Phony.plausible?(value).should be_falsey,
+            expect(Phony.plausible?(value)).to be_falsey,
               "It should not validate #{value}, but does."
           end
         end

data/spec/lib/phony/countries_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe 'country descriptions' do
 
   def self.it_splits number, expected
-    it { Phony.split(number).should == expected }
+    it { expect(Phony.split(number)).to eq expected }
   end
 
   describe 'regression' do
@@ -871,7 +871,7 @@ describe 'country descriptions' do
       it_splits '6737932744', %w(673 7 932 744)
     end
     describe 'Burkina Faso' do
-      it_splits '22667839323', ['226', false, '6783', '9323']
+      it_splits '22667839323', ['226', false, '67', '83', '93', '23']
     end
     describe 'Burundi' do
       it_splits '25712345678', ['257', false, '1234', '5678']

data/spec/lib/phony/country_codes_spec.rb

@@ -15,207 +15,209 @@ describe Phony::CountryCodes do
   describe 'ccc handling' do
     it 'splits a ccc correctly' do
       cc, ndc, *local = countries.split('1868')
-      cc.should eq('1')
-      ndc.should eq('868')
+      
+      expect(cc).to eq '1'
+      expect(ndc).to eq '868'
     end
     it 'splits a ccc correctly' do
       cc, ndc, *local = countries.split('1868')
-      cc.should eq('1')
-      ndc.should eq('868')
+      
+      expect(cc).to eq '1'
+      expect(ndc).to eq '868'
     end
   end
   
   describe '#[]' do
     it 'returns a country' do
-      countries['41'].class.should eql Phony::Country
+      expect(countries['41'].class).to eq Phony::Country
     end
   end
   
   describe '#country_for' do
     it 'returns a country' do
-      countries.send(:country_for, '41').class.should eql Phony::Country
+      expect(countries.send(:country_for, '41').class).to eq Phony::Country
     end
   end
   
   describe '#countrify' do
     it 'returns a country' do
-      countries.send(:countrify, '441231212', '41').should eql '41441231212'
+      expect(countries.send(:countrify, '441231212', '41')).to eq '41441231212'
     end
   end
   describe '#countrify!' do
     it 'in-place replaces the number' do
       number = '441231212'
-      countries.send(:countrify!, number, '41').should eql number
+      expect(countries.send(:countrify!, number, '41')).to eq number
       
-      number.should == '41441231212'
+      expect(number).to eq '41441231212'
     end
   end
   
   describe '#vanity?' do
     it 'returns true if so' do
-      countries.vanity?('1800HELLOES').should eql true
+      expect(countries.vanity?('1800HELLOES')).to eq true
     end
     it 'returns false if not' do
-      countries.vanity?('18001234567').should eql false
+      expect(countries.vanity?('18001234567')).to eq false
     end
   end
 
   describe 'normalize' do
     it 'normalizes correctly' do
-      countries.normalize('0041-44-364-35-32').should eql '41443643532'
+      expect(countries.normalize('0041-44-364-35-32')).to eq '41443643532'
     end
     it 'normalizes correctly with CC option' do
-      countries.normalize('044-364-35-32', cc: '41').should eql '41443643532'
+      expect(countries.normalize('044-364-35-32', cc: '41')).to eq '41443643532'
     end
 
     context 'specific countries' do
       it 'handles Congo correctly' do
-        countries.normalize('+242 0571 73992').should eql '242057173992'
-        countries.normalize('+242 2221 15932').should eql '242222115932'
+        expect(countries.normalize('+242 0571 73992')).to eq '242057173992'
+        expect(countries.normalize('+242 2221 15932')).to eq '242222115932'
       end
     end
   end
 
   describe 'formatted' do
     it 'formats correctly' do
-      countries.formatted('41443643532', :format => :international, :spaces => :-).should eql '+41-44-364-35-32'
+      expect(countries.formatted('41443643532', :format => :international, :spaces => :-)).to eq '+41-44-364-35-32'
     end
     it 'formats correctly' do
-      countries.formatted('41443643532', :format => :international_relative, :spaces => :-).should eql '0041-44-364-35-32'
+      expect(countries.formatted('41443643532', :format => :international_relative, :spaces => :-)).to eq '0041-44-364-35-32'
     end
     it 'formats correctly' do
-      countries.formatted('41443643532', :format => :national, :spaces => :-).should eql '044-364-35-32'
+      expect(countries.formatted('41443643532', :format => :national, :spaces => :-)).to eq '044-364-35-32'
     end
     context 'specific' do
       it 'formats Ireland correctly' do
-        countries.formatted("3533451234", :format => :national).should eql '0345 1234'
+        expect(countries.formatted("3533451234", :format => :national)).to eq '0345 1234'
       end
       it 'formats Ireland correctly' do
-        countries.formatted("353411231234", :format => :national).should eql '041 123 1234'
+        expect(countries.formatted("353411231234", :format => :national)).to eq '041 123 1234'
       end
       it 'formats Spain correctly' do
-        countries.formatted("34123456789", :format => :national).should eql '123 456 789'
+        expect(countries.formatted("34123456789", :format => :national)).to eq '123 456 789'
       end
       it 'formats Cambodia correctly' do
-        countries.formatted('85512239123', :format => :national).should eql '012 239 123'
+        expect(countries.formatted('85512239123', :format => :national)).to eq '012 239 123'
       end
       it 'formats the US correctly' do
-        countries.formatted('18005551212', :format => :national, :spaces => :-).should eql '(800)-555-1212'
+        expect(countries.formatted('18005551212', :format => :national, :spaces => :-)).to eq '(800)-555-1212'
       end
       it 'formats the US correctly' do
-        countries.formatted('18005551212', :format => :national, :spaces => :-).should eql '(800)-555-1212'
+        expect(countries.formatted('18005551212', :format => :national, :spaces => :-)).to eq '(800)-555-1212'
       end
     end
     context 'default' do
       it "should format swiss numbers" do
-        countries.formatted('41443643532').should eql '+41 44 364 35 32'
+        expect(countries.formatted('41443643532')).to eq '+41 44 364 35 32'
       end
       it "should format swiss service numbers" do
-        countries.formatted('41800112233').should eql '+41 800 112 233'
+        expect(countries.formatted('41800112233')).to eq '+41 800 112 233'
       end
       it "should format austrian numbers" do
-        countries.formatted('43198110').should eql '+43 1 98110'
+        expect(countries.formatted('43198110')).to eq '+43 1 98110'
       end
       it "should format american numbers" do
-        countries.formatted('18705551122').should eql '+1 (870) 555-1122'
+        expect(countries.formatted('18705551122')).to eq '+1 (870) 555-1122'
       end
       it "should format irish numbers" do
-        countries.formatted('35311234567').should eql '+353 1 123 4567'
+        expect(countries.formatted('35311234567')).to eq '+353 1 123 4567'
       end
     end
     describe "international" do
       it "should format north american numbers" do
-        countries.formatted('18091231234', :format => :international).should eql '+1 (809) 123-1234'
+        expect(countries.formatted('18091231234', :format => :international)).to eq '+1 (809) 123-1234'
       end
       it "should format austrian numbers" do
-        countries.formatted('43198110', :format => :international).should eql '+43 1 98110'
+        expect(countries.formatted('43198110', :format => :international)).to eq '+43 1 98110'
       end
       it "should format austrian numbers" do
-        countries.formatted('43198110', :format => :international_absolute).should eql '+43 1 98110'
+        expect(countries.formatted('43198110', :format => :international_absolute)).to eq '+43 1 98110'
       end
       it "should format french numbers" do
-        countries.formatted('33142278186', :format => :+).should eql '+33 1 42 27 81 86'
+        expect(countries.formatted('33142278186', :format => :+)).to eq '+33 1 42 27 81 86'
       end
       it "should format austrian numbers" do
-        countries.formatted('43198110', :format => :international_relative).should eql '0043 1 98110'
+        expect(countries.formatted('43198110', :format => :international_relative)).to eq '0043 1 98110'
       end
       it 'should format liechtensteiner numbers' do
-        countries.formatted('4233841148', :format => :international_relative).should eql '00423 384 11 48'
+        expect(countries.formatted('4233841148', :format => :international_relative)).to eq '00423 384 11 48'
       end
       it "should format irish numbers" do
-        countries.formatted('35311234567', :format => :international).should eql '+353 1 123 4567'
+        expect(countries.formatted('35311234567', :format => :international)).to eq '+353 1 123 4567'
       end
       it "should format luxembourgian numbers" do
-        countries.formatted('352222809', :format => :international).should eql '+352 22 28 09'
+        expect(countries.formatted('352222809', :format => :international)).to eq '+352 22 28 09'
       end
       it "should format luxembourgian 4-digit ndc numbers" do
-        countries.formatted('35226222809', :format => :international).should eql '+352 2622 28 09'
+        expect(countries.formatted('35226222809', :format => :international)).to eq '+352 2622 28 09'
       end
       it "should format luxembourgian mobile numbers" do
-        countries.formatted('352621123456', :format => :international).should eql '+352 621 123 456'
+        expect(countries.formatted('352621123456', :format => :international)).to eq '+352 621 123 456'
       end
       it "should format luxembourgian city numbers" do
-        countries.formatted('3524123456', :format => :international).should eql '+352 41 23 45 6'
+        expect(countries.formatted('3524123456', :format => :international)).to eq '+352 41 23 45 6'
       end
       it "should format luxembourgian machine to machine numbers" do
-        countries.formatted('352602112345678', :format => :international).should eql '+352 6021 12 34 56 78'
+        expect(countries.formatted('352602112345678', :format => :international)).to eq '+352 6021 12 34 56 78'
       end
       it "should format luxembourgian numbers" do
-        countries.formatted('352370431', :format => :international).should eql '+352 37 04 31'
+        expect(countries.formatted('352370431', :format => :international)).to eq '+352 37 04 31'
       end
       it "should format luxembourgian numbers" do
-        countries.formatted('35227855', :format => :international).should eql '+352 27 85 5'
+        expect(countries.formatted('35227855', :format => :international)).to eq '+352 27 85 5'
       end
       it "should format nigerian lagosian numbers" do
-        countries.formatted('23414480000', :format => :international).should eql '+234 1 448 0000'
+        expect(countries.formatted('23414480000', :format => :international)).to eq '+234 1 448 0000'
       end
       it "should format nigerian beninese numbers" do
-        countries.formatted('23452123456', :format => :international).should eql '+234 52 123 456'
+        expect(countries.formatted('23452123456', :format => :international)).to eq '+234 52 123 456'
       end
       it "should format nigerian mobile numbers" do
-        countries.formatted('2347061234567', :format => :international).should eql '+234 706 123 4567'
+        expect(countries.formatted('2347061234567', :format => :international)).to eq '+234 706 123 4567'
       end
       context 'with no spaces' do
         it "should format north american numbers" do
-          Phony.formatted('18091231234', :format => :international, :spaces => '').should eql '+1(809)123-1234'
+          expect(Phony.formatted('18091231234', :format => :international, :spaces => '')).to eq '+1(809)123-1234'
         end
         it "should format austrian numbers" do
-          Phony.formatted('43198110', :format => :international, :spaces => '').should eql '+43198110'
+          expect(Phony.formatted('43198110', :format => :international, :spaces => '')).to eq '+43198110'
         end
         it "should format austrian numbers" do
-          Phony.formatted('43198110', :format => :international_absolute, :spaces => '').should eql '+43198110'
+          expect(Phony.formatted('43198110', :format => :international_absolute, :spaces => '')).to eq '+43198110'
         end
         it "should format french numbers" do
-          Phony.formatted('33142278186', :format => :+, :spaces => '').should eql '+33142278186'
+          expect(Phony.formatted('33142278186', :format => :+, :spaces => '')).to eq '+33142278186'
         end
         it "should format austrian numbers" do
-          Phony.formatted('43198110', :format => :international_relative, :spaces => '').should eql '0043198110'
+          expect(Phony.formatted('43198110', :format => :international_relative, :spaces => '')).to eq '0043198110'
         end
         it 'should format liechtensteiner numbers' do
-          Phony.formatted('4233841148', :format => :international_relative, :spaces => '').should eql '004233841148'
+          expect(Phony.formatted('4233841148', :format => :international_relative, :spaces => '')).to eq '004233841148'
         end
       end
       context 'with special spaces' do
         it "should format swiss numbers" do
-          Phony.formatted('41443643532', :format => :international).should eql '+41 44 364 35 32'
+          expect(Phony.formatted('41443643532', :format => :international)).to eq '+41 44 364 35 32'
         end
         it "should format north american numbers" do
-          Phony.formatted('18091231234', :format => :international, :spaces => :-).should eql '+1-(809)-123-1234'
+          expect(Phony.formatted('18091231234', :format => :international, :spaces => :-)).to eq '+1-(809)-123-1234'
         end
         it "should format austrian numbers" do
-          Phony.formatted('43198110', :format => :international, :spaces => :-).should eql '+43-1-98110'
+          expect(Phony.formatted('43198110', :format => :international, :spaces => :-)).to eq '+43-1-98110'
         end
         it "should format austrian numbers" do
-          Phony.formatted('43198110', :format => :international_absolute, :spaces => :-).should eql '+43-1-98110'
+          expect(Phony.formatted('43198110', :format => :international_absolute, :spaces => :-)).to eq '+43-1-98110'
         end
         it "should format french numbers" do
-          Phony.formatted('33142278186', :format => :+, :spaces => :-).should eql '+33-1-42-27-81-86'
+          expect(Phony.formatted('33142278186', :format => :+, :spaces => :-)).to eq '+33-1-42-27-81-86'
         end
         it "should format austrian numbers" do
-          Phony.formatted('43198110', :format => :international_relative, :spaces => :-).should eql '0043-1-98110'
+          expect(Phony.formatted('43198110', :format => :international_relative, :spaces => :-)).to eq '0043-1-98110'
         end
         it 'should format liechtensteiner numbers' do
-          Phony.formatted('4233841148', :format => :international_relative, :spaces => :-).should eql '00423-384-11-48'
+          expect(Phony.formatted('4233841148', :format => :international_relative, :spaces => :-)).to eq '00423-384-11-48'
         end
 
       end

data/spec/lib/phony/country_spec.rb

@@ -12,12 +12,12 @@ describe Phony::Country do
     end
     describe '#clean' do
       it 'cleans the number' do
-        country.clean('+41-44-123-12-12').should eql '41441231212'
+        expect(country.clean('+41-44-123-12-12')).to eq '41441231212'
       end
     end
     describe '#vanity_to_number' do
       it 'turns the vanity number into a number' do
-        country.vanity_to_number('1-800-HELLO').should eql '1-800-43556'
+        expect(country.vanity_to_number('1-800-HELLO')).to eq '1-800-43556'
       end
     end
   end
@@ -32,27 +32,27 @@ describe Phony::Country do
         described_class.new national_code
       end
       it 'splits correctly' do
-        country.split('112').should == [nil, false, '112']
+        expect(country.split('112')).to eq [nil, false, '112']
       end
     end
     describe 'San Marino' do
       it 'normalizes correctly' do
-        Phony.normalize('+3780549903549').should == '3780549903549'
+        expect(Phony.normalize('+3780549903549')).to eq '3780549903549'
       end
       xit 'automatically adds the sole NC' do
-        Phony.normalize('+378903549').should == '3780549903549'
+        expect(Phony.normalize('+378903549')).to eq '3780549903549'
       end
     end
     describe 'Japan' do
       it 'normalizes correctly' do
-        Phony.normalize('+81-03-1234-5634').should == '81312345634'
-        Phony.normalize('03-1234-5634', cc: '81').should == '81312345634'
+        expect(Phony.normalize('+81-03-1234-5634')).to eq '81312345634'
+        expect(Phony.normalize('03-1234-5634', cc: '81')).to eq '81312345634'
       end
       it 'formats correctly' do
-        Phony.format('81312345634').should == '+81-3-1234-5634'
+        expect(Phony.format('81312345634')).to eq '+81-3-1234-5634'
       end
       it 'splits correctly' do
-        Phony.split('81312345634').should == %w(81 3 1234 5634)
+        expect(Phony.split('81312345634')).to eq %w(81 3 1234 5634)
       end
     end
   end
@@ -68,12 +68,12 @@ describe Phony::Country do
     
     describe "split" do
       it "should handle ZH" do
-        country.split('443643532').should == [nil, '44', '364', '35', '32']
+        expect(country.split('443643532')).to eq [nil, '44', '364', '35', '32']
       end
     end
     describe 'normalize' do
       it "should handle ZH" do
-        country.normalize('0443643532').should == '443643532'
+        expect(country.normalize('0443643532')).to eq '443643532'
       end
     end
   end
@@ -93,10 +93,10 @@ describe Phony::Country do
     
     describe "split" do
       it "should handle ZH" do
-        country.split('443643532').should == [nil, '44', '364', '35', '32']
+        expect(country.split('443643532')).to eq [nil, '44', '364', '35', '32']
       end
       it "should handle 800" do
-        country.split('800333666').should == [nil, '800', '333', '666']
+        expect(country.split('800333666')).to eq [nil, '800', '333', '666']
       end
     end
   end

data/spec/lib/phony/dsl_spec.rb

@@ -7,9 +7,13 @@ describe Phony::DSL do
   let(:dsl) { described_class.new }
 
   it 'has a todo' do
+    result = nil
+    
     Phony.define do
-      todo.split("123456789012345").should == [nil, false, '123456789012345']
+      result = todo.split("123456789012345")
     end
+    
+    expect(result).to eq [nil, false, '123456789012345']
   end
   
   describe 'match' do
@@ -17,7 +21,7 @@ describe Phony::DSL do
       expect { dsl.match(/123/) }.to raise_error("Regexp /123/ needs a group in it that defines which digits belong to the NDC.")
     end
     it 'should return a Phony::NationalSplitters::Regex' do
-      dsl.match(/(123)/).class.name.should == Phony::NationalSplitters::Regex.name
+      expect(dsl.match(/(123)/).class.name).to eq Phony::NationalSplitters::Regex.name
     end
   end
 

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

@@ -16,40 +16,37 @@ describe Phony::LocalSplitters::Regex do
   end
   
   describe 'split' do
-    before(:each) do
-      # Norway as example.
-      #
-      @splitter = described_class.instance_for(/^[489].*$/ => [3,2,3], :fallback => [2,2,2,2])
-    end
+    # Norway.
+    let(:splitter) { described_class.instance_for(/^[489].*$/ => [3,2,3], :fallback => [2,2,2,2]) }
     it 'splits a number correctly' do
-      @splitter.split('21234567').should == ['21','23','45','67']
+      expect(splitter.split('21234567')).to eq ['21','23','45','67']
     end
     it 'splits a number correctly' do
-      @splitter.split('31234567').should == ['31','23','45','67']
+      expect(splitter.split('31234567')).to eq ['31','23','45','67']
     end
     it 'splits a number correctly' do
-      @splitter.split('41234567').should == ['412','34','567']
+      expect(splitter.split('41234567')).to eq ['412','34','567']
     end
     it 'splits a number correctly' do
-      @splitter.split('51234567').should == ['51','23','45','67']
+      expect(splitter.split('51234567')).to eq ['51','23','45','67']
     end
     it 'splits a number correctly' do
-      @splitter.split('61234567').should == ['61','23','45','67']
+      expect(splitter.split('61234567')).to eq ['61','23','45','67']
     end
     it 'splits a number correctly' do
-      @splitter.split('71234567').should == ['71','23','45','67']
+      expect(splitter.split('71234567')).to eq ['71','23','45','67']
     end
     it 'splits a number correctly' do
-      @splitter.split('81234567').should == ['812','34','567']
+      expect(splitter.split('81234567')).to eq ['812','34','567']
     end
     it 'splits a number correctly' do
-      @splitter.split('91234567').should == ['912','34','567']
+      expect(splitter.split('91234567')).to eq ['912','34','567']
     end
     it 'splits it fast' do
-      performance_of { @splitter.split('21234567').should == ['21','23','45','67'] }.should < 0.00005
+      expect(performance_of { splitter.split('21234567') }).to be < 0.00005
     end
     it 'splits it fast' do
-      performance_of { @splitter.split('91234567').should == ['912','34','567'] }.should < 0.00004
+      expect(performance_of { splitter.split('91234567') }).to be < 0.00004
     end
   end
 

data/spec/lib/phony/national_code_spec.rb

@@ -5,87 +5,57 @@ describe Phony::NationalCode do
   describe 'split' do
     context 'regression' do
       describe 'iceland' do
-        before(:each) do
+        let(:national) do
           national_splitter = Phony::NationalSplitters::None.instance_for
           local_splitter    = Phony::LocalSplitters::Fixed.instance_for [3, 4]
 
-          @national         = Phony::NationalCode.new national_splitter, local_splitter
+          Phony::NationalCode.new national_splitter, local_splitter
         end
         it 'splits correctly' do
-          @national.split('112').should == [nil, false, '112']
+          expect(national.split('112')).to eq [nil, false, '112']
         end
       end
     end
     context 'with fixed ndc (Swiss)' do
-      before(:each) do
+      let(:national) do
         national_splitter = Phony::NationalSplitters::Fixed.instance_for 2
         local_splitter    = Phony::LocalSplitters::Fixed.instance_for [3, 2, 2]
         
-        @national         = Phony::NationalCode.new national_splitter, local_splitter
+        Phony::NationalCode.new national_splitter, local_splitter
       end
       it 'splits correctly' do
-        @national.split('443643532').should == [nil, '44', '364', '35', '32']
+        expect(national.split('443643532')).to eq [nil, '44', '364', '35', '32']
       end
       it 'splits correctly' do
-        @national.split('44364353').should == [nil, '44', '364', '35', '3']
+        expect(national.split('44364353')).to eq [nil, '44', '364', '35', '3']
       end
       it 'normalizes correctly' do
-        @national.normalize('044364353').should == '44364353'
+        expect(national.normalize('044364353')).to eq '44364353'
       end
       it 'normalizes correctly' do
-        @national.normalize('44364353').should == '44364353'
+        expect(national.normalize('44364353')).to eq '44364353'
       end
     end
     context 'with fixed ndc (French)' do
-      before(:each) do
+      let(:national) do
         national_splitter = Phony::NationalSplitters::Fixed.instance_for 1
         local_splitter    = Phony::LocalSplitters::Fixed.instance_for [2, 2, 2, 2]
         
-        @national         = Phony::NationalCode.new national_splitter, local_splitter
+        Phony::NationalCode.new national_splitter, local_splitter
       end
       it 'splits correctly' do
-        @national.split('142278186').should == [nil, '1', '42', '27', '81', '86']
+        expect(national.split('142278186')).to eq [nil, '1', '42', '27', '81', '86']
       end
       it 'splits correctly' do
-        @national.split('14227818').should == [nil, '1', '42', '27', '81', '8']
+        expect(national.split('14227818')).to eq [nil, '1', '42', '27', '81', '8']
       end
       it 'normalizes correctly' do
-        @national.normalize('0142278186').should == '142278186'
+        expect(national.normalize('0142278186')).to eq '142278186'
       end
       it 'normalizes correctly' do
-        @national.normalize('142278186').should == '142278186'
+        expect(national.normalize('142278186')).to eq '142278186'
       end
     end
-    # context 'normalizing' do
-    #   context 'false' do
-    #     before(:each) do
-    #       @national = Phony::NationalCode.new nil, nil, false
-    #     end
-    #     it 'normalizes an italian case correctly' do
-    #       @national.normalize('0909709511').should == '0909709511'
-    #     end
-    #   end
-    #   context 'true' do
-    #     before(:each) do
-    #       national_splitter = Phony::NationalSplitters::Fixed.instance_for 2
-    #       local_splitter    = Phony::LocalSplitters::Fixed.instance_for [3, 2, 2]
-    #       @national = Phony::NationalCode.new national_splitter, local_splitter, true
-    #     end
-    #     it 'normalizes a swiss case correctly' do
-    #       @national.normalize('044364353').should == '44364353'
-    #     end
-    #   end
-    #   context 'nil (true)' do
-    #     before(:each) do
-    #       national_splitter = Phony::NationalSplitters::Fixed.instance_for 2
-    #       local_splitter    = Phony::LocalSplitters::Fixed.instance_for [3, 2, 2]
-    #       @national = Phony::NationalCode.new national_splitter, local_splitter, nil
-    #     end
-    #     it 'normalizes a swiss case correctly' do
-    #       @national.normalize('044364353').should == '44364353'
-    #     end
-    #   end
-    # end
   end
   
 end

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

@@ -4,45 +4,41 @@ 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))
+      expect(Phony::NationalSplitters::Fixed.instance_for(3)).to eq 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))
+      expect(Phony::NationalSplitters::Fixed.instance_for(1)).to_not eq Phony::NationalSplitters::Fixed.instance_for(2)
     end
   end
   
   describe 'split' do
-    before(:each) do
-      @splitter = Phony::NationalSplitters::Fixed.new 2
-    end
+    let(:splitter) { Phony::NationalSplitters::Fixed.new(2) }
     it 'splits correctly' do
-      @splitter.split('443643532').should == [nil, '44', '3643532']
+      expect(splitter.split('443643532')).to eq [nil, '44', '3643532']
     end
     it 'splits correctly even when the number is too long' do
-      @splitter.split('44364353211').should == [nil, '44', '364353211']
+      expect(splitter.split('44364353211')).to eq [nil, '44', '364353211']
     end
     it 'splits correctly even when the number is too short' do
-      @splitter.split('443').should == [nil, '44','3']
+      expect(splitter.split('443')).to eq [nil, '44','3']
     end
     it 'has a length of 2' do
-      @splitter.length.should == 2
+      expect(splitter.length).to eq 2
     end
   end
   describe 'split' do
-    before(:each) do
-      @splitter = Phony::NationalSplitters::Fixed.new nil
-    end
+    let(:splitter) { Phony::NationalSplitters::Fixed.new(nil) }
     it 'splits correctly' do
-      @splitter.split('443643532').should == [nil, '443643532']
+      expect(splitter.split('443643532')).to eq [nil, '443643532']
     end
     it 'splits correctly even when the number is too long' do
-      @splitter.split('44364353211').should == [nil, '44364353211']
+      expect(splitter.split('44364353211')).to eq [nil, '44364353211']
     end
     it 'splits correctly even when the number is too short' do
-      @splitter.split('443').should == [nil, '443']
+      expect(splitter.split('443')).to eq [nil, '443']
     end
     it 'has a length of nil' do
-      @splitter.length.should == nil
+      expect(splitter.length).to eq nil
     end
   end
   

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

@@ -4,7 +4,7 @@ describe Phony::NationalSplitters::None do
   
   describe 'instance_for' do
     it 'caches' do
-      described_class.instance_for.should equal(described_class.instance_for)
+      expect(described_class.instance_for).to eq described_class.instance_for
     end
   end
   
@@ -13,13 +13,13 @@ describe Phony::NationalSplitters::None do
   
     describe 'split' do
       it 'splits correctly into ndc and rest' do
-        splitter.split('123456789').should == [nil, false, '123456789']
+        expect(splitter.split('123456789')).to eq [nil, false, '123456789']
       end
     end
     
     describe 'length' do
       it 'is always 0' do
-        splitter.length.should be_zero
+        expect(splitter.length).to be_zero
       end
     end
     

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

@@ -4,34 +4,30 @@ describe Phony::NationalSplitters::Variable do
   
   describe 'split' do
     context 'normal' do
-      before(:each) do
-        @splitter = Phony::NationalSplitters::Variable.new 4, ['1', '316', '67', '68', '669', '711']
-      end
+      let(:splitter) { Phony::NationalSplitters::Variable.new 4, ['1', '316', '67', '68', '669', '711'] }
       it "handles Vienna" do
-        @splitter.split('198110').should == [nil, '1', '98110']
+        expect(splitter.split('198110')).to eq [nil, '1', '98110']
       end
       it "handles some mobile services" do
-        @splitter.split('66914093902').should == [nil, '669', '14093902']
+        expect(splitter.split('66914093902')).to eq [nil, '669', '14093902']
       end
       it "handles Graz" do
-        @splitter.split('3161234567891').should == [nil, '316', '1234567891']
+        expect(splitter.split('3161234567891')).to eq [nil, '316', '1234567891']
       end
       it "handles Rohrau" do
-        @splitter.split('2164123456789').should == [nil, '2164', '123456789']
+        expect(splitter.split('2164123456789')).to eq [nil, '2164', '123456789']
       end
       it 'has an NDC length of 3' do
-        @splitter.length.should == (1..3)
+        expect(splitter.length).to eq (1..3)
       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, ['800']
-      end
+      let(:splitter) { Phony::NationalSplitters::Variable.new 2, ['800'] }
       it "should handle swiss service numbers" do
-        @splitter.split('800223344').should == [nil, '800', '223344']
+        expect(splitter.split('800223344')).to eq [nil, '800', '223344']
       end
       it 'has an NDC length of 3' do
-        @splitter.length.should == (3..3)
+        expect(splitter.length).to eq (3..3)
       end
     end
   end

data/spec/lib/phony/vanity_spec.rb

@@ -8,22 +8,22 @@ describe Phony::Vanity do
 
   describe '.replace' do
     it 'replaces letters with digits' do
-      vanity.replace('1-800-HELLO').should == '1-800-43556'
+      expect(vanity.replace('1-800-HELLO')).to eq '1-800-43556'
     end
   end
   
   describe '.vanity?' do
     it 'returns true on a vanity number' do
-      vanity.vanity?('800HELLOES').should == true
+      expect(vanity.vanity?('800HELLOES')).to eq true
     end
     it 'returns false on a non-vanity number' do
-      vanity.vanity?('8004355637').should == false
+      expect(vanity.vanity?('8004355637')).to eq false
     end
   end
   
   describe '.normalized' do
     it 'normalizes the vanity number' do
-      vanity.normalized('1-800-HELLO').should == '1800HELLO'
+      expect(vanity.normalized('1-800-HELLO')).to eq '1800HELLO'
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phony
 version: !ruby/object:Gem::Version
-  version: 2.20.2
+  version: 2.20.3
 platform: ruby
 authors:
 - Florian Hanke
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-23 00:00:00.000000000 Z
+date: 2023-04-18 00:00:00.000000000 Z
 dependencies: []
 description: 'Fast international phone number (E164 standard) normalizing, splitting
   and formatting. Lots of formatting options: International (+.., 00..), national