ibandit 0.11.6 → 0.11.7

data/spec/ibandit/sweden/validator_spec.rb

@@ -1,228 +1,228 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Ibandit::Sweden::Validator do
-  describe '.bank_code_exists_for_clearing_code?' do
+  describe ".bank_code_exists_for_clearing_code?" do
     subject do
       described_class.bank_code_exists_for_clearing_code?(clearing_code)
     end
 
-    context 'without a clearing code' do
+    context "without a clearing code" do
       let(:clearing_code) { nil }
       it { is_expected.to eq(false) }
     end
 
-    context 'with an impossible clearing code' do
-      let(:clearing_code) { '1001' }
+    context "with an impossible clearing code" do
+      let(:clearing_code) { "1001" }
       it { is_expected.to eq(false) }
     end
 
-    context 'with a possible clearing code' do
-      let(:clearing_code) { '1101' }
+    context "with a possible clearing code" do
+      let(:clearing_code) { "1101" }
       it { is_expected.to eq(true) }
     end
   end
 
-  describe '.valid_clearing_code_length?' do
+  describe ".valid_clearing_code_length?" do
     subject { described_class.valid_clearing_code_length?(clearing_code) }
 
-    context 'without a clearing code' do
+    context "without a clearing code" do
       let(:clearing_code) { nil }
       it { is_expected.to eq(nil) }
     end
 
-    context 'with an impossible clearing code' do
-      let(:clearing_code) { '1001' }
+    context "with an impossible clearing code" do
+      let(:clearing_code) { "1001" }
       it { is_expected.to eq(nil) }
     end
 
-    context 'with a correct length 4-digit clearing code' do
-      let(:clearing_code) { '1101' }
+    context "with a correct length 4-digit clearing code" do
+      let(:clearing_code) { "1101" }
       it { is_expected.to eq(true) }
     end
 
-    context 'with a correct length 5-digit clearing code' do
-      let(:clearing_code) { '80001' }
+    context "with a correct length 5-digit clearing code" do
+      let(:clearing_code) { "80001" }
       it { is_expected.to eq(true) }
     end
 
-    context 'with an incorrect length 5-digit clearing code' do
-      let(:clearing_code) { '40001' }
+    context "with an incorrect length 5-digit clearing code" do
+      let(:clearing_code) { "40001" }
       it { is_expected.to eq(false) }
     end
   end
 
-  describe '.valid_serial_number_length?' do
+  describe ".valid_serial_number_length?" do
     subject do
       described_class.valid_serial_number_length?(clearing_code: clearing_code,
                                                   serial_number: serial_number)
     end
 
-    context 'without a clearing code' do
+    context "without a clearing code" do
       let(:clearing_code) { nil }
-      let(:serial_number) { '1234567' }
+      let(:serial_number) { "1234567" }
       it { is_expected.to eq(nil) }
     end
 
-    context 'with an impossible clearing code' do
-      let(:clearing_code) { '1001' }
-      let(:serial_number) { '1234567' }
+    context "with an impossible clearing code" do
+      let(:clearing_code) { "1001" }
+      let(:serial_number) { "1234567" }
       it { is_expected.to eq(nil) }
     end
 
-    context 'with a correct length serial number' do
-      let(:clearing_code) { '1101' }
-      let(:serial_number) { '1234567' }
+    context "with a correct length serial number" do
+      let(:clearing_code) { "1101" }
+      let(:serial_number) { "1234567" }
       it { is_expected.to eq(true) }
     end
 
-    context 'with an incorrect length serial number' do
-      let(:clearing_code) { '1101' }
-      let(:serial_number) { '123456' }
+    context "with an incorrect length serial number" do
+      let(:clearing_code) { "1101" }
+      let(:serial_number) { "123456" }
       it { is_expected.to eq(false) }
     end
 
-    context 'with a short serial number for a clearing code that zerofills' do
-      let(:clearing_code) { '9960' }
-      let(:serial_number) { '123456' }
+    context "with a short serial number for a clearing code that zerofills" do
+      let(:clearing_code) { "9960" }
+      let(:serial_number) { "123456" }
       it { is_expected.to eq(true) }
     end
 
-    context 'with a long serial number for a clearing code that zerofills' do
-      let(:clearing_code) { '9960' }
-      let(:serial_number) { '12345678901' }
+    context "with a long serial number for a clearing code that zerofills" do
+      let(:clearing_code) { "9960" }
+      let(:serial_number) { "12345678901" }
       it { is_expected.to eq(false) }
     end
 
