phony 2.20.14 → 2.20.15

data/spec/lib/phony/country_codes_spec.rb

@@ -1,227 +0,0 @@
-require 'spec_helper'
-
-describe Phony::CountryCodes do
-  
-  let(:countries) { Phony::CountryCodes.instance }
-  
-  describe '#plausible?' do
-    it 'raises an error on a too long ccc' do
-      expect do
-        countries.plausible?('+1 868 7620266', ccc: '1868123')
-      end.to raise_error(ArgumentError, %Q{The provided ccc option is too long and includes more than a cc ('1') and ndc ('868'). It also includes '123'.})
-    end
-  end
-  
-  describe 'ccc handling' do
-    it 'splits a ccc correctly' do
-      cc, ndc, *local = countries.split('1868')
-      
-      expect(cc).to eq '1'
-      expect(ndc).to eq '868'
-    end
-    it 'splits a ccc correctly' do
-      cc, ndc, *local = countries.split('1868')
-      
-      expect(cc).to eq '1'
-      expect(ndc).to eq '868'
-    end
-  end
-  
-  describe '#[]' do
-    it 'returns a country' do
-      expect(countries['41'].class).to eq Phony::Country
-    end
-  end
-  
-  describe '#country_for' do
-    it 'returns a country' do
-      expect(countries.send(:country_for, '41').class).to eq Phony::Country
-    end
-  end
-  
-  describe '#countrify' do
-    it 'returns a country' do
-      expect(countries.send(:countrify, '441231212', '41')).to eq '41441231212'
-    end
-  end
-  describe '#countrify!' do
-    it 'in-place replaces the number' do
-      number = '441231212'
-      expect(countries.send(:countrify!, number, '41')).to eq number
-      
-      expect(number).to eq '41441231212'
-    end
-  end
-  
-  describe '#vanity?' do
-    it 'returns true if so' do
-      expect(countries.vanity?('1800HELLOES')).to eq true
-    end
-    it 'returns false if not' do
-      expect(countries.vanity?('18001234567')).to eq false
-    end
-  end
-
-  describe 'normalize' do
-    it 'normalizes correctly' do
-      expect(countries.normalize('0041-44-364-35-32')).to eq '41443643532'
-    end
-    it 'normalizes correctly with CC option' do
-      expect(countries.normalize('044-364-35-32', cc: '41')).to eq '41443643532'
-    end
-
-    context 'specific countries' do
-      it 'handles Congo correctly' do
-        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
-      expect(countries.formatted('41443643532', :format => :international, :spaces => :-)).to eq '+41-44-364-35-32'
-    end
-    it 'formats correctly' do
-      expect(countries.formatted('41443643532', :format => :international_relative, :spaces => :-)).to eq '0041-44-364-35-32'
-    end
-    it 'formats correctly' do
-      expect(countries.formatted('41443643532', :format => :national, :spaces => :-)).to eq '044-364-35-32'
-    end
-    context 'specific' do
-      it 'formats Ireland correctly' do
-        expect(countries.formatted("3533451234", :format => :national)).to eq '0345 1234'
-      end
-      it 'formats Ireland correctly' do
-        expect(countries.formatted("353411231234", :format => :national)).to eq '041 123 1234'
-      end
-      it 'formats Spain correctly' do
-        expect(countries.formatted("34123456789", :format => :national)).to eq '123 456 789'
-      end
-      it 'formats Cambodia correctly' do
-        expect(countries.formatted('85512239123', :format => :national)).to eq '012 239 123'
-      end
-      it 'formats the US correctly' do
-        expect(countries.formatted('18005551212', :format => :national, :spaces => :-)).to eq '(800)-555-1212'
-      end
-      it 'formats the US correctly' do
-        expect(countries.formatted('18005551212', :format => :national, :spaces => :-)).to eq '(800)-555-1212'
-      end
-    end
-    context 'default' do
-      it "should format swiss numbers" do
-        expect(countries.formatted('41443643532')).to eq '+41 44 364 35 32'
-      end
-      it "should format swiss service numbers" do
-        expect(countries.formatted('41800112233')).to eq '+41 800 112 233'
-      end
-      it "should format austrian numbers" do
-        expect(countries.formatted('43198110')).to eq '+43 1 98110'
-      end
-      it "should format american numbers" do
-        expect(countries.formatted('18705551122')).to eq '+1 (870) 555-1122'
-      end
-      it "should format irish numbers" do
-        expect(countries.formatted('35311234567')).to eq '+353 1 123 4567'
-      end
-    end
-    describe "international" do
-      it "should format north american numbers" do
-        expect(countries.formatted('18091231234', :format => :international)).to eq '+1 (809) 123-1234'
-      end
-      it "should format austrian numbers" do
-        expect(countries.formatted('43198110', :format => :international)).to eq '+43 1 98110'
-      end
-      it "should format austrian numbers" do
-        expect(countries.formatted('43198110', :format => :international_absolute)).to eq '+43 1 98110'
-      end
-      it "should format french numbers" do
-        expect(countries.formatted('33142278186', :format => :+)).to eq '+33 1 42 27 81 86'
-      end
-      it "should format austrian numbers" do
-        expect(countries.formatted('43198110', :format => :international_relative)).to eq '0043 1 98110'
-      end
-      it 'should format liechtensteiner numbers' do
-        expect(countries.formatted('4233841148', :format => :international_relative)).to eq '00423 384 11 48'
-      end
-      it "should format irish numbers" do
-        expect(countries.formatted('35311234567', :format => :international)).to eq '+353 1 123 4567'
-      end
-      it "should format luxembourgian numbers" do
-        expect(countries.formatted('352222809', :format => :international)).to eq '+352 22 28 09'
-      end
-      it "should format luxembourgian 4-digit ndc numbers" do
-        expect(countries.formatted('35226222809', :format => :international)).to eq '+352 2622 28 09'
-      end
-      it "should format luxembourgian mobile numbers" do
-        expect(countries.formatted('352621123456', :format => :international)).to eq '+352 621 123 456'
-      end
-      it "should format luxembourgian city numbers" do
-        expect(countries.formatted('3524123456', :format => :international)).to eq '+352 41 23 45 6'
-      end
-      it "should format luxembourgian machine to machine numbers" do
-        expect(countries.formatted('352602112345678', :format => :international)).to eq '+352 6021 12 34 56 78'
-      end
-      it "should format luxembourgian numbers" do
-        expect(countries.formatted('352370431', :format => :international)).to eq '+352 37 04 31'
-      end
-      it "should format luxembourgian numbers" do
-        expect(countries.formatted('35227855', :format => :international)).to eq '+352 27 85 5'
-      end
-      it "should format nigerian lagosian numbers" do
-        expect(countries.formatted('23414480000', :format => :international)).to eq '+234 1 448 0000'
-      end
-      it "should format nigerian beninese numbers" do
-        expect(countries.formatted('23452123456', :format => :international)).to eq '+234 52 123 456'
-      end
-      it "should format nigerian mobile numbers" do
-        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
-          expect(Phony.formatted('18091231234', :format => :international, :spaces => '')).to eq '+1(809)123-1234'
-        end
-        it "should format austrian numbers" do
-          expect(Phony.formatted('43198110', :format => :international, :spaces => '')).to eq '+43198110'
-        end
-        it "should format austrian numbers" do
-          expect(Phony.formatted('43198110', :format => :international_absolute, :spaces => '')).to eq '+43198110'
-        end
-        it "should format french numbers" do
-          expect(Phony.formatted('33142278186', :format => :+, :spaces => '')).to eq '+33142278186'
-        end
-        it "should format austrian numbers" do
-          expect(Phony.formatted('43198110', :format => :international_relative, :spaces => '')).to eq '0043198110'
-        end
-        it 'should format liechtensteiner numbers' do
-          expect(Phony.formatted('4233841148', :format => :international_relative, :spaces => '')).to eq '004233841148'
-        end
-      end
-      context 'with special spaces' do
-        it "should format swiss numbers" do
-          expect(Phony.formatted('41443643532', :format => :international)).to eq '+41 44 364 35 32'
-        end
-        it "should format north american numbers" do
-          expect(Phony.formatted('18091231234', :format => :international, :spaces => :-)).to eq '+1-(809)-123-1234'
-        end
-        it "should format austrian numbers" do
-          expect(Phony.formatted('43198110', :format => :international, :spaces => :-)).to eq '+43-1-98110'
-        end
-        it "should format austrian numbers" do
-          expect(Phony.formatted('43198110', :format => :international_absolute, :spaces => :-)).to eq '+43-1-98110'
-        end
-        it "should format french numbers" do
-          expect(Phony.formatted('33142278186', :format => :+, :spaces => :-)).to eq '+33-1-42-27-81-86'
-        end
-        it "should format austrian numbers" do
-          expect(Phony.formatted('43198110', :format => :international_relative, :spaces => :-)).to eq '0043-1-98110'
-        end
-        it 'should format liechtensteiner numbers' do
-          expect(Phony.formatted('4233841148', :format => :international_relative, :spaces => :-)).to eq '00423-384-11-48'
-        end
-
-      end
-    end
-  end
-
-end

