ibandit 0.8.1 → 0.8.2

data/lib/ibandit.rb

@@ -4,7 +4,9 @@ require 'ibandit/errors'
 require 'ibandit/constants'
 require 'ibandit/iban'
 require 'ibandit/german_details_converter'
-require 'ibandit/swedish_details_converter'
+require 'ibandit/sweden/local_details_converter'
+require 'ibandit/sweden/validator'
+require 'ibandit/sweden/bank_lookup'
 require 'ibandit/iban_splitter'
 require 'ibandit/iban_assembler'
 require 'ibandit/pseudo_iban_assembler'

data/lib/ibandit/iban.rb

@@ -276,19 +276,47 @@ module Ibandit
     def valid_swedish_details?
       return true unless country_code == 'SE'
 
-      bank_details = {
-        bank_code: swift_bank_code,
-        account_number: swift_account_number
-      }
+      if branch_code
+        valid_swedish_local_details?
+      else
+        valid_swedish_swift_details?
+      end
+    end
 
-      unless SwedishDetailsConverter.valid_bank_code?(bank_details)
+    def valid_swedish_swift_details?
+      unless Sweden::Validator.bank_code_exists?(swift_bank_code)
         bank_code_field = bank_code.nil? ? :account_number : :bank_code
         @errors[bank_code_field] = Ibandit.translate(:is_invalid)
         @errors.delete(:bank_code) if bank_code.nil?
         return false
       end
 
-      unless SwedishDetailsConverter.valid_length?(bank_details)
+      length_valid =
+        Sweden::Validator.account_number_length_valid_for_bank_code?(
+          bank_code: swift_bank_code,
+          account_number: swift_account_number
+        )
+
+      unless length_valid
+        @errors[:account_number] = Ibandit.translate(:is_invalid)
+        return false
+      end
+
+      true
+    end
+
+    def valid_swedish_local_details?
+      unless Sweden::Validator.valid_clearing_code_length?(branch_code)
+        @errors[:branch_code] = Ibandit.translate(:is_invalid)
+        return false
+      end
+
+      valid_serial_number = Sweden::Validator.valid_serial_number_length?(
+        clearing_code: branch_code,
+        serial_number: account_number
+      )
+
+      unless valid_serial_number
         @errors[:account_number] = Ibandit.translate(:is_invalid)
         return false
       end

data/lib/ibandit/local_details_cleaner.rb

@@ -441,20 +441,19 @@ module Ibandit
     end
 
     def self.clean_se_details(local_details)
-      converted_details = SwedishDetailsConverter.new(
-        branch_code: local_details[:branch_code],
-        account_number: local_details[:account_number]
-      ).convert
-
-      bank_code = local_details[:bank_code] ||
-                  converted_details[:swift_bank_code]
-
-      {
-        account_number:       converted_details[:account_number],
-        branch_code:          converted_details[:branch_code],
-        swift_bank_code:      bank_code,
-        swift_account_number: converted_details[:swift_account_number]
-      }
+      if local_details[:bank_code]
+        # If a bank_code was provided without a branch code we're (probably)
+        # dealing with SWIFT details and should just return them.
+        return {
+          swift_account_number: local_details[:account_number],
+          swift_bank_code: local_details[:bank_code]
+        }
+      else
+        Sweden::LocalDetailsConverter.new(
+          branch_code: local_details[:branch_code],
+          account_number: local_details[:account_number]
+        ).convert
+      end
     end
 
     def self.clean_si_details(local_details)

data/lib/ibandit/sweden/bank_lookup.rb

@@ -0,0 +1,24 @@
+module Ibandit
+  module Sweden
+    class BankLookup
+      def self.for_clearing_code(clearing_code)
+        code = clearing_code.to_s.slice(0, 4).to_i
+        bank_info_table.find { |bank| bank[:range].include?(code) }
+      end
+
+      def self.for_bank_code(bank_code)
+        bank_info_table.select { |bank| bank[:bank_code] == bank_code.to_i }
+      end
+
+      def self.bank_info_table
+        @swedish_bank_lookup ||=
+          begin
+            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])) }
+          end
+      end
+    end
+  end
+end

data/lib/ibandit/sweden/local_details_converter.rb