-    context 'without a serial number' do
-      let(:clearing_code) { '9960' }
+    context "without a serial number" do
+      let(:clearing_code) { "9960" }
       let(:serial_number) { nil }
       it { is_expected.to eq(false) }
     end
   end
 
-  describe '.bank_code_exists?' do
+  describe ".bank_code_exists?" do
     subject { described_class.bank_code_exists?(bank_code) }
 
-    context 'without a bank code' do
+    context "without a bank code" do
       let(:bank_code) { nil }
       it { is_expected.to eq(false) }
     end
 
-    context 'with an impossible bank code' do
-      let(:bank_code) { '123' }
+    context "with an impossible bank code" do
+      let(:bank_code) { "123" }
       it { is_expected.to eq(false) }
     end
 
-    context 'with a possible bank code' do
-      let(:bank_code) { '120' }
+    context "with a possible bank code" do
+      let(:bank_code) { "120" }
       it { is_expected.to eq(true) }
     end
   end
 
-  describe '.bank_code_possible_for_account_number?' do
+  describe ".bank_code_possible_for_account_number?" do
     subject do
       described_class.bank_code_possible_for_account_number?(
         bank_code: bank_code,
-        account_number: account_number
+        account_number: account_number,
       )
     end
 
-    context 'without a bank code' do
-      let(:account_number) { '12810105723' }
+    context "without a bank code" do
+      let(:account_number) { "12810105723" }
       let(:bank_code) { nil }
       it { is_expected.to eq(nil) }
     end
 
-    context 'with an impossible bank code' do
-      let(:account_number) { '12810105723' }
-      let(:bank_code) { '500' }
+    context "with an impossible bank code" do
+      let(:account_number) { "12810105723" }
+      let(:bank_code) { "500" }
       it { is_expected.to eq(false) }
     end
 
-    context 'with a possible bank code' do
-      let(:account_number) { '12810105723' }
-      let(:bank_code) { '120' }
+    context "with a possible bank code" do
+      let(:account_number) { "12810105723" }
+      let(:bank_code) { "120" }
       it { is_expected.to eq(true) }
     end
   end
 
-  describe '.account_number_length_valid_for_bank_code?' do
+  describe ".account_number_length_valid_for_bank_code?" do
     subject do
       described_class.account_number_length_valid_for_bank_code?(
         bank_code: bank_code,
-        account_number: account_number
+        account_number: account_number,
       )
     end
 
-    context 'without a bank code' do
-      let(:account_number) { '12810105723' }
+    context "without a bank code" do
+      let(:account_number) { "12810105723" }
       let(:bank_code) { nil }
       it { is_expected.to eq(nil) }
     end
 
-    context 'with an impossible bank code' do
-      let(:account_number) { '12810105723' }
-      let(:bank_code) { '500' }
+    context "with an impossible bank code" do
+      let(:account_number) { "12810105723" }
+      let(:bank_code) { "500" }
       it { is_expected.to eq(nil) }
     end
 
-    context 'with a normal type-1 account number' do
-      let(:account_number) { '00000054391024039' }
-      let(:bank_code) { '500' }
+    context "with a normal type-1 account number" do
+      let(:account_number) { "00000054391024039" }
+      let(:bank_code) { "500" }
       it { is_expected.to eq(true) }
 
-      context 'that has a 6 digit serial number' do
-        let(:account_number) { '00000005439102403' }
-        let(:bank_code) { '500' }
+      context "that has a 6 digit serial number" do
+        let(:account_number) { "00000005439102403" }
+        let(:bank_code) { "500" }
         it { is_expected.to eq(false) }
       end
 
-      context 'that has an 8 digit serial number' do
-        let(:account_number) { '00000543910240391' }
-        let(:bank_code) { '500' }
+      context "that has an 8 digit serial number" do
+        let(:account_number) { "00000543910240391" }
+        let(:bank_code) { "500" }
         it { is_expected.to eq(false) }
       end
     end
 
-    context 'with a Danske bank account' do
-      let(:account_number) { '12810105723' }
-      let(:bank_code) { '120' }
+    context "with a Danske bank account" do
+      let(:account_number) { "12810105723" }
+      let(:bank_code) { "120" }
       it { is_expected.to eq(true) }
 
-      context 'that has an 8 digit serial number' do
-        let(:account_number) { '00000128101057231' }
-        let(:bank_code) { '120' }
+      context "that has an 8 digit serial number" do
+        let(:account_number) { "00000128101057231" }
+        let(:bank_code) { "120" }
         it { is_expected.to eq(false) }
       end
 