data/spec/lib/phony/country_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-
-describe Phony::Country do
-  
-  describe 'general' do
-    let(:country) do
-      national_splitter = Phony::NationalSplitters::Variable.new 4, ['44']
-      local_splitter    = Phony::LocalSplitters::Fixed.instance_for [3, 2, 2]
-      national_code     = Phony::NationalCode.new national_splitter, local_splitter
-      
-      Phony::Country.new national_code
-    end
-    describe '#clean' do
-      it 'cleans the number' do
-        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
-        expect(country.vanity_to_number('1-800-HELLO')).to eq '1-800-43556'
-      end
-    end
-  end
-  
-  context 'regression' do
-    describe 'Iceland' do
-      let(:country) do
-        national_splitter = Phony::NationalSplitters::None.instance_for
-        local_splitter    = Phony::LocalSplitters::Fixed.instance_for [3, 4]
-
-        national_code     = Phony::NationalCode.new national_splitter, local_splitter
-        described_class.new national_code
-      end
-      it 'splits correctly' do
-        expect(country.split('112')).to eq [nil, false, '112']
-      end
-    end
-    describe 'San Marino' do
-      it 'normalizes correctly' do
-        expect(Phony.normalize('+3780549903549')).to eq '3780549903549'
-      end
-      xit 'automatically adds the sole NC' do
-        expect(Phony.normalize('+378903549')).to eq '3780549903549'
-      end
-    end
-    describe 'Japan' do
-      it 'normalizes correctly' do
-        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
-        expect(Phony.format('81312345634')).to eq '+81-3-1234-5634'
-      end
-      it 'splits correctly' do
-        expect(Phony.split('81312345634')).to eq %w(81 3 1234 5634)
-      end
-    end
-  end
-  
-  context "without special cases (with switzerland)" do
-    let(:country) do
-      national_splitter = Phony::NationalSplitters::Variable.new 4, ['44']
-      local_splitter    = Phony::LocalSplitters::Fixed.instance_for [3, 2, 2]
-      national_code     = Phony::NationalCode.new national_splitter, local_splitter
-      
-      Phony::Country.new national_code
-    end
-    
-    describe "split" do
-      it "should handle ZH" do
-        expect(country.split('443643532')).to eq [nil, '44', '364', '35', '32']
-      end
-    end
-    describe 'normalize' do
-      it "should handle ZH" do
-        expect(country.normalize('0443643532')).to eq '443643532'
-      end
-    end
-  end
-  
-  context "without special cases" do
-    let(:country) do
-      special_national_splitter = Phony::NationalSplitters::Variable.new nil, ['800']
-      special_local_splitter    = Phony::LocalSplitters::Fixed.instance_for [3, 3]
-      special_code              = Phony::NationalCode.new special_national_splitter, special_local_splitter
-      
-      national_splitter         = Phony::NationalSplitters::Variable.new 4, ['44']
-      local_splitter            = Phony::LocalSplitters::Fixed.instance_for [3, 2, 2]
-      national_code             = Phony::NationalCode.new national_splitter, local_splitter
-      
-      Phony::Country.new special_code, national_code
-    end
-    
-    describe "split" do
-      it "should handle ZH" do
-        expect(country.split('443643532')).to eq [nil, '44', '364', '35', '32']
-      end
-      it "should handle 800" do
-        expect(country.split('800333666')).to eq [nil, '800', '333', '666']
-      end
-    end
-  end
-  
-end

