phony 2.20.1 → 2.20.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2e0337c11693c028c028c978936d9753067bab16cceb1deba77f39e535fbb50
-  data.tar.gz: 45468532f0d66381ce8b52f8c500881ee6a34f134450f6ffac5b57193c1d4323
+  metadata.gz: 27443f0af2d18a25a1b9056a1a09e77dffd8e8669346d974a3970cdfe9931ee4
+  data.tar.gz: b5d22d65bb38fcb66b8f966716e5a5ee582d272a53b418b3ed20070ce90a74c1
 SHA512:
-  metadata.gz: 1c2ad0d4272a0eaf808bc95f8ace53b1d3c5f7fe2718bd555547b5611915eee4a5f34ea968ef7ebe8fb7b4b8cb86b9040b8af48a8181a7d287a9a39d9906f312
-  data.tar.gz: 0a2e811f7f43f4e357fbe384381565a884073d98e6f1376664df1f457cf210dc759bf50c140749e7447cb034cc40e9d2916a77d3c7555df7f922fa5f522652f0
+  metadata.gz: 5ee83977f8d9f5b8ccbcbbea65976ff20456fd35f4adca206e91b9efe4838cf80bef3a15b8cd837e093f4cfedca43a757e7ecd2c941abae9d08c0d54f217c930
+  data.tar.gz: 30760e746ca05cadc07b41e404507537a18f516938b9701a18ecedd6a56d14f9f1eb39eee754d8121679e7217514be356f250292a7d7a9bad7a89efcc98168c4

data/lib/phony/countries/italy.rb

@@ -256,7 +256,8 @@ ndcs_3digit = [
 # but this was not frozen so easily.
 mobile = %w(300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399)
 
-service = [ # Not exhaustive.
+# Not exhaustive.
+service = [
  '112',
  '113',
  '115',
@@ -268,11 +269,19 @@ service = [ # Not exhaustive.
  '1530'
 ]
 
+# Not exhaustive. Unused below - just for info purposes.
+free_of_charge_services = [
+  '800',
+  '803'
+]
+
 Phony.define do
   # Note: The 0 does not count towards NDC number length.
   country '39', trunk('', normalize: false) |
                 one_of(*service)     >> split(3,3) |
                 one_of(*mobile)      >> split(3,4,-1..1) |
+                match(/^(800)\d{6}$/) >> split(6) | # 3-6, Special handling for 800 numbers.
+                match(/^(803)\d{3}$/) >> split(3) | # 3-3, Special handling for 803 numbers.
                 one_of(*ndcs_1digit) >> matched_split(
                   /\A\d{5}\z/ => [5],
                   /\A\d{6}\z/ => [4,2],

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
@@ -621,6 +621,12 @@ describe 'plausibility' do
         Phony.plausible?('+39 06 4991').should be_falsy
         Phony.plausible?('+39 06 49911').should be_truthy
         Phony.plausible?('+39 06 499112').should be_truthy
+
+        Phony.plausible?('+39 800 081631').should be_truthy
+        Phony.plausible?('+39 800 0816311').should be_falsy
+
+        Phony.plausible?('+39 803 08163').should be_falsy
+        Phony.plausible?('+39 803 081').should be_truthy
       end
 
       it 'is correct for Russia' do

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.1
+  version: 2.20.3
 platform: ruby
 authors:
 - Florian Hanke
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-03 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
@@ -115,26 +115,26 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: Fast international phone number (E164 standard) normalizing, splitting and
   formatting.
 test_files:
-- spec/lib/phony_spec.rb
-- spec/lib/phony/trunk_code_spec.rb
-- spec/lib/phony/country_spec.rb
-- spec/lib/phony/national_code_spec.rb
+- spec/functional/config_spec.rb
+- spec/functional/plausibility_spec.rb
 - spec/lib/phony/countries_spec.rb
+- spec/lib/phony/country_codes_spec.rb
+- spec/lib/phony/country_spec.rb
 - spec/lib/phony/dsl_spec.rb
-- spec/lib/phony/national_splitters/variable_spec.rb
+- spec/lib/phony/local_splitters/fixed_spec.rb
+- spec/lib/phony/local_splitters/regex_spec.rb
+- spec/lib/phony/national_code_spec.rb
+- spec/lib/phony/national_splitters/default_spec.rb
+- spec/lib/phony/national_splitters/fixed_spec.rb
 - spec/lib/phony/national_splitters/none_spec.rb
 - spec/lib/phony/national_splitters/regex_spec.rb
-- spec/lib/phony/national_splitters/fixed_spec.rb
-- spec/lib/phony/national_splitters/default_spec.rb
-- spec/lib/phony/country_codes_spec.rb
-- spec/lib/phony/local_splitters/regex_spec.rb
-- spec/lib/phony/local_splitters/fixed_spec.rb
+- spec/lib/phony/national_splitters/variable_spec.rb
+- spec/lib/phony/trunk_code_spec.rb
 - spec/lib/phony/vanity_spec.rb
-- spec/functional/config_spec.rb
-- spec/functional/plausibility_spec.rb
+- spec/lib/phony_spec.rb