valvat 1.4.0 → 1.4.2

data/spec/valvat/utils_spec.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Valvat::Utils do
-  describe '#split' do
-    it 'returns country and rest on VAT number as array' do
-      expect(described_class.split('DE345889003')).to eql(%w[DE 345889003])
-      expect(described_class.split('ESX4588900X')).to eql(%w[ES X4588900X])
-    end
-
-    it 'returns two nils on non-european iso codes as array' do
-      expect(described_class.split('US345889003')).to eql([nil, nil])
-      expect(described_class.split('RUX4588900X')).to eql([nil, nil])
-    end
-
-    it 'returns two nils on non-sense input as array' do
-      expect(described_class.split('DE')).to eql([nil, nil])
-      expect(described_class.split('X345889003')).to eql([nil, nil])
-      expect(described_class.split('')).to eql([nil, nil])
-      expect(described_class.split('1234')).to eql([nil, nil])
-      expect(described_class.split(' ')).to eql([nil, nil]) # rubocop:disable Style/RedundantArgument
-    end
-
-    it 'returns EL (language iso code) on greek vat' do
-      expect(described_class.split('EL999999999')).to eql(%w[EL 999999999])
-    end
-
-    it 'returns XI (vat number code) on northern ireland vat' do
-      expect(described_class.split('XI999999999')).to eql(%w[XI 999999999])
-    end
-  end
-
-  describe '#normalize' do
-    it 'returns VAT number with upcase chars' do
-      expect(described_class.normalize('de345889003')).to eql('DE345889003')
-      expect(described_class.normalize('EsX4588900y')).to eql('ESX4588900Y')
-    end
-
-    it 'returns trimmed VAT number' do
-      expect(described_class.normalize(' DE345889003')).to eql('DE345889003')
-      expect(described_class.normalize('  DE345889003  ')).to eql('DE345889003')
-      expect(described_class.normalize('DE345889003 ')).to eql('DE345889003')
-    end
-
-    it 'does not change already normalized VAT numbers' do
-      expect(described_class.normalize('DE345889003')).to eql('DE345889003')
-      expect(described_class.normalize('ESX4588900X')).to eql('ESX4588900X')
-    end
-
-    it 'removes spaces' do
-      expect(described_class.normalize('DE 345889003')).to eql('DE345889003')
-      expect(described_class.normalize('ESX  458 8900 X')).to eql('ESX4588900X')
-    end
-
-    it 'removes special chars' do
-      expect(described_class.normalize('DE.345-889_00:3,;')).to eql('DE345889003')
-      expect(described_class.normalize("→ DE·Ö34588 9003\0 ☺")).to eql(
-        '→DEÖ345889003☺'
-      )
-    end
-  end
-
-  describe '#vat_country_to_iso_country' do
-    it "returns iso country code on greek iso language 'EL'" do
-      expect(described_class.vat_country_to_iso_country('EL')).to eql('GR')
-    end
-
-    it "returns iso country code on northern ireland vat prefix 'XI'" do
-      expect(described_class.vat_country_to_iso_country('XI')).to eql('GB')
-    end
-
-    Valvat::Utils::EU_MEMBER_STATES.each do |iso|
-      it "returns unchanged iso country code '#{iso}'" do
-        expect(described_class.vat_country_to_iso_country(iso)).to eql(iso)
-      end
-    end
-  end
-
-  describe '#iso_country_to_vat_country' do
-    it "returns VAT country EL on greek iso country code 'GR'" do
-      expect(described_class.iso_country_to_vat_country('GR')).to eql('EL')
-    end
-
-    it "returns VAT country XI on british iso country code 'GB'" do
-      expect(described_class.iso_country_to_vat_country('GB')).to eql('XI')
-    end
-
-    Valvat::Utils::EU_MEMBER_STATES.each do |c|
-      next if c == 'GR'
-
-      it "returns unchanged VAT country code '#{c}'" do
-        expect(described_class.iso_country_to_vat_country(c)).to eql(c)
-      end
-    end
-  end
-
-  describe '#country_is_supported?' do
-    Valvat::Utils::EU_MEMBER_STATES.each do |code|
-      it "returns true on #{code}" do
-        expect(described_class.country_is_supported?(code)).to be(true)
-      end
-    end
-
-    it 'returns true on GB' do
-      expect(described_class.country_is_supported?('GB')).to be(true)
-    end
-
-    %w[US AE CA CN BR AU NO ML].each do |code|
-      it "returns false on #{code}" do
-        expect(described_class.country_is_supported?(code)).to be(false)
-      end
-    end
-  end
-
-  describe '#deep_symbolize_keys' do
-    it 'symbolizes keys of flat hash' do
-      expect(described_class.deep_symbolize_keys({ 'a' => 1, :b => 2 })).to eql({ a: 1, b: 2 })
-    end
-
-    it 'symbolizes all hashes' do
-      expect(described_class.deep_symbolize_keys({ 'a' => 1, :b => { 'c' => 3 } })).to eql({ a: 1, b: { c: 3 } })
-    end
-  end
-end