data/spec/lib/phony/dsl_spec.rb

@@ -1,28 +0,0 @@
-# encoding: utf-8
-#
-require 'spec_helper'
-
-describe Phony::DSL do
-  
-  let(:dsl) { described_class.new }
-
-  it 'has a todo' do
-    result = nil
-    
-    Phony.define do
-      result = todo.split("123456789012345")
-    end
-    
-    expect(result).to eq [nil, false, '123456789012345']
-  end
-  
-  describe 'match' do
-    it 'checks for ( in regex' 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
-      expect(dsl.match(/(123)/).class.name).to eq Phony::NationalSplitters::Regex.name
-    end
-  end
-
-end

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

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-describe Phony::LocalSplitters::Fixed do
-  
-  describe 'instance_for' do
-    it 'caches' do
-      described_class.instance_for([3,2,2]).should equal(described_class.instance_for([3,2,2]))
-    end
-    it 'caches correctly' do
-      described_class.instance_for([1,2,3]).should_not equal(described_class.instance_for([9,9,9]))
-    end
-    it 'caches correctly' do
-      described_class.instance_for.should equal(described_class.instance_for)
-    end
-  end
-  
-  describe 'split' do
-    context "without format" do
-      before(:each) do
-        @splitter = described_class.new
-      end
-      it 'splits correctly' do
-        @splitter.split('3643532').should == ['364','35','32']
-      end
-      it 'splits correctly even when the number is too long (but leniently)' do
-        @splitter.split('3643532111').should == ['364','35','32111']
-      end
-      it 'splits correctly even when the number is too short' do
-        @splitter.split('364353').should == ['364','35','3']
-      end
-    end
-    context "with format" do
-      before(:each) do
-        @splitter = described_class.new [3, 2, 2]
-      end
-      it 'splits correctly' do
-        @splitter.split('3643532').should == ['364','35','32']
-      end
-      it 'splits correctly even when the number is too long (but leniently)' do
-        @splitter.split('3643532111').should == ['364','35','32111']
-      end
-      it 'splits correctly even when the number is too short' do
-        @splitter.split('364353').should == ['364','35','3']
-      end
-    end
-    context "with hard number (iceland regression)" do
-      before(:each) do
-        @splitter = described_class.new [3, 4]
-      end
-      it 'splits correctly' do
-        @splitter.split('112').should == ['112']
-      end
-    end
-  end
-  
-end

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