@@ -0,0 +1,92 @@
+module Ibandit
+  module Sweden
+    class LocalDetailsConverter
+      # Converts local Swedish details into SWIFT details.
+      #
+      # Local details can be provided as either:
+      # - branch_code: clearing number, account_number: serial number
+      # - branch_code: nil, account_number: #{clearing number}#{serial number}
+      #
+      # The reverse conversion (extracting local details from SWIFT details) is
+      # not possible, since the clearing number cannot be derived. You should
+      # NOT pass this class a SWIFT account number, as it will not convert it to
+      # local details successfully.
+      def initialize(branch_code: nil, account_number: nil)
+        @branch_code = branch_code
+        @account_number = account_number
+      end
+
+      def convert
+        if bank_info.nil?
+          return { swift_bank_code: nil,
+                   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
+        }
+      end
+
+      private
+
+      def cleaned_account_number
+        # Don't trim leading zeroes if the account number we are given is a
+        # serial number (i.e. if the clearing code is separate).
+        @cleaned_account_number ||= remove_bad_chars(@account_number)
+      end
+
+      def cleaned_branch_code
+        @cleaned_branch_code ||= remove_bad_chars(@branch_code)
+      end
+
+      def remove_bad_chars(number)
+        return if number.nil?
+        number.gsub(/[-.\s]/, '')
+      end
+
+      def bank_info
+        @bank_info ||= Sweden::BankLookup.for_clearing_code(bank_info_key)
+      end
+
+      def bank_info_key
+        (cleaned_branch_code || cleaned_account_number).slice(0, 4)
+      end
+
+      def clearing_code_length
+        bank_info.fetch(:clearing_code_length)
+      end
+
+      def serial_number_length
+        bank_info.fetch(:serial_number_length)
+      end
+
+      def clearing_code
+        cleaned_branch_code ||
+          cleaned_account_number.slice(0, clearing_code_length)
+      end
+
+      def serial_number
+        serial_number = if @branch_code.nil?
+                          cleaned_account_number[clearing_code_length..-1]
+                        else
+                          cleaned_account_number
+                        end
+
+        return serial_number unless bank_info.fetch(:zerofill_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).rjust(17, '0')
+        else
+          serial_number.rjust(17, '0')
+        end
+      end
+    end
+  end
+end

data/lib/ibandit/sweden/validator.rb

@@ -0,0 +1,75 @@
+module Ibandit
+  module Sweden
+    class Validator
+      ###########################
+      # Local detail validators #
+      ###########################
+
+      def self.bank_code_exists_for_clearing_code?(clearing_code)
+        !Sweden::BankLookup.for_clearing_code(clearing_code).nil?
+      end
+
+      def self.valid_clearing_code_length?(clearing_code)
+        return unless bank_code_exists_for_clearing_code?(clearing_code)
+
+        bank_info = Sweden::BankLookup.for_clearing_code(clearing_code)
+        bank_info.fetch(:clearing_code_length) == clearing_code.to_s.length
+      end
+
+      def self.valid_serial_number_length?(clearing_code: nil,
+                                           serial_number: nil)
+        return unless bank_code_exists_for_clearing_code?(clearing_code)
+
+        bank_info = Sweden::BankLookup.for_clearing_code(clearing_code)
+        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')
+        end
+
+        serial_number_length == serial_number.to_s.length
+      end
+
+      ###########################
+      # SWIFT detail validators #
+      ###########################
+
+      def self.bank_code_exists?(bank_code)
+        Sweden::BankLookup.for_bank_code(bank_code).any?
+      end
+
+      def self.bank_code_possible_for_account_number?(bank_code: nil,
+                                                      account_number: nil)
+        return unless bank_code_exists?(bank_code)
+
+        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
+      end
+
+      def self.account_number_length_valid_for_bank_code?(bank_code: nil,
+                                                          account_number: nil)
+        bank_code_possible = bank_code_possible_for_account_number?(
+          bank_code: bank_code,
+          account_number: account_number
+        )
+        return unless bank_code_possible
+
+        Sweden::BankLookup.for_bank_code(bank_code).any? do |bank|
+          length = bank.fetch(:serial_number_length)
+          length += bank[:clearing_code_length] if bank[:include_clearing_code]
+
+          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')
+          end
+
+          cleaned_account_number.length == length
+        end
+      end
+    end
+  end
+end