data/spec/valvat_spec.rb

@@ -1,276 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Valvat do
-  describe '#new' do
-    it 'demands one and only one argument' do
-      expect { described_class.new }.to raise_error(ArgumentError)
-      expect { described_class.new('a', 'b') }.to raise_error(ArgumentError)
-      expect { described_class.new('a') }.not_to raise_error
-    end
-
-    it 'normalizes input string' do
-      expect(described_class.new('de25.9597,69 7').to_s).to eql('DE259597697')
-      expect(described_class.new('de25.9597,69 7').iso_country_code).to eql('DE')
-    end
-  end
-
-  describe 'Valvat()' do
-    it 'initializes new Valvat instance on string' do
-      expect(Valvat('abc')).to be_a(described_class)
-    end
-
-    it 'returns same Valvat instance on Valvat instance' do
-      vat = described_class.new('abc')
-      expect(Valvat(vat)).to be_a(described_class)
-      expect(Valvat(vat).object_id).to eql(vat.object_id)
-    end
-  end
-
-  describe '#blank?' do
-    it 'returns true when when initialized with nil' do
-      expect(described_class.new(nil)).to be_blank
-    end
-
-    it 'returns true when when initialized with an empty string' do
-      expect(described_class.new(' ')).to be_blank
-    end
-
-    it 'returns false when initialized with a value' do
-      expect(described_class.new('DE259597697')).not_to be_blank
-    end
-  end
-
-  describe 'object equality' do
-    it 'returns true when the underlying number are the same' do
-      first = 'DE259597697'
-      second = 'DE259597697'
-
-      expect(described_class.new(first)).to eql(described_class.new(second))
-    end
-
-    it 'returns true when the underlying number are the same when normalized' do
-      first = 'DE259597697'
-      second = 'DE  2595 9 7697    '
-
-      expect(described_class.new(first)).to eql(described_class.new(second))
-    end
-
-    it 'returns false when the underlying number are different' do
-      first = 'DE259597697'
-      second = 'ATU458890031'
-
-      expect(described_class.new(first)).not_to eql(described_class.new(second))
-    end
-  end
-
-  context 'with european VAT number' do
-    let(:de_vat) { described_class.new('DE259597697') } # valid & exists
-    let(:invalid_checksum) { described_class.new('DE259597687') } # valid & invalid checksum
-    let(:at_vat) { described_class.new('ATU458890031') } # invalid
-    let(:gr_vat) { described_class.new('EL999943280') } # valid & exists
-
-    describe '#valid?' do
-      it 'returns true on valid numbers' do
-        expect(de_vat).to be_valid
-        expect(gr_vat).to be_valid
-      end
-
-      it 'returns false on invalid numbers' do
-        expect(at_vat).not_to be_valid
-      end
-    end
-
-    describe '#valid_checksum?' do
-      it 'returns true on valid numbers' do
-        expect(de_vat).to be_valid_checksum
-        expect(gr_vat).to be_valid_checksum
-      end
-
-      it 'returns false on invalid numbers' do
-        expect(at_vat).not_to be_valid_checksum
-        expect(invalid_checksum).not_to be_valid_checksum
-      end
-    end
-
-    describe '#exist(s)?' do
-      it 'returns true with existing VAT numbers' do
-        allow(Valvat::Lookup).to receive_messages(validate: true)
-        expect(de_vat.exists?).to be(true)
-        expect(gr_vat.exists?).to be(true)
-        expect(de_vat.exist?).to be(true)
-        expect(gr_vat.exist?).to be(true)
-      end
-
-      it 'returns false with not existing VAT numbers' do
-        allow(Valvat::Lookup).to receive_messages(validate: false)
-        expect(at_vat.exists?).to be(false)
-        expect(at_vat.exist?).to be(false)
-      end
-
-      it 'calls Valvat::Lookup.validate with options' do
-        allow(Valvat::Lookup).to receive_messages(validate: true)
-        expect(de_vat.exists?(detail: true, bla: 'blupp')).to be(true)
-        expect(Valvat::Lookup).to have_received(:validate).once.with(
-          de_vat, detail: true, bla: 'blupp'
-        )
-      end
-    end
-
-    describe '#iso_country_code' do
-      it 'returns iso country code on iso_country_code' do
-        expect(de_vat.iso_country_code).to eql('DE')
-        expect(at_vat.iso_country_code).to eql('AT')
-      end
-
-      it 'returns GR iso country code on greek VAT number' do
-        expect(gr_vat.iso_country_code).to eql('GR')
-      end
-    end
-
-    describe '#vat_country_code' do
-      it 'returns iso country code on iso_country_code' do
-        expect(de_vat.vat_country_code).to eql('DE')
-        expect(at_vat.vat_country_code).to eql('AT')
-      end
-
-      it 'returns EL iso language code on greek VAT number' do
-        expect(gr_vat.vat_country_code).to eql('EL')
-      end
-    end
-
-    describe '#to_s' do
-      it 'returns full VAT number' do
-        expect(de_vat.to_s).to eql('DE259597697')
-        expect(at_vat.to_s).to eql('ATU458890031')
-        expect(gr_vat.to_s).to eql('EL999943280')
-      end
-    end
-
-    describe '#inspect' do
-      it 'returns VAT number with iso country code' do
-        expect(de_vat.inspect).to eql('#<Valvat DE259597697 DE>')
-        expect(at_vat.inspect).to eql('#<Valvat ATU458890031 AT>')
-        expect(gr_vat.inspect).to eql('#<Valvat EL999943280 GR>')
-      end
-    end
-
-    describe '#to_a' do
-      it 'calls Valvat::Utils.split with raw VAT number and returns result' do
-        allow(Valvat::Utils).to receive(:split).and_return(%w[a b])
-        de_vat # initialize
-        expect(Valvat::Utils).to have_received(:split).once.with('DE259597697')
-        expect(de_vat.to_a).to eql(%w[a b])
-      end
-    end
-  end
-
-  context 'with VAT number from outside of europe' do
-    let(:us_vat) { described_class.new('US345889003') }
-    let(:ch_vat) { described_class.new('CH445889003') }
-
-    describe '#valid?' do
-      it 'returns false' do
-        expect(us_vat).not_to be_valid
-        expect(ch_vat).not_to be_valid
-      end
-    end
-
-    describe '#exist?' do
-      it 'returns false' do
-        expect(us_vat).not_to be_exist
-        expect(ch_vat).not_to be_exist
-      end
-    end
-
-    describe '#iso_country_code' do
-      it 'returns nil' do
-        expect(us_vat.iso_country_code).to be_nil
-        expect(ch_vat.iso_country_code).to be_nil
-      end
-    end
-
-    describe '#vat_country_code' do
-      it 'returns nil' do
-        expect(us_vat.vat_country_code).to be_nil
-        expect(ch_vat.vat_country_code).to be_nil
-      end
-    end
-
-    describe '#to_s' do
-      it 'returns full given VAT number' do
-        expect(us_vat.to_s).to eql('US345889003')
-        expect(ch_vat.to_s).to eql('CH445889003')
-      end
-    end
-
-    describe '#inspect' do
-      it 'returns VAT number without iso country code' do
-        expect(us_vat.inspect).to eql('#<Valvat US345889003>')
-        expect(ch_vat.inspect).to eql('#<Valvat CH445889003>')
-      end
-    end
-  end
-
-  context 'with non-sense/empty VAT number' do
-    let(:only_iso_vat) { described_class.new('DE') }
-    let(:num_vat) { described_class.new('12445889003') }
-    let(:empty_vat) { described_class.new('') }
-    let(:nil_vat) { described_class.new('') }
-
-    describe '#valid?' do
-      it 'returns false' do
-        expect(only_iso_vat).not_to be_valid
-        expect(num_vat).not_to be_valid
-        expect(empty_vat).not_to be_valid
-        expect(nil_vat).not_to be_valid
-      end
-    end
-
-    describe '#exist?' do
-      it 'returns false' do
-        expect(only_iso_vat).not_to be_exist
-        expect(num_vat).not_to be_exist
-        expect(empty_vat).not_to be_exist
-        expect(nil_vat).not_to be_exist
-      end
-    end
-
-    describe '#iso_country_code' do
-      it 'returns nil' do
-        expect(only_iso_vat.iso_country_code).to be_nil
-        expect(num_vat.iso_country_code).to be_nil
-        expect(empty_vat.iso_country_code).to be_nil
-        expect(nil_vat.iso_country_code).to be_nil
-      end
-    end
-
-    describe '#vat_country_code' do
-      it 'returns nil' do
-        expect(only_iso_vat.vat_country_code).to be_nil
-        expect(num_vat.vat_country_code).to be_nil
-        expect(empty_vat.vat_country_code).to be_nil
-        expect(nil_vat.vat_country_code).to be_nil
-      end
-    end
-
-    describe '#to_s' do
-      it 'returns full given VAT number' do
-        expect(only_iso_vat.to_s).to eql('DE')
-        expect(num_vat.to_s).to eql('12445889003')
-        expect(empty_vat.to_s).to eql('')
-        expect(nil_vat.to_s).to eql('')
-      end
-    end
-
-    describe '#inspect' do
-      it 'returns VAT number without iso country code' do
-        expect(only_iso_vat.inspect).to eql('#<Valvat DE>')
-        expect(num_vat.inspect).to eql('#<Valvat 12445889003>')
-        expect(empty_vat.inspect).to eql('#<Valvat >')
-        expect(nil_vat.inspect).to eql('#<Valvat >')
-      end
-    end
-  end
-end

data/valvat.gemspec

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH.push File.expand_path('lib', __dir__)
-require 'valvat/version'
-
-Gem::Specification.new do |s|
-  s.name                              = 'valvat'
-  s.version                           = Valvat::VERSION
-  s.platform                          = Gem::Platform::RUBY
-  s.license                           = 'MIT'
-  s.authors                           = ['Sebastian Munz']
-  s.email                             = ['sebastian@mite.de']
-  s.homepage                          = 'https://github.com/yolk/valvat'
-  s.summary                           = 'Validates european vat numbers. Standalone or as a ActiveModel validator.'
-  s.description                       = 'Validates european vat numbers. Standalone or as a ActiveModel validator.'
-  s.files                             = `git ls-files`.split("\n")
-  s.require_paths                     = ['lib']
-  s.cert_chain                        = ['certs/mite.pem']
-  s.signing_key                       = File.expand_path('~/.ssh/gem-private_key.pem') if $PROGRAM_NAME =~ /gem\z/
-  s.metadata['rubygems_mfa_required'] = 'true'
-  s.required_ruby_version             = '>= 2.6.0'
-
-  s.add_runtime_dependency('rexml', '>= 3.2', '< 4.0')
-end