@@ -1,94 +0,0 @@
-require 'spec_helper'
-
-main = self
-
-describe Phony::LocalSplitters::Regex do
-  
-  before do
-    load 'spec_helper_extensions.rb'
-    main.send :include, SpecHelperExtensions
-  end
-  
-  describe 'instance_for' do
-    it 'does not cache' do
-      described_class.instance_for({}).should_not equal(described_class.instance_for({}))
-    end
-  end
-  
-  describe 'split' do
-    # Norway.
-    let(:splitter) { described_class.instance_for(/^[489].*$/ => [3,2,3], :fallback => [2,2,2,2]) }
-    it 'splits a number correctly' do
-      expect(splitter.split('21234567')).to eq ['21','23','45','67']
-    end
-    it 'splits a number correctly' do
-      expect(splitter.split('31234567')).to eq ['31','23','45','67']
-    end
-    it 'splits a number correctly' do
-      expect(splitter.split('41234567')).to eq ['412','34','567']
-    end
-    it 'splits a number correctly' do
-      expect(splitter.split('51234567')).to eq ['51','23','45','67']
-    end
-    it 'splits a number correctly' do
-      expect(splitter.split('61234567')).to eq ['61','23','45','67']
-    end
-    it 'splits a number correctly' do
-      expect(splitter.split('71234567')).to eq ['71','23','45','67']
-    end
-    it 'splits a number correctly' do
-      expect(splitter.split('81234567')).to eq ['812','34','567']
-    end
-    it 'splits a number correctly' do
-      expect(splitter.split('91234567')).to eq ['912','34','567']
-    end
-    it 'splits it fast' do
-      expect(performance_of { splitter.split('21234567') }).to be < 0.00005
-    end
-    it 'splits it fast' do
-      expect(performance_of { splitter.split('91234567') }).to be < 0.00004
-    end
-  end
-
-  describe 'plausible?' do
-    let(:number) {['123', '456']}
-    let(:result) { local_splitter.plausible?(number) }
-
-    context 'Local splitter without mappings' do
-      let(:local_splitter) { described_class.instance_for({})}
-      it 'returns false' do
-        result.should be_falsey
-      end
-    end
-
-    context 'Mapping does not exist for a number' do
-      let(:local_splitter) { described_class.instance_for(/\A5/ => [1,2,3])}
-      it 'returns false' do
-        result.should be_falsey
-      end
-    end
-
-    context "Mapping exists, but the length is greater" do
-      let(:local_splitter) { described_class.instance_for(/\A123/ => [2,2])}
-      it 'returns false' do
-        result.should be_falsey
-      end
-    end
-
-    context "Mapping exists, but the length is less" do
-      let(:local_splitter) { described_class.instance_for(/\A123/ => [2,2,3])}
-      it 'returns false' do
-        result.should be_falsey
-      end
-    end
-
-    context 'Mapping exists and the length is equal' do
-      let(:local_splitter) { described_class.instance_for(/\A123/ => [2,2,2])}
-      it 'returns true' do
-        result.should be_truthy
-      end
-    end
-
-  end
-  
-end

