iban_calculator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 19c90f0379c87c7251c554191b6ee1ca82f7e7c5
+  data.tar.gz: 1906317a98ebfa25ec45d4bdff1a0c3d01448ab0
+SHA512:
+  metadata.gz: 2210281de1e0c117cf9881d0f0adea74b8f37271a48032dc5a735a9068fdc3e49e69a990ec8bf650f893eb25c865373582a4c5d5746050f4d99f261ee4b0372a
+  data.tar.gz: 4d69c1cef82b442417c2a2096a408eb394f5d1ad8673cdef9c047a245625b8a2e2271e8a2d36200ea583460a15809d0cc8e6db7ef753c4f09b7692f9b2028035

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in iban_calculator.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Maximilian Schulz
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,44 @@
+# IbanCalculator
+
+A wrapper for ibanrechner.de API. It allows converting bank account data from legacy syntax to new SEPA IBAN/BIC.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'iban_calculator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install iban_calculator
+
+## Usage
+
+In order to use iban calculator, you need to create an account at [iban-bic.com](http://www.iban-bic.com/).
+
+In case you are using rails, configure your app like this:
+
+    # config/initializers/iban_calculator.rb
+    IbanCalculator.user = 'your_username',
+    IbanCalculator.password = 'your_password'
+    IbanCalculator.logger = Rails.logger
+
+Whenever you need to convert European legacy account data to new SEPA IBAN format:
+
+    # app/models/your_model.rb
+    IbanCalculator.calculate_iban country: 'DE', account_number: '123', bank_code: '456'
+
+Example data can be found at: http://www.iban-bic.com/sample_accounts.html
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/iban_calculator/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/iban_calculator.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'iban_calculator/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "iban_calculator"
+  spec.version       = IbanCalculator::VERSION
+  spec.authors       = ["Maximilian Schulz"]
+  spec.email         = ["m.schulz@kulturfluss.de"]
+  spec.summary       = %q{Calculate IBAN and BIC for countries of Single European Payments Area (SEPA).}
+  spec.description   = %q{At the moment the gem is just a wrapper for the ibanrechner.de API.}
+  spec.homepage      = "https://github.com/railslove/iban_calculator"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", "~> 4"
+  spec.add_dependency "savon", "~> 2"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 0"
+  spec.add_development_dependency "rspec", "~> 3"
+end

data/lib/iban_calculator/iban_bic.rb

@@ -0,0 +1,104 @@
+require 'savon'
+
+# Return codes and their meaning:
+#
+# 0 = all checks were successful
+#
+# 1 = sub account number has been added automatically
+# 2 = account number did not include a checksum
+# 4 = checksum has not been checked
+# 8 = bank code has not been checked
+#
+# 32 = A sub account number might be required, but could not be determined autoamtically
+#
+# 128 = checksum for account_number is invalid
+# 256 = bank_code could not be found is database
+# 512 = account_number has an invalid length
+# 1024 = bank_code has an invalid length
+# 4096 = data is missing (i.e. country code)
+# 8192= country is not yet supported
+#
+module IbanCalculator
+  class IbanBic
+    ITALIAN_IBAN_LENGTH = 27
+    PREFIX_AND_CHECKSUM_LENGTH = 4
+
+    VALID_RESPONSE_CODE = 0..31
+    PROBABLY_VALID_RESPONSE_CODE = 32..127
+    SERVICE_ERROR_RESPONSE_CODE = 65536
+
+    attr_accessor :user, :password, :url, :logger
+
+    def initialize(user, password, url, logger)
+      self.user = user
+      self.password = password
+      self.url = url
+      self.logger = logger
+    end
+
+    # You should provide country, bank_code, and account_number. (cin, abi, and cab for Italian accounts)
+    def calculate_iban(attributes)
+      payload = iban_payload(attributes)
+      response = client.call(:calculate_iban, message: payload).body[:calculate_iban_response][:return]
+      log "iban lookup attributes=#{attributes} payload=#{payload} response=#{response}"
+
+      case return_code = response[:return_code].to_i
+      when VALID_RESPONSE_CODE
+        formatted_result(response)
+      when PROBABLY_VALID_RESPONSE_CODE
+        log "iban check needs manual check return_code=#{return_code}"
+        formatted_result(response)
+      when SERVICE_ERROR_RESPONSE_CODE
+        log "iban check failed return_code=#{return_code}"
+        fail ServiceError, 'Service could not handle the request'
+      else
+        log "iban check invalid return_code=#{return_code}"
+        fail InvalidData.new('Invalid input data', return_code)
+      end
+    end
+
+    def italian_account_number(attributes = {})
+      return {} unless attributes['country'].to_s.upcase == 'IT'
+      left_length = ITALIAN_IBAN_LENGTH - PREFIX_AND_CHECKSUM_LENGTH - attributes['account'].length
+      left_side = [attributes['cin'], attributes['abi'], attributes['cab']].join.ljust(left_length, '0')
+      { 'account' => left_side + attributes['account'] }
+    end
+
+    def default_payload
+      { country: '', bank_code: '', account: '', user: user, password: password, bic: '', legacy_mode: 0 }
+    end
+
+    def formatted_result(data)
+      { iban: data[:iban],
+        bics: process_bic_candidates(data[:bic_candidates]),
+        country: data[:country],
+        bank_code: data[:bank_code],
+        bank: data[:bank],
+        account_number: data[:account_number],
+        updated_at: Date.parse(data[:data_age]) }
+    end
+
+    def process_bic_candidates(candidates)
+      [candidates[:item].select { |key, value| [:bic, :zip, :city].include?(key) && value.kind_of?(String) }]
+    rescue
+      log "Could not handle candidates=#{candidates}"
+      fail ArgumentError, "Could not handle BIC response"
+    end
+
+    def iban_payload(attributes)
+      attributes = attributes.with_indifferent_access
+      attributes['account'] = attributes.delete('account_number')
+      normalized_attributes = attributes.merge(italian_account_number(attributes))
+      payload = normalized_attributes.select { |k,_| %w(country account bank_code).include?(k) }
+      default_payload.merge(payload.symbolize_keys)
+    end
+
+    def log(message)
+      logger.info message
+    end
+
+    def client
+      @client ||= Savon.client(wsdl: url)
+    end
+  end
+end

data/lib/iban_calculator/invalid_data.rb

@@ -0,0 +1,35 @@
+module IbanCalculator
+  class InvalidData < StandardError
+    CODES = {
+      128  => [:account_number, [:checksum_failed]],
+      256  => [:bank_code,      [:not_found]],
+      512  => [:account_number, [:invalid_length]],
+      1024 => [:bank_code,      [:invalid_length]],
+      4096 => [:base,           [:data_missing]],
+      8192 => [:country,        [:not_supported]],
+    }
+
+    attr_accessor :errors
+
+    def initialize(msg, error_code)
+      self.errors = resolve_error_code(error_code)
+      super(msg)
+    end
+
+    def resolve_error_code(error_code)
+      known_error_codes(error_code).reduce(Hash.new([])) do |hsh, item|
+        error = CODES[item]
+        hsh[error[0]] += error[1]
+        hsh
+      end
+    end
+
+    def known_error_codes(error_code)
+      error_codes(error_code) & CODES.keys
+    end
+
+    def error_codes(n)
+      (0..13).map { |i| n & 2**i } - [0]
+    end
+  end
+end

data/lib/iban_calculator/version.rb

@@ -0,0 +1,3 @@
+module IbanCalculator
+  VERSION = "0.0.1"
+end

data/lib/iban_calculator.rb

@@ -0,0 +1,22 @@
+require 'iban_calculator/version'
+require 'active_support/configurable'
+require 'active_support/core_ext/hash'
+require 'logger'
+require 'iban_calculator/iban_bic'
+require 'iban_calculator/invalid_data'
+
+module IbanCalculator
+  include ActiveSupport::Configurable
+
+  config_accessor(:url) { 'https://ssl.ibanrechner.de/soap/?wsdl' }
+  config_accessor(:user) { '' }
+  config_accessor(:password) { '' }
+  config_accessor(:logger) { Logger.new(STDOUT) }
+
+  ServiceError = Class.new(StandardError)
+
+  def self.calculate_iban(attributes = {})
+    client = IbanBic.new(config.user, config.password, config.url, config.logger)
+    client.calculate_iban(attributes)
+  end
+end

data/spec/iban_bic_spec.rb

@@ -0,0 +1,244 @@
+describe IbanCalculator::IbanBic do
+  subject { described_class.new('user', 'pass', 'url', Logger.new(STDOUT) ) }
+
+  before { allow(subject.logger).to receive(:info) }
+
+  describe '#italian_account_number' do
+    it 'returns an empty hash if not all fields are provided' do
+      expect(subject.italian_account_number).to eq({})
+    end
+
+    it 'returns hash with correct account number if valid data is provided' do
+      expect(subject.italian_account_number(
+        'country' => 'IT',
+        'cab' => '03280',
+        'abi' => '03002',
+        'cin' => 'D',
+        'account' => '400162854',
+      )).to eq('account' => 'D0300203280000400162854')
+    end
+  end
+
+  describe '#default_payload' do
+    it 'includes account data' do
+      expect(subject.default_payload).to match hash_including(user: 'user', password: 'pass')
+    end
+  end
+
+  describe '#process_bic_candidates' do
+    context 'known single BIC payload' do
+      let(:payload) { valid_payload[:bic_candidates] }
+
+      it 'returns an array' do
+        expect(subject.process_bic_candidates(payload)).to be_kind_of(Array)
+      end
+
+      it 'returns its bank\'s bic' do
+        expect(subject.process_bic_candidates(payload).first).to match hash_including(bic: 'BYLADEM1001')
+      end
+
+      it 'returns its bank\'s zip' do
+        expect(subject.process_bic_candidates(payload).first).to match hash_including(zip: '10117')
+      end
+
+      it 'returns its bank\'s city' do
+        expect(subject.process_bic_candidates(payload).first).to match hash_including(city: 'Berlin')
+      end
+
+      context 'empty fields' do
+        let(:payload) { {:item=>{
+                            :bic=>"UNCRITMM",
+                            :zip=>{:"@xsi:type"=>"xsd:string"},
+                            :city=>{:"@xsi:type"=>"xsd:string"},
+                            :wwwcount=>"0",
+                            :sampleurl=>{:"@xsi:type"=>"xsd:string"},
+                            :"@xsi:type"=>"tns:BICStruct"
+                          },
+                          :"@xsi:type"=>"SOAP-ENC:Array",
+                          :"@soap_enc:array_type"=>"tns:BICStruct[1]"} }
+
+        it 'ignores empty zip' do
+          expect(subject.process_bic_candidates(payload).first.keys).to_not include(:zip)
+        end
+
+        it 'ignores empty city' do
+          expect(subject.process_bic_candidates(payload).first.keys).to_not include(:city)
+        end
+      end
+    end
+
+    context 'unknown payload' do
+      let(:payload) { { :items => [], :"@xsi:type" => 'SOAP-ENC:Array' } }
+
+      it 'logs the payload' do
+        subject.process_bic_candidates(payload) rescue
+        expect(subject.logger).to have_received(:info)
+      end
+
+      it 'raises an exception' do
+        expect { subject.process_bic_candidates(payload) }.to raise_exception(ArgumentError)
+      end
+    end
+  end
+
+  describe '#formatted_result' do
+    before { allow(subject).to receive(:process_bic_candidates).and_return(['data']) }
+
+    it 'returns a valid ruby date for last update date' do
+      expect(subject.formatted_result(valid_payload)[:updated_at]).to be_kind_of(Date)
+    end
+
+    it 'transforms the list of bic candidates' do
+      subject.formatted_result(valid_payload)
+      expect(subject).to have_received(:process_bic_candidates)
+    end
+
+    it 'includes iban' do
+      expect(subject.formatted_result(valid_payload).keys).to include(:iban)
+    end
+  end
+
+  describe '#iban_payload' do
+    context 'italian data is provided' do
+      before { allow(subject).to receive(:italian_account_number).and_return({ 'account' => 'italy-123' }) }
+
+      it 'normalizes italian account data' do
+        subject.iban_payload({})
+        expect(subject).to have_received(:italian_account_number)
+      end
+
+      it 'merges italian data' do
+        expect(subject.iban_payload({ 'country' => 'IT' })).to match(hash_including(account: 'italy-123'))
+      end
+
+      it 'strips italian data' do
+        expect(subject.iban_payload({ 'cin' => '123' }).keys).to_not include('cin')
+      end
+    end
+
+    it 'adds default payload' do
+      expect(subject.iban_payload({}).keys).to include(:user, :password, :legacy_mode)
+    end
+
+    it 'overrides default data' do
+      expect(subject.iban_payload({ bank_code: '123' })).to match hash_including(bank_code: '123')
+    end
+
+    it 'replaces account_number with account' do
+      expect(subject.iban_payload({ account_number: '123' })).to match hash_including(account: '123')
+    end
+  end
+
+  describe '#calculate_iban' do
+    before { allow(subject.client).to receive(:call).and_return(response) }
+
+    context 'valid response' do
+      let(:response) { double(body: { calculate_iban_response: { return: valid_payload } }) }
+
+      it 'returns a formatted response' do
+        allow(subject).to receive(:formatted_result)
+        subject.calculate_iban({})
+        expect(subject).to have_received(:formatted_result)
+      end
+
+      it 'calls the client with the generated payload' do
+        subject.calculate_iban({})
+        expect(subject.client).to have_received(:call).with(:calculate_iban, message: anything)
+      end
+    end
+
+    context 'probably valid response' do
+      let(:response) { double(body: { calculate_iban_response: { return: valid_payload.merge(return_code: '32') } }) }
+
+      it 'logs a message' do
+        subject.calculate_iban({}) rescue IbanCalculator::InvalidData
+        expect(subject.logger).to have_received(:info).with(/needs manual check/)
+      end
+
+      it 'returns a formatted response' do
+        allow(subject).to receive(:formatted_result)
+        subject.calculate_iban({})
+        expect(subject).to have_received(:formatted_result)
+      end
+    end
+
+    context 'invalid response' do
+      let(:response) { double(body: { calculate_iban_response: { return: valid_payload.merge(return_code: '128') } }) }
+
+      it 'logs a message' do
+        subject.calculate_iban({}) rescue IbanCalculator::InvalidData
+        expect(subject.logger).to have_received(:info).with(/iban check invalid/)
+      end
+
+      it 'fails with invalid data exception' do
+        expect{ subject.calculate_iban({}) }.to raise_exception(IbanCalculator::InvalidData)
+      end
+    end
+
+    context 'server error response' do
+      let(:response) { double(body: { calculate_iban_response: { return: valid_payload.merge(return_code: '65536') } }) }
+
+      it 'logs a message' do
+        subject.calculate_iban({}) rescue IbanCalculator::ServiceError
+        expect(subject.logger).to have_received(:info).with(/iban check failed/)
+      end
+
+      it 'fails with service error exception' do
+        expect{ subject.calculate_iban({}) }.to raise_exception(IbanCalculator::ServiceError)
+      end
+    end
+  end
+
+  def valid_payload
+    {
+      :iban=>"DE59120300001111236988",
+      :result=>"passed",
+      :return_code=>"0",
+      :ibanrueck_return_code=>{
+        :"@xsi:type"=>"xsd:string"
+      },
+      :checks=>{
+        :item=>["length", "bank_code", "account_number"],
+        :"@xsi:type"=>"SOAP-ENC:Array",
+        :"@soap_enc:array_type"=>"xsd:string[3]"
+      },
+      :bic_candidates=>{
+        :item=>{
+          :bic=>"BYLADEM1001",
+          :zip=>"10117",
+          :city=>"Berlin",
+          :wwwcount=>"0",
+          :sampleurl=>{:"@xsi:type"=>"xsd:string"},
+          :"@xsi:type"=>"tns:BICStruct"
+        },
+        :"@xsi:type"=>"SOAP-ENC:Array",
+        :"@soap_enc:array_type"=>"tns:BICStruct[1]"
+      },
+      :country=>"DE",
+      :bank_code=>"12030000",
+      :alternative_bank_code=>{:"@xsi:type"=>"xsd:string"},
+      :bank=>"Deutsche Kreditbank Berlin",
+      :bank_address=>{:"@xsi:type"=>"xsd:string"},
+      :bank_url=>{:"@xsi:type"=>"xsd:string"},
+      :branch=>{:"@xsi:type"=>"xsd:string"},
+      :branch_code=>{:"@xsi:type"=>"xsd:string"},
+      :in_scl_directory=>"yes",
+      :sct=>"yes",
+      :sdd=>"yes",
+      :b2b=>"yes",
+      :account_number=>"1011856976",
+      :alternative_account_number=>{:"@xsi:type"=>"xsd:string"},
+      :account_validation_method=>"00",
+      :account_validation=>"Methode 00, Konto 1111236988, BLZ 12030000, Prüfziffer 6 steht an Position 10, erwartete Prüfziffer: 6. Überblick über die Berechnung: Nimm die Ziffern auf den Positionen 1 bis 9 - hier: 1111236988 -, multipliziere sie von rechts nach links mit den Gewichten 2,1,2,1,2,1,2,1,2, addiere die Quersummen der Produkte, bilde den Rest der Division durch 10, ziehe das Ergebnis von 10 ab,  und das Ergebnis modulo 10 ist die erwartete Prüfziffer.",
+      :length_check=>"passed",
+      :account_check=>"passed",
+      :bank_code_check=>"passed",
+      :bic_plausibility_check=>{:"@xsi:type"=>"xsd:string"},
+      :data_age=>"20140525",
+      :iba_nformat=>"DEkk BBBB BBBB CCCC CCCC CC",
+      :formatcomment=>"B = sort code (BLZ), C = account No.",
+      :balance=>"4",
+      :"@xsi:type"=>"tns:IBANCalcResStruct"
+    }
+  end
+end

data/spec/iban_calculator_spec.rb

@@ -0,0 +1,51 @@
+describe IbanCalculator do
+  describe '.url' do
+    it 'defaults to ibanrechner.de' do
+      expect(IbanCalculator.url).to eq('https://ssl.ibanrechner.de/soap/?wsdl')
+    end
+
+    it 'allows overriding' do
+      IbanCalculator.url = 'http://mytest.com'
+      expect(IbanCalculator.url).to eq('http://mytest.com')
+      IbanCalculator.url = 'https://ssl.ibanrechner.de/soap/?wsdl'
+    end
+  end
+
+  describe '.user' do
+    it 'defaults to ""' do
+      expect(IbanCalculator.user).to eq('')
+    end
+
+    it 'allows specifying it' do
+      IbanCalculator.user = 'test'
+      expect(IbanCalculator.user).to eq('test')
+      IbanCalculator.user = ''
+    end
+  end
+
+  describe '.password' do
+    it 'defaults to ""' do
+      expect(IbanCalculator.password).to eq('')
+    end
+
+    it 'allows specifying it' do
+      IbanCalculator.password = 'test'
+      expect(IbanCalculator.password).to eq('test')
+      IbanCalculator.password = ''
+    end
+  end
+
+  describe '.logger' do
+    it 'defaults to a logger instance' do
+      expect(IbanCalculator.logger).to be_instance_of(Logger)
+    end
+
+    it 'allows specifying it' do
+      old_logger = IbanCalculator.logger
+      logger = Logger.new(STDERR)
+      IbanCalculator.logger = logger
+      expect(IbanCalculator.logger).to eql(logger)
+      IbanCalculator.logger = old_logger
+    end
+  end
+end

data/spec/invalid_data_spec.rb

@@ -0,0 +1,55 @@
+describe IbanCalculator::InvalidData do
+  subject { described_class.new('', 128) }
+
+  describe '#resolve_error_code' do
+    it 'handles single errors' do
+      expect(subject.resolve_error_code(128)).to eq(account_number: [:checksum_failed])
+    end
+
+    it 'can combine multiple errors' do
+      expect(subject.resolve_error_code(128 + 256)).to eq(account_number: [:checksum_failed], bank_code: [:not_found])
+    end
+
+    it 'can combine multiple errors of same attribute' do
+      expect(subject.resolve_error_code(128 + 512)).to eq(account_number: [:checksum_failed, :invalid_length])
+    end
+
+    it 'can combine multiple errors of same attribute' do
+      expect(subject.resolve_error_code(512)).to eq(account_number: [:invalid_length])
+    end
+  end
+
+  describe '#error_codes' do
+    it 'ignores zeros' do
+      expect(subject.error_codes(0)).to eq([])
+    end
+
+    it 'detects unique values' do
+      expect(subject.error_codes(1)).to eq([1])
+    end
+
+    it 'detects compounded values' do
+      expect(subject.error_codes(3)).to eq([1, 2])
+    end
+
+    it 'detects 512' do
+      expect(subject.error_codes(512)).to eq([512])
+    end
+
+    it 'detects compounded values up to 8192' do
+      expect(subject.error_codes(8193)).to eq([1, 8192])
+    end
+  end
+
+  describe '#known_error_codes' do
+    it 'detects 512' do
+      expect(subject.known_error_codes(512)).to eq([512])
+    end
+  end
+
+  describe '#error' do
+    it 'sets error on object' do
+      expect(described_class.new('test', 512).errors).to eq(account_number: [:invalid_length])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'iban_calculator'
+
+RSpec.configure do |config|
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.profile_examples = 3
+
+  config.order = :random
+
+  Kernel.srand config.seed
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+    mocks.verify_partial_doubles = true
+  end
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: iban_calculator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Maximilian Schulz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: savon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: At the moment the gem is just a wrapper for the ibanrechner.de API.
+email:
+- m.schulz@kulturfluss.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- iban_calculator.gemspec
+- lib/iban_calculator.rb
+- lib/iban_calculator/iban_bic.rb
+- lib/iban_calculator/invalid_data.rb
+- lib/iban_calculator/version.rb
+- spec/iban_bic_spec.rb
+- spec/iban_calculator_spec.rb
+- spec/invalid_data_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/railslove/iban_calculator
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Calculate IBAN and BIC for countries of Single European Payments Area (SEPA).
+test_files:
+- spec/iban_bic_spec.rb
+- spec/iban_calculator_spec.rb
+- spec/invalid_data_spec.rb
+- spec/spec_helper.rb
+has_rdoc: