ibandit 0.11.6 → 0.11.7

data/lib/ibandit/pseudo_iban_assembler.rb

@@ -18,7 +18,7 @@ module Ibandit
         Constants::PSEUDO_IBAN_CHECK_DIGITS,
         padded_bank_code,
         padded_branch_code,
-        padded_account_number
+        padded_account_number,
       ].join
     end
 
@@ -67,7 +67,7 @@ module Ibandit
 
     def pad(number, length_key)
       return if number.nil?
-      number.rjust(structure[length_key], 'X')
+      number.rjust(structure[length_key], "X")
     end
 
     def structure

data/lib/ibandit/pseudo_iban_splitter.rb

@@ -5,45 +5,48 @@ module Ibandit
     end
 
     def split
-      return unless decomposable?
-
       {
         country_code: country_code,
+        check_digits: check_digits,
         bank_code: bank_code,
         branch_code: branch_code,
-        account_number: account_number
+        account_number: account_number,
       }
     end
 
-    private
-
     def country_code
       @pseudo_iban.slice(0, 2)
     end
 
+    private
+
     def check_digits
       @pseudo_iban.slice(2, 2)
     end
 
     def bank_code
+      return unless country_code_valid?
       pseudo_iban_part(bank_code_start_index, :pseudo_iban_bank_code_length)
     end
 
     def branch_code
+      return unless country_code_valid?
       pseudo_iban_part(branch_code_start_index,
                        :pseudo_iban_branch_code_length)
     end
 
     def account_number
-      pseudo_iban_part(account_number_start_index,
-                       :pseudo_iban_account_number_length)
+      return unless country_code_valid?
+      remove_leading_padding(
+        @pseudo_iban.slice(account_number_start_index, @pseudo_iban.length),
+      )
     end
 
     def pseudo_iban_part(start_index, length_key)
       length = structure.fetch(length_key)
       return if length == 0
 
-      @pseudo_iban.slice(start_index, length).gsub(/\AX+/, '')
+      remove_leading_padding(@pseudo_iban.slice(start_index, length))
     end
 
     def bank_code_start_index
@@ -58,29 +61,16 @@ module Ibandit
       branch_code_start_index + structure.fetch(:pseudo_iban_branch_code_length)
     end
 
-    def expected_length
-      account_number_start_index +
-        structure.fetch(:pseudo_iban_account_number_length)
-    end
-
-    def decomposable?
-      country_code_valid? && check_digits_valid? && correct_length?
-    end
-
     def country_code_valid?
       Constants::PSEUDO_IBAN_COUNTRY_CODES.include?(country_code)
     end
 
-    def check_digits_valid?
-      check_digits == Constants::PSEUDO_IBAN_CHECK_DIGITS
-    end
-
-    def correct_length?
-      @pseudo_iban.length == expected_length
-    end
-
     def structure
       Ibandit.structures[country_code]
     end
+
+    def remove_leading_padding(input)
+      input.gsub(/\AX+/, "")
+    end
   end
 end

data/lib/ibandit/sweden/bank_lookup.rb

@@ -13,7 +13,7 @@ module Ibandit
       def self.bank_info_table
         @swedish_bank_lookup ||=
           begin
-            relative_path = '../../../../data/raw/swedish_bank_lookup.yml'
+            relative_path = "../../../../data/raw/swedish_bank_lookup.yml"
             raw_info = YAML.load_file(File.expand_path(relative_path, __FILE__))
 
             raw_info.map { |bank| bank.merge(range: Range.new(*bank[:range])) }

data/lib/ibandit/sweden/local_details_converter.rb

@@ -19,14 +19,14 @@ module Ibandit
       def convert
         if bank_info.nil?
           return { swift_bank_code: nil,
-                   swift_account_number: cleaned_account_number.rjust(17, '0') }
+                   swift_account_number: cleaned_account_number.rjust(17, "0") }
         end
 
         {
           account_number: serial_number,
           branch_code: clearing_code,
           swift_bank_code: bank_info.fetch(:bank_code).to_s,
-          swift_account_number: swift_account_number
+          swift_account_number: swift_account_number,
         }
       end
 
@@ -44,7 +44,7 @@ module Ibandit
 
       def remove_bad_chars(number)
         return if number.nil?
-        number.gsub(/[-.\s]/, '')
+        number.gsub(/[-.\s]/, "")
       end
 
       def bank_info
@@ -76,15 +76,15 @@ module Ibandit
                         end
 
         return serial_number unless bank_info.fetch(:zerofill_serial_number)
-        serial_number && serial_number.rjust(serial_number_length, '0')
+        serial_number && serial_number.rjust(serial_number_length, "0")
       end
 
       def swift_account_number
         if bank_info.fetch(:include_clearing_code) &&
-           clearing_code && serial_number
-          (clearing_code + serial_number).rjust(17, '0')
+            clearing_code && serial_number
+          (clearing_code + serial_number).rjust(17, "0")
         else
-          serial_number && serial_number.rjust(17, '0')
+          serial_number && serial_number.rjust(17, "0")
         end
       end
     end

data/lib/ibandit/sweden/validator.rb

@@ -25,7 +25,7 @@ module Ibandit
         serial_number_length = bank_info.fetch(:serial_number_length)
 
         if bank_info.fetch(:zerofill_serial_number)
-          serial_number = serial_number.rjust(serial_number_length, '0')
+          serial_number = serial_number.rjust(serial_number_length, "0")
         end
 
         serial_number_length == serial_number.to_s.length
@@ -43,7 +43,7 @@ module Ibandit
                                                       account_number: nil)
         return unless bank_code_exists?(bank_code)
 
-        clearing_code = account_number.gsub(/\A0+/, '').slice(0, 4).to_i
+        clearing_code = account_number.gsub(/\A0+/, "").slice(0, 4).to_i
         Sweden::BankLookup.for_bank_code(bank_code).any? do |bank|
           !bank[:include_clearing_code] || bank[:range].include?(clearing_code)
         end
@@ -53,7 +53,7 @@ module Ibandit
                                                           account_number: nil)
         bank_code_possible = bank_code_possible_for_account_number?(
           bank_code: bank_code,
-          account_number: account_number
+          account_number: account_number,
         )
         return unless bank_code_possible
 
@@ -61,11 +61,11 @@ module Ibandit
           length = bank.fetch(:serial_number_length)
           length += bank[:clearing_code_length] if bank[:include_clearing_code]
 
-          cleaned_account_number = account_number.gsub(/\A0+/, '')
+          cleaned_account_number = account_number.gsub(/\A0+/, "")
           if bank[:zerofill_serial_number] && !bank[:include_clearing_code]
             cleaned_account_number =
               cleaned_account_number.
-              rjust(bank.fetch(:serial_number_length), '0')
+                rjust(bank.fetch(:serial_number_length), "0")
           end
 
           cleaned_account_number.length == length

data/lib/ibandit/version.rb

@@ -1,3 +1,3 @@
 module Ibandit
-  VERSION = '0.11.6'.freeze
+  VERSION = "0.11.7".freeze
 end

data/spec/ibandit/german_details_converter_spec.rb

@@ -1,7 +1,7 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Ibandit::GermanDetailsConverter do
-  shared_examples 'json based fixture' do |json_fixture_file|
+  shared_examples "json based fixture" do |json_fixture_file|
     json_fixture(json_fixture_file).each do |convertor|
       context "Rule #{convertor['convertor']}" do
         let(:klass) do
@@ -15,35 +15,36 @@ describe Ibandit::GermanDetailsConverter do
             and_call_original
         end
 
-        convertor.fetch('valid', []).each do |tuple|
+        convertor.fetch("valid", []).each do |tuple|
           context "bank code: #{tuple['bank_code']} account number " \
             "#{tuple['account_number']}" do
             let(:bank_code) do
-              tuple['bank_code']
+              tuple["bank_code"]
             end
             let(:account_number) do
-              tuple['account_number']
+              tuple["account_number"]
             end
             let(:converted_bank_code) do
-              tuple['converted_bank_code'] || bank_code
+              tuple["converted_bank_code"] || bank_code
             end
             let(:converted_account_number) do
-              tuple['converted_account_number'] || account_number
+              tuple["converted_account_number"] || account_number
             end
             it do
               is_expected.to eq(
                 bank_code: converted_bank_code,
-                account_number: converted_account_number)
+                account_number: converted_account_number,
+              )
             end
           end
         end
 
-        convertor.fetch('invalid', []).each do |tuple|
+        convertor.fetch("invalid", []).each do |tuple|
           context "bank code: #{tuple['bank_code']} account number " \
             "#{tuple['account_number']}" do
-            let(:bank_code) { tuple['bank_code'] || '00000000' }
-            let(:account_number) { tuple['account_number'] }
-            it 'raises UnsupportedAccountDetails' do
+            let(:bank_code) { tuple["bank_code"] || "00000000" }
+            let(:account_number) { tuple["account_number"] }
+            it "raises UnsupportedAccountDetails" do
               expect { subject }.
                 to raise_error(Ibandit::UnsupportedAccountDetails)
             end
@@ -53,8 +54,8 @@ describe Ibandit::GermanDetailsConverter do
     end
   end
 
-  describe 'integration tests' do
-    include_examples 'json based fixture', 'germany_integration_test_cases' do
+  describe "integration tests" do
+    include_examples "json based fixture", "germany_integration_test_cases" do
       let(:test_subject) do
         described_class.
           convert(bank_code: bank_code, account_number: account_number)