data/spec/lib/phony/national_code_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-describe Phony::NationalCode do
-  
-  describe 'split' do
-    context 'regression' do
-      describe 'iceland' do
-        let(:national) do
-          national_splitter = Phony::NationalSplitters::None.instance_for
-          local_splitter    = Phony::LocalSplitters::Fixed.instance_for [3, 4]
-
-          Phony::NationalCode.new national_splitter, local_splitter
-        end
-        it 'splits correctly' do
-          expect(national.split('112')).to eq [nil, false, '112']
-        end
-      end
-    end
-    context 'with fixed ndc (Swiss)' do
-      let(:national) do
-        national_splitter = Phony::NationalSplitters::Fixed.instance_for 2
-        local_splitter    = Phony::LocalSplitters::Fixed.instance_for [3, 2, 2]
-        
-        Phony::NationalCode.new national_splitter, local_splitter
-      end
-      it 'splits correctly' do
-        expect(national.split('443643532')).to eq [nil, '44', '364', '35', '32']
-      end
-      it 'splits correctly' do
-        expect(national.split('44364353')).to eq [nil, '44', '364', '35', '3']
-      end
-      it 'normalizes correctly' do
-        expect(national.normalize('044364353')).to eq '44364353'
-      end
-      it 'normalizes correctly' do
-        expect(national.normalize('44364353')).to eq '44364353'
-      end
-    end
-    context 'with fixed ndc (French)' do
-      let(:national) do
-        national_splitter = Phony::NationalSplitters::Fixed.instance_for 1
-        local_splitter    = Phony::LocalSplitters::Fixed.instance_for [2, 2, 2, 2]
-        
-        Phony::NationalCode.new national_splitter, local_splitter
-      end
-      it 'splits correctly' do
-        expect(national.split('142278186')).to eq [nil, '1', '42', '27', '81', '86']
-      end
-      it 'splits correctly' do
-        expect(national.split('14227818')).to eq [nil, '1', '42', '27', '81', '8']
-      end
-      it 'normalizes correctly' do
-        expect(national.normalize('0142278186')).to eq '142278186'
-      end
-      it 'normalizes correctly' do
-        expect(national.normalize('142278186')).to eq '142278186'
-      end
-    end
-  end
-  
-end

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

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe Phony::NationalSplitters::Default do
-  
-  describe 'instance_for' do
-    it 'caches' do
-      described_class.instance_for.should equal(described_class.instance_for)
-    end
-  end
-  
-  context 'with instance' do
-    let(:splitter) { described_class.instance_for }
-    
-    describe 'split' do
-      it 'does only pretend split' do
-        splitter.split(:anything).should == [nil, :anything]
-      end
-    end
-    
-    describe 'plausible?' do
-      it 'is always plausible' do
-        splitter.plausible?(:anything, :anything).should be_truthy
-      end
-    end
-    
-    describe 'length' do
-      it 'needs to be at least 3' do
-        splitter.length.should == 3
-      end
-    end
-    
-  end
-  
-end

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

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe Phony::NationalSplitters::Fixed do
-  
-  describe 'instance_for' do
-    it 'caches' do
-      expect(Phony::NationalSplitters::Fixed.instance_for(3)).to eq Phony::NationalSplitters::Fixed.instance_for(3)
-    end
-    it 'caches correctly' do
-      expect(Phony::NationalSplitters::Fixed.instance_for(1)).to_not eq Phony::NationalSplitters::Fixed.instance_for(2)
-    end
-  end
-  
-  describe 'split' do
-    let(:splitter) { Phony::NationalSplitters::Fixed.new(2) }
-    it 'splits correctly' do
-      expect(splitter.split('443643532')).to eq [nil, '44', '3643532']
-    end
-    it 'splits correctly even when the number is too long' do
-      expect(splitter.split('44364353211')).to eq [nil, '44', '364353211']
-    end
-    it 'splits correctly even when the number is too short' do
-      expect(splitter.split('443')).to eq [nil, '44','3']
-    end
-    it 'has a length of 2' do
-      expect(splitter.length).to eq 2
-    end
-  end
-  describe 'split' do
-    let(:splitter) { Phony::NationalSplitters::Fixed.new(nil) }
-    it 'splits correctly' do
-      expect(splitter.split('443643532')).to eq [nil, '443643532']
-    end
-    it 'splits correctly even when the number is too long' do
-      expect(splitter.split('44364353211')).to eq [nil, '44364353211']
-    end
-    it 'splits correctly even when the number is too short' do
-      expect(splitter.split('443')).to eq [nil, '443']
-    end
-    it 'has a length of nil' do
-      expect(splitter.length).to eq nil
-    end
-  end
-  
-end

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

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe Phony::NationalSplitters::None do
-  
-  describe 'instance_for' do
-    it 'caches' do
-      expect(described_class.instance_for).to eq described_class.instance_for
-    end
-  end
-  
-  context 'with instance' do
-    let(:splitter) { described_class.instance_for }
-  
-    describe 'split' do
-      it 'splits correctly into ndc and rest' do
-        expect(splitter.split('123456789')).to eq [nil, false, '123456789']
-      end
-    end
-    
-    describe 'length' do
-      it 'is always 0' do
-        expect(splitter.length).to be_zero
-      end
-    end
-    
-  end
-  
-end