data/lib/ibandit/version.rb

@@ -1,3 +1,3 @@
 module Ibandit
-  VERSION = '0.8.1'.freeze
+  VERSION = '0.8.2'.freeze
 end

data/spec/ibandit/iban_spec.rb

@@ -1353,60 +1353,113 @@ describe Ibandit::IBAN do
     describe 'valid_swedish_details?' do
       subject { iban.valid_swedish_details? }
 
-      context 'with an account number that is too long' do
-        let(:arg) do
-          {
-            country_code: 'SE',
-            bank_code: '500',
-            account_number: '00000543910240391'
-          }
-        end
+      context 'with SWIFT details' do
+        context 'with an account number that is too long' do
+          let(:arg) do
+            {
+              country_code: 'SE',
+              bank_code: '500',
+              account_number: '00000543910240391'
+            }
+          end
 
-        it { is_expected.to eq(false) }
+          it { is_expected.to eq(false) }
 
-        context 'locale en', locale: :en do
-          specify do
-            iban.valid_swedish_details?
-            expect(iban.errors).to eq(account_number: 'is invalid')
+          context 'locale en', locale: :en do
+            specify do
+              iban.valid_swedish_details?
+              expect(iban.errors).to eq(account_number: 'is invalid')
+            end
           end
         end
-      end
 
-      context "with an account number that doesn't have a bank code" do
-        let(:arg) do
-          {
-            country_code: 'SE',
-            bank_code: nil,
-            account_number: '00000000000010011'
-          }
+        context "with an account number that doesn't have a bank code" do
+          let(:arg) do
+            {
+              country_code: 'SE',
+              bank_code: nil,
+              account_number: '00000000000010011'
+            }
+          end
+
+          it { is_expected.to eq(false) }
+
+          context 'locale en', locale: :en do
+            specify do
+              iban.valid?
+              expect(iban.errors).to include(account_number: 'is invalid')
+              expect(iban.errors).to_not include(:bank_code)
+            end
+          end
         end
 
-        it { is_expected.to eq(false) }
+        context 'with a bank code that does not match' do
+          let(:arg) do
+            {
+              country_code: 'SE',
+              bank_code: '902',
+              account_number: '00000054391024039'
+            }
+          end
 
-        context 'locale en', locale: :en do
-          specify do
-            iban.valid?
-            expect(iban.errors).to include(account_number: 'is invalid')
-            expect(iban.errors).to_not include(:bank_code)
+          it { is_expected.to eq(false) }
+
+          context 'locale en', locale: :en do
+            specify do
+              iban.valid_swedish_details?
+              expect(iban.errors).to eq(account_number: 'is invalid')
+            end
           end
         end
       end
 
-      context 'with a bad bank code' do
-        let(:arg) do
-          {
-            country_code: 'SE',
-            bank_code: '902',
-            account_number: '00000054391024039'
-          }
+      context 'with local details' do
+        context 'with good details' do
+          let(:arg) do
+            {
+              country_code: 'SE',
+              account_number: '5439-0240391'
+            }
+          end
+
+          it { is_expected.to eq(true) }
         end
 
-        it { is_expected.to eq(false) }
+        context 'with a clearing code that is too long' do
+          let(:arg) do
+            {
+              country_code: 'SE',
+              branch_code: '54391',
+              account_number: '0240391'
+            }
+          end
 
-        context 'locale en', locale: :en do
-          specify do
-            iban.valid_swedish_details?
-            expect(iban.errors).to eq(bank_code: 'is invalid')
+          it { is_expected.to eq(false) }
+
+          context 'locale en', locale: :en do
+            specify do
+              iban.valid_swedish_details?
+              expect(iban.errors).to eq(branch_code: 'is invalid')
+            end
+          end
+        end
+
+        context 'with a serial number that is too long' do
+          let(:arg) do
+            {
+              country_code: 'SE',
+              branch_code: '5439',
+              account_number: '024039111'
+            }
+          end
+
+          it { is_expected.to eq(false) }
+
+          context 'locale en', locale: :en do
+            specify do
+              iban.valid_swedish_details?
+              expect(iban.errors).to eq(account_number: 'is invalid')
+            end
           end
         end
       end