@@ -62,8 +63,8 @@ describe Ibandit::GermanDetailsConverter do
     end
   end
 
-  describe 'unit tests' do
-    include_examples 'json based fixture', 'germany_unit_test_cases' do
+  describe "unit tests" do
+    include_examples "json based fixture", "germany_unit_test_cases" do
       let(:test_subject) do
         klass.new(bank_code, account_number).converted_details
       end
@@ -74,25 +75,25 @@ describe Ibandit::GermanDetailsConverter do
     subject { described_class.new(account_number) }
 
     # Test cases taken from the IBAN Rules definitions document
-    valid_account_numbers = %w(
+    valid_account_numbers = %w[
       38150900 600103660 39101181 5600200 75269100 3700246 6723143
       5719083 571908300 8007759 800775900 350002200 900004300
-    )
+    ]
 
-    invalid_account_numbers = %w(
+    invalid_account_numbers = %w[
       370024600 672314300 3500022 9000043 123456700 94012341 94012341
       5073321010 1234517892 987614325
-    )
+    ]
 
     valid_account_numbers.each do |number|
-      context "#{number}" do
+      context number.to_s do
         let(:account_number) { number }
         it { is_expected.to be_valid }
       end
     end
 
     invalid_account_numbers.each do |number|
-      context "#{number}" do
+      context number.to_s do
         let(:account_number) { number }
         it { is_expected.to_not be_valid }
       end

data/spec/ibandit/iban_assembler_spec.rb

@@ -1,901 +1,901 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Ibandit::IBANAssembler do
-  shared_examples_for 'allows round trips' do |iban_code|
+  shared_examples_for "allows round trips" do |iban_code|
     let(:iban) { Ibandit::IBAN.new(iban_code) }
     let(:args) do
       {
         country_code:   iban.country_code,
         account_number: iban.swift_account_number,
         branch_code:    iban.swift_branch_code,
-        bank_code:      iban.swift_bank_code
+        bank_code:      iban.swift_bank_code,
       }.reject { |_key, value| value.nil? }
     end
 
-    it 'successfully reconstructs the IBAN' do
+    it "successfully reconstructs the IBAN" do
       expect(described_class.assemble(args)).to eq(iban.iban)
     end
   end
 
-  describe '.assemble' do
+  describe ".assemble" do
     subject(:assemble) { described_class.assemble(args) }
-    let(:args) { { country_code: 'ES' } }
+    let(:args) { { country_code: "ES" } }
 
-    context 'without a country_code' do
+    context "without a country_code" do
       let(:args) { { bank_code: 1 } }
       it { is_expected.to be_nil }
     end
 
-    context 'with an unsupported country_code' do
-      let(:args) { { country_code: 'FU' } }
+    context "with an unsupported country_code" do
+      let(:args) { { country_code: "FU" } }
       it { is_expected.to be_nil }
     end
 
-    context 'with AT as the country_code' do
+    context "with AT as the country_code" do
       let(:args) do
         {
-          country_code: 'AT',
-          account_number: '00234573201',
-          bank_code: '19043'
+          country_code: "AT",
+          account_number: "00234573201",
+          bank_code: "19043",
         }
       end
 
-      it { is_expected.to eq('AT611904300234573201') }
+      it { is_expected.to eq("AT611904300234573201") }
 
-      it_behaves_like 'allows round trips', 'AT61 1904 3002 3457 3201'
+      it_behaves_like "allows round trips", "AT61 1904 3002 3457 3201"
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an bank_code' do
+      context "without an bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with BE as the country_code' do
-      let(:args) { { country_code: 'BE', account_number: '510007547061' } }
+    context "with BE as the country_code" do
+      let(:args) { { country_code: "BE", account_number: "510007547061" } }
 
-      it { is_expected.to eq('BE62510007547061') }
+      it { is_expected.to eq("BE62510007547061") }
 
-      it_behaves_like 'allows round trips', 'BE62 5100 0754 7061'
+      it_behaves_like "allows round trips", "BE62 5100 0754 7061"
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with BG as the country_code' do
+    context "with BG as the country_code" do
       let(:args) do
         {
-          country_code: 'BG',
-          account_number: '1020345678',
-          bank_code: 'BNBG',
-          branch_code: '9661'
+          country_code: "BG",
+          account_number: "1020345678",
+          bank_code: "BNBG",
+          branch_code: "9661",
         }
       end
 
-      it { is_expected.to eq('BG80BNBG96611020345678') }
+      it { is_expected.to eq("BG80BNBG96611020345678") }
 
-      it_behaves_like 'allows round trips', 'BG80 BNBG 9661 1020 3456 78'
+      it_behaves_like "allows round trips", "BG80 BNBG 9661 1020 3456 78"
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with CY as the country_code' do
+    context "with CY as the country_code" do
       let(:args) do
         {
-          country_code: 'CY',
-          account_number: '0000001200527600',
-          bank_code: '002',
-          branch_code: '00128'
+          country_code: "CY",
+          account_number: "0000001200527600",
+          bank_code: "002",
+          branch_code: "00128",
         }
       end
 
-      it { is_expected.to eq('CY17002001280000001200527600') }
+      it { is_expected.to eq("CY17002001280000001200527600") }
 
-      it_behaves_like 'allows round trips', 'CY17 0020 0128 0000 0012 0052 7600'
+      it_behaves_like "allows round trips", "CY17 0020 0128 0000 0012 0052 7600"
 
-      context 'without an branch_code' do
+      context "without an branch_code" do
         before { args.delete(:branch_code) }
-        it { is_expected.to eq('CY040020000001200527600') }
+        it { is_expected.to eq("CY040020000001200527600") }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an bank_code' do
+      context "without an bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with CZ as the country_code' do
+    context "with CZ as the country_code" do
       let(:args) do
         {
-          country_code: 'CZ',
-          bank_code: '0800',
-          account_number: '0000192000145399'
+          country_code: "CZ",
+          bank_code: "0800",
+          account_number: "0000192000145399",
         }
       end
 
-      it { is_expected.to eq('CZ6508000000192000145399') }
+      it { is_expected.to eq("CZ6508000000192000145399") }
 
-      it_behaves_like 'allows round trips', 'CZ65 0800 0000 1920 0014 5399'
+      it_behaves_like "allows round trips", "CZ65 0800 0000 1920 0014 5399"
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with DE as the country_code' do
+    context "with DE as the country_code" do
       let(:args) do
-        { country_code: 'DE',
-          bank_code: '37040044',
-          account_number: '0532013000' }
+        { country_code: "DE",
+          bank_code: "37040044",
+          account_number: "0532013000" }
       end
 
-      it { is_expected.to eq('DE89370400440532013000') }
+      it { is_expected.to eq("DE89370400440532013000") }
 
-      it_behaves_like 'allows round trips', 'DE89 3704 0044 0532 0130 00'
+      it_behaves_like "allows round trips", "DE89 3704 0044 0532 0130 00"
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with DK as the country_code' do
+    context "with DK as the country_code" do
       let(:args) do
-        { country_code: 'DK',
-          bank_code: '1199',
-          account_number: '0003179680' }
+        { country_code: "DK",
+          bank_code: "1199",
+          account_number: "0003179680" }
       end
 
-      it { is_expected.to eq('DK2411990003179680') }
+      it { is_expected.to eq("DK2411990003179680") }
 
-      it_behaves_like 'allows round trips', 'DK24 1199 0003 1796 80'
+      it_behaves_like "allows round trips", "DK24 1199 0003 1796 80"
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with EE as the country_code' do
+    context "with EE as the country_code" do
       let(:args) do
         {
-          country_code: 'EE',
-          bank_code: '22',
-          account_number: '00221020145685'
+          country_code: "EE",
+          bank_code: "22",
+          account_number: "00221020145685",
         }
       end
 
-      it { is_expected.to eq('EE382200221020145685') }
+      it { is_expected.to eq("EE382200221020145685") }
 
-      it_behaves_like 'allows round trips', 'EE38 2200 2210 2014 5685'
+      it_behaves_like "allows round trips", "EE38 2200 2210 2014 5685"
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with ES as the country_code' do
+    context "with ES as the country_code" do
       let(:args) do
         {
-          country_code: 'ES',
-          bank_code: '2310',
-          branch_code: '0001',
-          account_number: '180000012345'
+          country_code: "ES",
+          bank_code: "2310",
+          branch_code: "0001",
+          account_number: "180000012345",
         }
       end
 
-      it { is_expected.to eq('ES8023100001180000012345') }
+      it { is_expected.to eq("ES8023100001180000012345") }
 
-      it_behaves_like 'allows round trips', 'ES80 2310 0001 1800 0001 2345'
+      it_behaves_like "allows round trips", "ES80 2310 0001 1800 0001 2345"
 
-      context 'without a bank_code or branch code' do
+      context "without a bank_code or branch code" do
         before { args.delete(:bank_code) }
         before { args.delete(:branch_code) }
-        before { args[:account_number] = '23100001180000012345' }
+        before { args[:account_number] = "23100001180000012345" }
 
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with FI as the country_code' do
+    context "with FI as the country_code" do
       let(:args) do
-        { country_code: 'FI', bank_code: '123456', account_number: '00000785' }
+        { country_code: "FI", bank_code: "123456", account_number: "00000785" }
       end
 
-      it { is_expected.to eq('FI2112345600000785') }
+      it { is_expected.to eq("FI2112345600000785") }
 