-      context 'that has a 6 digit serial number' do
-        let(:account_number) { '00000001281010572' }
-        let(:bank_code) { '120' }
+      context "that has a 6 digit serial number" do
+        let(:account_number) { "00000001281010572" }
+        let(:bank_code) { "120" }
         # This passes because it could be a 10 digit account number from the
         # clearing code range 9180-9189.
         it { is_expected.to eq(true) }
       end
     end
 
-    context 'with a Handelsbanken account number' do
-      let(:bank_code) { '600' }
-      let(:account_number) { '00000000219161038' }
+    context "with a Handelsbanken account number" do
+      let(:bank_code) { "600" }
+      let(:account_number) { "00000000219161038" }
       it { is_expected.to eq(true) }
 
-      context 'that is only 8 characters long' do
-        let(:account_number) { '00000000021916103' }
+      context "that is only 8 characters long" do
+        let(:account_number) { "00000000021916103" }
         it { is_expected.to eq(true) }
       end
 
-      context 'that is 10 characters long' do
-        let(:account_number) { '00000002191610381' }
+      context "that is 10 characters long" do
+        let(:account_number) { "00000002191610381" }
         it { is_expected.to eq(false) }
       end
     end
 
-    context 'without a Nordea PlusGirot account number' do
-      let(:bank_code) { '950' }
-      let(:account_number) { '00099603401258276' }
+    context "without a Nordea PlusGirot account number" do
+      let(:bank_code) { "950" }
+      let(:account_number) { "00099603401258276" }
       it { is_expected.to eq(true) }
     end
   end

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
-require 'ibandit'
-require 'rspec/its'
-require 'json'
+require "ibandit"
+require "rspec/its"
+require "json"
 
 RSpec.configure do |config|
   config.mock_with(:rspec) { |mocks| mocks.verify_partial_doubles = true }
@@ -11,30 +11,30 @@ def json_fixture(filename)
   JSON.parse(File.read("spec/fixtures/#{filename}.json"))
 end
 
-RSpec.shared_context 'locale en', locale: :en do
+RSpec.shared_context "locale en", locale: :en do
   around { |example| I18n.with_locale(:en) { example.run } }
 end
 
-RSpec.shared_context 'locale fr', locale: :fr do
+RSpec.shared_context "locale fr", locale: :fr do
   around { |example| I18n.with_locale(:fr) { example.run } }
 end
 
-RSpec.shared_context 'locale de', locale: :de do
+RSpec.shared_context "locale de", locale: :de do
   around { |example| I18n.with_locale(:de) { example.run } }
 end
 
-RSpec.shared_context 'locale pt', locale: :pt do
+RSpec.shared_context "locale pt", locale: :pt do
   around { |example| I18n.with_locale(:pt) { example.run } }
 end
 
-RSpec.shared_context 'locale es', locale: :es do
+RSpec.shared_context "locale es", locale: :es do
   around { |example| I18n.with_locale(:es) { example.run } }
 end
 
-RSpec.shared_context 'locale it', locale: :it do
+RSpec.shared_context "locale it", locale: :it do
   around { |example| I18n.with_locale(:it) { example.run } }
 end
 
-RSpec.shared_context 'locale nl', locale: :nl do
+RSpec.shared_context "locale nl", locale: :nl do
   around { |example| I18n.with_locale(:nl) { example.run } }
 end

metadata

@@ -1,85 +1,113 @@
 --- !ruby/object:Gem::Specification
 name: ibandit
 version: !ruby/object:Gem::Version
-  version: 0.11.6
+  version: 0.11.7
 platform: ruby
 authors:
-- Grey Baker
+- GoCardless
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-17 00:00:00.000000000 Z
+date: 2017-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.3'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
-  name: rspec-its
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '0.10'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: pry-nav
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.33.0
+        version: '0.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.33.0
+        version: '0.2'
 - !ruby/object:Gem::Dependency
-  name: sax-machine
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
-  name: nokogiri
+  name: rspec-its
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.52.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.52.0
+- !ruby/object:Gem::Dependency
+  name: sax-machine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: i18n
   requirement: !ruby/object:Gem::Requirement
@@ -98,7 +126,7 @@ description: Ibandit is a Ruby library for manipulating and validating IBANs. It
   you to construct an IBAN from national banking details; deconstruct an IBAN into
   national banking details; and validate an IBAN's check digits and format.
 email:
-- grey@gocardless.com
+- developers@gocardless.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -177,7 +205,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Convert national banking details into IBANs, and vice-versa.