-      it_behaves_like 'allows round trips', 'FI21 1234 5600 0007 85'
+      it_behaves_like "allows round trips", "FI21 1234 5600 0007 85"
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with FR as the country_code' do
+    context "with FR as the country_code" do
       let(:args) do
         {
-          country_code: 'FR',
-          bank_code: '20041',
-          branch_code: '01005',
-          account_number: '0500013M02606'
+          country_code: "FR",
+          bank_code: "20041",
+          branch_code: "01005",
+          account_number: "0500013M02606",
         }
       end
 
-      it { is_expected.to eq('FR1420041010050500013M02606') }
+      it { is_expected.to eq("FR1420041010050500013M02606") }
 
-      it_behaves_like 'allows round trips', 'FR14 2004 1010 0505 0001 3M02 606'
+      it_behaves_like "allows round trips", "FR14 2004 1010 0505 0001 3M02 606"
 
-      context 'without the rib key in the account number' do
-        before { args[:account_number] = '0500013M026' }
+      context "without the rib key in the account number" do
+        before { args[:account_number] = "0500013M026" }
         specify { expect(Ibandit::IBAN.new(assemble)).to_not be_valid }
       end
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a branch_code' do
+      context "without a branch_code" do
         before { args.delete(:branch_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with GB as the country_code' do
+    context "with GB as the country_code" do
       let(:args) do
         {
-          country_code: 'GB',
-          bank_code: 'BARC',
-          branch_code: '200000',
-          account_number: '00579135'
+          country_code: "GB",
+          bank_code: "BARC",
+          branch_code: "200000",
+          account_number: "00579135",
         }
       end
 
-      it { is_expected.to eq('GB07BARC20000000579135') }
+      it { is_expected.to eq("GB07BARC20000000579135") }
 
-      it_behaves_like 'allows round trips', 'GB07 BARC 2000 0000 5791 35'
+      it_behaves_like "allows round trips", "GB07 BARC 2000 0000 5791 35"
 
-      context 'with the bank_code supplied manually' do
-        before { args.merge!(bank_code: 'BARC') }
-        it { is_expected.to eq('GB07BARC20000000579135') }
+      context "with the bank_code supplied manually" do
+        before { args.merge!(bank_code: "BARC") }
+        it { is_expected.to eq("GB07BARC20000000579135") }
       end
 
-      context 'without a branch_code' do
+      context "without a branch_code" do
         before { args.delete(:branch_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'with a non-numeric branch code' do
-        before { args[:branch_code] = 'abc123' }
+      context "with a non-numeric branch code" do
+        before { args[:branch_code] = "abc123" }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with GR as the country_code' do
+    context "with GR as the country_code" do
       let(:args) do
         {
-          country_code: 'GR',
-          bank_code: '011',
-          branch_code: '0125',
-          account_number: '0000000012300695'
+          country_code: "GR",
+          bank_code: "011",
+          branch_code: "0125",
+          account_number: "0000000012300695",
         }
       end
 
-      it { is_expected.to eq('GR1601101250000000012300695') }
+      it { is_expected.to eq("GR1601101250000000012300695") }
 
-      it_behaves_like 'allows round trips', 'GR16 0110 1250 0000 0001 2300 695'
+      it_behaves_like "allows round trips", "GR16 0110 1250 0000 0001 2300 695"
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a branch_code' do
+      context "without a branch_code" do
         before { args.delete(:branch_code) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with HR as the country_code' do
+    context "with HR as the country_code" do
       let(:args) do
-        { country_code: 'HR',
-          bank_code: '1001005',
-          account_number: '1863000160' }
+        { country_code: "HR",
+          bank_code: "1001005",
+          account_number: "1863000160" }
       end
 
-      it { is_expected.to eq('HR1210010051863000160') }
+      it { is_expected.to eq("HR1210010051863000160") }
 
-      it_behaves_like 'allows round trips', 'HR12 1001 0051 8630 0016 0'
+      it_behaves_like "allows round trips", "HR12 1001 0051 8630 0016 0"
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with HU as the country_code' do
+    context "with HU as the country_code" do
       let(:args) do
         {
-          country_code: 'HU',
-          bank_code: '117',
-          branch_code: '7301',
-          account_number: '61111101800000000'
+          country_code: "HU",
+          bank_code: "117",
+          branch_code: "7301",
+          account_number: "61111101800000000",
         }
       end
 
-      it { is_expected.to eq('HU42117730161111101800000000') }
+      it { is_expected.to eq("HU42117730161111101800000000") }
 
-      it_behaves_like 'allows round trips', 'HU42 1177 3016 1111 1018 0000 0000'
+      it_behaves_like "allows round trips", "HU42 1177 3016 1111 1018 0000 0000"
 
-      context 'without a bank_code or branch_code' do
+      context "without a bank_code or branch_code" do
         before { args.delete(:bank_code) }
         before { args.delete(:branch_code) }
-        before { args[:account_number] = '11773016-11111018-00000000' }
+        before { args[:account_number] = "11773016-11111018-00000000" }
 
         it { is_expected.to be_nil }
       end
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
-        before { args[:account_number] = '11773016-11111018-00000000' }
+        before { args[:account_number] = "11773016-11111018-00000000" }
 
         it { is_expected.to be_nil }
       end
 
-      context 'without a branch_code' do
+      context "without a branch_code" do
         before { args.delete(:branch_code) }
-        before { args[:account_number] = '11773016-11111018-00000000' }
+        before { args[:account_number] = "11773016-11111018-00000000" }
 
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with IE as the country_code' do
+    context "with IE as the country_code" do
       let(:args) do
-        { country_code: 'IE',
-          bank_code: 'AIBK',
-          branch_code: '931152',
-          account_number: '12345678' }
+        { country_code: "IE",
+          bank_code: "AIBK",
+          branch_code: "931152",
+          account_number: "12345678" }
       end
 
-      it { is_expected.to eq('IE29AIBK93115212345678') }
+      it { is_expected.to eq("IE29AIBK93115212345678") }
 
-      it_behaves_like 'allows round trips', 'IE29 AIBK 9311 5212 3456 78'
+      it_behaves_like "allows round trips", "IE29 AIBK 9311 5212 3456 78"
 
-      context 'without a branch_code' do
+      context "without a branch_code" do
         before { args.delete(:branch_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with IS as the country_code' do
+    context "with IS as the country_code" do
       let(:args) do
         {
-          country_code: 'IS',
-          account_number: '260195306702696399',
-          bank_code: '1175'
+          country_code: "IS",
+          account_number: "260195306702696399",
+          bank_code: "1175",
         }
       end
 
-      it { is_expected.to eq('IS501175260195306702696399') }
+      it { is_expected.to eq("IS501175260195306702696399") }
 
-      it_behaves_like 'allows round trips', 'IS50 1175 2601 9530 6702 6963 99'
+      it_behaves_like "allows round trips", "IS50 1175 2601 9530 6702 6963 99"
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with IT as the country_code' do
+    context "with IT as the country_code" do
       let(:args) do
         {
-          country_code: 'IT',
-          bank_code: '05428',
-          branch_code: '11101',
-          account_number: '000000123456'
+          country_code: "IT",
+          bank_code: "05428",
+          branch_code: "11101",
+          account_number: "000000123456",
         }
       end
 
-      it { is_expected.to eq('IT60X0542811101000000123456') }
+      it { is_expected.to eq("IT60X0542811101000000123456") }
 
-      it_behaves_like 'allows round trips', 'IT60 X054 2811 1010 0000 0123 456'
+      it_behaves_like "allows round trips", "IT60 X054 2811 1010 0000 0123 456"
 
-      context 'with an explicitly passed check digit' do
-        before { args[:check_digit] = 'Y' }
-        it { is_expected.to eq('IT64Y0542811101000000123456') }
+      context "with an explicitly passed check digit" do
+        before { args[:check_digit] = "Y" }
+        it { is_expected.to eq("IT64Y0542811101000000123456") }
       end
 
-      context 'with a bad character in an odd position' do
-        before { args[:account_number] = '000000123h00' }
+      context "with a bad character in an odd position" do
+        before { args[:account_number] = "000000123h00" }
         it { is_expected.to be_nil }
       end
 
-      context 'with a bad character in an even position' do
-        before { args[:account_number] = '0000001230h0' }
+      context "with a bad character in an even position" do
+        before { args[:account_number] = "0000001230h0" }
         it { is_expected.to be_nil }
       end
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a branch_code' do
+      context "without a branch_code" do
         before { args.delete(:branch_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with LT as the country_code' do
+    context "with LT as the country_code" do
       let(:args) do
         {
-          country_code: 'LT',
-          account_number: '11101001000',
-          bank_code: '10000'
+          country_code: "LT",
+          account_number: "11101001000",
+          bank_code: "10000",
         }
       end
 
-      it { is_expected.to eq('LT121000011101001000') }
+      it { is_expected.to eq("LT121000011101001000") }
 
-      it_behaves_like 'allows round trips', 'LT12 1000 0111 0100 1000'
+      it_behaves_like "allows round trips", "LT12 1000 0111 0100 1000"
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with LU as the country_code' do
+    context "with LU as the country_code" do
       let(:args) do
         {
-          country_code: 'LU',
-          account_number: '9400644750000',
-          bank_code: '001'
+          country_code: "LU",
+          account_number: "9400644750000",
+          bank_code: "001",
         }
       end
 
-      it { is_expected.to eq('LU280019400644750000') }
+      it { is_expected.to eq("LU280019400644750000") }
 
-      it_behaves_like 'allows round trips', 'LU28 0019 4006 4475 0000'
+      it_behaves_like "allows round trips", "LU28 0019 4006 4475 0000"
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with LV as the country_code' do
+    context "with LV as the country_code" do
       let(:args) do
         {
-          country_code: 'LV',
-          account_number: '1234567890123',
-          bank_code: 'BANK'
+          country_code: "LV",
+          account_number: "1234567890123",
+          bank_code: "BANK",
         }
       end
 
-      it { is_expected.to eq('LV72BANK1234567890123') }
+      it { is_expected.to eq("LV72BANK1234567890123") }
 
-      it_behaves_like 'allows round trips', 'LV72 BANK 1234 5678 9012 3'
+      it_behaves_like "allows round trips", "LV72 BANK 1234 5678 9012 3"
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with MC as the country_code' do
+    context "with MC as the country_code" do
       let(:args) do
         {
-          country_code: 'MC',
-          bank_code: '20041',
-          branch_code: '01005',
-          account_number: '0500013M02606'
+          country_code: "MC",
+          bank_code: "20041",
+          branch_code: "01005",
+          account_number: "0500013M02606",
         }
       end
 
-      it { is_expected.to eq('MC9320041010050500013M02606') }
+      it { is_expected.to eq("MC9320041010050500013M02606") }
 
-      it_behaves_like 'allows round trips', 'MC93 2004 1010 0505 0001 3M02 606'
+      it_behaves_like "allows round trips", "MC93 2004 1010 0505 0001 3M02 606"
 
-      context 'without the rib key in the account number' do
-        before { args[:account_number] = '0500013M026' }
+      context "without the rib key in the account number" do
+        before { args[:account_number] = "0500013M026" }
         specify { expect(Ibandit::IBAN.new(assemble)).to_not be_valid }
       end
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a branch_code' do
+      context "without a branch_code" do
         before { args.delete(:branch_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with MT as the country_code' do
+    context "with MT as the country_code" do
       let(:args) do
         {
-          country_code: 'MT',
-          bank_code: 'MMEB',
-          branch_code: '44093',
-          account_number: '000000009027293051'
+          country_code: "MT",
+          bank_code: "MMEB",
+          branch_code: "44093",
+          account_number: "000000009027293051",
         }
       end
 
-      it { is_expected.to eq('MT98MMEB44093000000009027293051') }
+      it { is_expected.to eq("MT98MMEB44093000000009027293051") }
 
       it_behaves_like(
-        'allows round trips',
-        'MT98 MMEB 4409 3000 0000 0902 7293 051'
+        "allows round trips",
+        "MT98 MMEB 4409 3000 0000 0902 7293 051",
       )
 
-      context 'without a branch_code' do
+      context "without a branch_code" do
         before { args.delete(:branch_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'with a non-numeric branch code' do
-        before { args[:branch_code] = 'abc123' }
+      context "with a non-numeric branch code" do
+        before { args[:branch_code] = "abc123" }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with NL as the country_code' do
+    context "with NL as the country_code" do
       let(:args) do
         {
-          country_code: 'NL',
-          account_number: '0417164300',
-          bank_code: 'ABNA'
+          country_code: "NL",
+          account_number: "0417164300",
+          bank_code: "ABNA",
         }
       end
 
-      it { is_expected.to eq('NL91ABNA0417164300') }
+      it { is_expected.to eq("NL91ABNA0417164300") }
 
-      it_behaves_like 'allows round trips', 'NL91 ABNA 0417 1643 00'
+      it_behaves_like "allows round trips", "NL91 ABNA 0417 1643 00"
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an bank_code' do
+      context "without an bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with NO as the country_code' do
+    context "with NO as the country_code" do
       let(:args) do
         {
-          country_code: 'NO',
-          bank_code: '8601',
-          account_number: '1117947'
+          country_code: "NO",
+          bank_code: "8601",
+          account_number: "1117947",
         }
       end
 
-      it { is_expected.to eq('NO9386011117947') }
+      it { is_expected.to eq("NO9386011117947") }
 
-      it_behaves_like 'allows round trips', 'NO93 8601 1117 947'
+      it_behaves_like "allows round trips", "NO93 8601 1117 947"
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
-        before { args[:account_number] = '86011117947' }
+        before { args[:account_number] = "86011117947" }
 
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with PL as the country_code' do
+    context "with PL as the country_code" do
       let(:args) do
         {
-          country_code: 'PL',
-          bank_code: '10201026',
-          account_number: '0000042270201111'
+          country_code: "PL",
+          bank_code: "10201026",
+          account_number: "0000042270201111",
         }
       end
 
-      it { is_expected.to eq('PL60102010260000042270201111') }
+      it { is_expected.to eq("PL60102010260000042270201111") }
 
-      it_behaves_like 'allows round trips', 'PL60 1020 1026 0000 0422 7020 1111'
+      it_behaves_like "allows round trips", "PL60 1020 1026 0000 0422 7020 1111"
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
-        before { args[:account_number] = '60102010260000042270201111' }
+        before { args[:account_number] = "60102010260000042270201111" }
 
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with PT as the country_code' do
+    context "with PT as the country_code" do
       let(:args) do
         {
-          country_code: 'PT',
-          bank_code: '0002',
-          branch_code: '0023',
-          account_number: '0023843000578'
+          country_code: "PT",
+          bank_code: "0002",
+          branch_code: "0023",
+          account_number: "0023843000578",
         }
       end
 
-      it { is_expected.to eq('PT50000200230023843000578') }
+      it { is_expected.to eq("PT50000200230023843000578") }
 
-      it_behaves_like 'allows round trips', 'PT50 0002 0023 0023 8430 0057 8'
+      it_behaves_like "allows round trips", "PT50 0002 0023 0023 8430 0057 8"
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a branch_code' do
+      context "without a branch_code" do
         before { args.delete(:branch_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with RO as the country_code' do
+    context "with RO as the country_code" do
       let(:args) do
         {
-          country_code: 'RO',
-          account_number: '1B31007593840000',
-          bank_code: 'AAAA'
+          country_code: "RO",
+          account_number: "1B31007593840000",
+          bank_code: "AAAA",
         }
       end
 
-      it { is_expected.to eq('RO49AAAA1B31007593840000') }
+      it { is_expected.to eq("RO49AAAA1B31007593840000") }
 
-      it_behaves_like 'allows round trips', 'RO49 AAAA 1B31 0075 9384 0000'
+      it_behaves_like "allows round trips", "RO49 AAAA 1B31 0075 9384 0000"
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with SE as the country_code' do
+    context "with SE as the country_code" do
       let(:args) do
         {
-          country_code: 'SE',
-          bank_code: '500',
-          account_number: '00000050011045825'
+          country_code: "SE",
+          bank_code: "500",
+          account_number: "00000050011045825",
         }
       end
 
-      it { is_expected.to eq('SE0450000000050011045825') }
+      it { is_expected.to eq("SE0450000000050011045825") }
 
-      it_behaves_like 'allows round trips', 'SE04 5000 0000 0500 1104 5825'
+      it_behaves_like "allows round trips", "SE04 5000 0000 0500 1104 5825"
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with SI as the country_code' do
+    context "with SI as the country_code" do
       let(:args) do
         {
-          country_code: 'SI',
-          bank_code: '19100',
-          account_number: '0000123438'
+          country_code: "SI",
+          bank_code: "19100",
+          account_number: "0000123438",
         }
       end
 
-      it { is_expected.to eq('SI56191000000123438') }
+      it { is_expected.to eq("SI56191000000123438") }
 
-      it_behaves_like 'allows round trips', 'SI56 1910 0000 0123 438'
+      it_behaves_like "allows round trips", "SI56 1910 0000 0123 438"
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with SK as the country_code' do
+    context "with SK as the country_code" do
       let(:args) do
         {
-          country_code: 'SK',
-          bank_code: '1200',
-          account_number: '0000198742637541'
+          country_code: "SK",
+          bank_code: "1200",
+          account_number: "0000198742637541",
         }
       end
 
-      it { is_expected.to eq('SK3112000000198742637541') }
+      it { is_expected.to eq("SK3112000000198742637541") }
 
-      it_behaves_like 'allows round trips', 'SK31 1200 0000 1987 4263 7541'
+      it_behaves_like "allows round trips", "SK31 1200 0000 1987 4263 7541"
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end
     end
 
-    context 'with SM as the country_code' do
+    context "with SM as the country_code" do
       let(:args) do
         {
-          country_code: 'SM',
-          bank_code: '05428',
-          branch_code: '11101',
-          account_number: '000000123456'
+          country_code: "SM",
+          bank_code: "05428",
+          branch_code: "11101",
+          account_number: "000000123456",
         }
       end
 
-      it { is_expected.to eq('SM88X0542811101000000123456') }
+      it { is_expected.to eq("SM88X0542811101000000123456") }
 
-      it_behaves_like 'allows round trips', 'SM88 X054 2811 1010 0000 0123 456'
+      it_behaves_like "allows round trips", "SM88 X054 2811 1010 0000 0123 456"
 
-      context 'without a bank_code' do
+      context "without a bank_code" do
         before { args.delete(:bank_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without a branch_code' do
+      context "without a branch_code" do
         before { args.delete(:branch_code) }
         it { is_expected.to be_nil }
       end
 
-      context 'without an account_number' do
+      context "without an account_number" do
         before { args.delete(:account_number) }
         it { is_expected.to be_nil }
       end