banktools-se 2.5.0 → 2.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3d35e823a3680d5f4f656ab0849199916b481110
-  data.tar.gz: 558d9b9047b302a807e28171fc515274c2461263
+  metadata.gz: 7718cc4bfa1982f2d41ca5a8e1a8ca872f647ba9
+  data.tar.gz: 61a4d355be53ebf5e0537b5b0a60b07af4869386
 SHA512:
-  metadata.gz: af1599d7f2669a938268f304b4d104202b19aba78db344ef6affcfabca4c30c25895efe47c764111453b8a10b1cdc99778c5be87e57c63009dd689fb74dff44f
-  data.tar.gz: e5eda874826d7e49d22cbf46e1102d45eb0cc451021e4d6f3e401d6027c3c7e99e5f394226d83ba305ad6243cf03f3c8b25fb81b4c139f4264bff812339fd145
+  metadata.gz: 309b92f8160559eee8e70e22c3d24c961210272d6d6122770ab6ff36fae38c3855fc95a0c495aaeb304ef3e9cdd03fb3feb9aedd2b8645ed658cc0551b6351b6
+  data.tar.gz: b4efc5ea6430a8a6dddabee2113f30f935587b948f9088cc21ac368693536e10efde30e7d9c395697948d186084582ba9dc0a4305a68be9ff1d449d6521de041

data/README.markdown

@@ -46,9 +46,9 @@ Inspired by [iulianu/iban-tools](https://github.com/iulianu/iban-tools). Please
     # This feature is intended to try to find all OCR numbers in a noisy bank statement string.
     # By design it may find too many numbers (e.g. valid substrings of other numbers), so you should check results against actual outstanding invoices.
     # By default, it excludes OCRs shorter than 4 digits and longer than 19 digits, but this limit can be specified per below.
-    BankTools::SE::OCR.find_all_in_string("OCR1230 and ref4564 and 7890")  # => [ "1230", "4564" ]
+    BankTools::SE::OCR.find_all_in_string("OCR1230 and ref4564 and 7890")  # => [ "1230", "4564", … ]
     BankTools::SE::OCR.find_all_in_string("1230 and 123067", length_digit: true, pad: "0")  # => [ "123067" ]
-    BankTools::SE::OCR.find_all_in_string("00 and 18 and 1230", min_length: 2, max_length: 3)  # => [ "00", "18" ]
+    BankTools::SE::OCR.find_all_in_string("00 and 18 and 1230", min_length: 2, max_length: 3)  # => [ "00", "018", "18" ]
 
     # Plusgiro
 
@@ -112,13 +112,14 @@ Or install it yourself as:
 
 Possible improvements to make:
 
-  * Luhn validation based on [BGC docs](http://web.archive.org/web/20130613010943/http://www.bgc.se/upload/Gemensamt/Trycksaker/Manualer/BG910.pdf).
+  * Luhn validation based on [these docs](https://www.bankgirot.se/globalassets/dokument/anvandarmanualer/bankernaskontonummeruppbyggnad_anvandarmanual_sv.pdf).
 
 
 ## Also see
 
 * [BankTools::DE (German)](https://github.com/barsoom/banktools-de)
 * [iban-tools](https://github.com/iulianu/iban-tools)
+* [Bankgirocentral documentation](https://www.bankgirot.se/kundservice/handbocker/)
 
 
 ## Credits and license

data/lib/banktools-se/account.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-# http://web.archive.org/web/20130613010943/http://www.bgc.se/upload/Gemensamt/Trycksaker/Manualer/BG910.pdf
+# https://www.bankgirot.se/globalassets/dokument/anvandarmanualer/bankernaskontonummeruppbyggnad_anvandarmanual_sv.pdf
 
 require "banktools-se/account/clearing_number"
 

data/lib/banktools-se/ocr.rb

@@ -1,4 +1,4 @@
-# http://web.archive.org/web/20111216065227/http://www.bgc.se/upload/Gemensamt/Trycksaker/Manualer/BG6070.pdf section 5.2
+# https://www.bankgirot.se/globalassets/dokument/anvandarmanualer/bankgiroinbetalningar_anvandarmanual_sv_31okt2016.pdf section 5.2
 
 module BankTools
   module SE
@@ -66,14 +66,28 @@ module BankTools
 
       # max_length is 19 because that's the longest allowed integer by default in a Postgres integer column with Ruby on Rails. So attempting some queries with longer OCRs may cause exceptions.
       def self.find_all_in_string(string, length_digit: false, pad: "", min_length: 4, max_length: 19)
-        expanded_string = [ string, *[ "\n", ";", "." ].map { |x| string.gsub(x, "") } ].join(" ")
+        # First, treat the input as one long string of digits.
+        # E.g. "1234 and 5678" becomes "12345678".
+        digit_string = string.gsub(/\D/, "")
+        digit_string_length = digit_string.length
 
-        numbers = expanded_string.scan(/\d+/)
+        candidates = []
 
-        expanded_numbers = with_numbers_found_by_removing_prefix_and_postfix(numbers).
-          reject { |n| n.length < min_length || n.length > max_length }
+        # Then find all substrings of min_length, and of all other lengths, up to max_length.
+        # So e.g. find all four-digit substrings ("1234", "2345", …), all five-digit substrings and so on.
 
-        expanded_numbers.select { |candidate|
+        0.upto(digit_string.length - min_length) do |start_pos|
+          min_end_pos = [ start_pos + min_length, digit_string_length ].min - 1
+          max_end_pos = [ start_pos + max_length, digit_string_length ].min - 1
+
+          min_end_pos.upto(max_end_pos) do |end_pos|
+            candidates << digit_string.slice(start_pos..end_pos)
+          end
+        end
+
+        # Finally, limit these substrings to ones that are actually valid OCRs.
+
+        candidates.select { |candidate|
           begin
             to_number(candidate, length_digit: length_digit, pad: pad)
             true

data/lib/banktools-se/version.rb

@@ -1,5 +1,5 @@
 module BankTools
   module SE
-    VERSION = "2.5.0"
+    VERSION = "2.6.0"
   end
 end

data/spec/account_spec.rb

@@ -5,20 +5,20 @@ require "banktools-se"
 
 describe BankTools::SE::Account do
   it "should initialize" do
-    BankTools::SE::Account.new("foo").should be_a(BankTools::SE::Account)
+    expect(BankTools::SE::Account.new("foo")).to be_a(BankTools::SE::Account)
   end
 
   describe "#valid?" do
     it "should be true with no errors" do
       account = BankTools::SE::Account.new("foo")
-      account.stub(:errors).and_return([])
-      account.should be_valid
+      allow(account).to receive(:errors).and_return([])
+      expect(account).to be_valid
     end
 
     it "should be false with errors" do
       account = BankTools::SE::Account.new("foo")
-      account.stub(:errors).and_return([:error])
-      account.should_not be_valid
+      allow(account).to receive(:errors).and_return([:error])
+      expect(account).not_to be_valid
     end
   end
 
@@ -68,99 +68,99 @@ describe BankTools::SE::Account do
 
     ].each do |number|
       it "should be empty for a valid number like #{number}" do
-        BankTools::SE::Account.new(number).errors.should == []
+        expect(BankTools::SE::Account.new(number).errors).to eq([])
       end
     end
 
     it "should include :too_short for numbers shorter than the bank allows" do
-      BankTools::SE::Account.new("11007").errors.should include(BankTools::SE::Errors::TOO_SHORT)
+      expect(BankTools::SE::Account.new("11007").errors).to include(BankTools::SE::Errors::TOO_SHORT)
     end
 
     it "should not include :too_short for Swedbank/Sparbanker numbers that can be zerofilled" do
-      BankTools::SE::Account.new("8000-2-00000000").errors.should_not include(BankTools::SE::Errors::TOO_SHORT)
-      BankTools::SE::Account.new("9300-2-00000000").errors.should_not include(BankTools::SE::Errors::TOO_SHORT)
-      BankTools::SE::Account.new("9570-2-00000000").errors.should_not include(BankTools::SE::Errors::TOO_SHORT)
+      expect(BankTools::SE::Account.new("8000-2-00000000").errors).not_to include(BankTools::SE::Errors::TOO_SHORT)
+      expect(BankTools::SE::Account.new("9300-2-00000000").errors).not_to include(BankTools::SE::Errors::TOO_SHORT)
+      expect(BankTools::SE::Account.new("9570-2-00000000").errors).not_to include(BankTools::SE::Errors::TOO_SHORT)
     end
 
     it "should include :too_long for numbers longer than the bank allows" do
-      BankTools::SE::Account.new("1100000000007").errors.should include(BankTools::SE::Errors::TOO_LONG)
+      expect(BankTools::SE::Account.new("1100000000007").errors).to include(BankTools::SE::Errors::TOO_LONG)
     end
 
     it "should not include :too_long for Swedbank/Sparbanker numbers with clearing checksum" do
-      BankTools::SE::Account.new("8000-2-0000000000").errors.should_not include(BankTools::SE::Errors::TOO_LONG)
+      expect(BankTools::SE::Account.new("8000-2-0000000000").errors).not_to include(BankTools::SE::Errors::TOO_LONG)
     end
 
     it "should include :invalid_characters for numbers with other character than digits, spaces and dashes" do
-      BankTools::SE::Account.new("1 2-3X").errors.should include(BankTools::SE::Errors::INVALID_CHARACTERS)
-      BankTools::SE::Account.new("1 2-3").errors.should_not include(BankTools::SE::Errors::INVALID_CHARACTERS)
+      expect(BankTools::SE::Account.new("1 2-3X").errors).to include(BankTools::SE::Errors::INVALID_CHARACTERS)
+      expect(BankTools::SE::Account.new("1 2-3").errors).not_to include(BankTools::SE::Errors::INVALID_CHARACTERS)
     end
 
     it "should include :bad_checksum for Nordea personkonto if the serial Luhn/mod 10 checksum is incorrect" do
-      BankTools::SE::Utils.valid_luhn?("800928-6249").should eq(true)
-      BankTools::SE::Utils.valid_luhn?("3300-800928-6249").should eq(false)
-      BankTools::SE::Account.new("3300-800928-6249").errors.should_not include(BankTools::SE::Errors::BAD_CHECKSUM)
+      expect(BankTools::SE::Utils.valid_luhn?("800928-6249")).to eq(true)
+      expect(BankTools::SE::Utils.valid_luhn?("3300-800928-6249")).to eq(false)
+      expect(BankTools::SE::Account.new("3300-800928-6249").errors).not_to include(BankTools::SE::Errors::BAD_CHECKSUM)
     end
 
     it "should include :unknown_clearing_number if the clearing number is unknown" do
-      BankTools::SE::Account.new("10000000009").errors.should include(BankTools::SE::Errors::UNKNOWN_CLEARING_NUMBER)
-      BankTools::SE::Account.new("11000000007").errors.should_not include(BankTools::SE::Errors::UNKNOWN_CLEARING_NUMBER)
+      expect(BankTools::SE::Account.new("10000000009").errors).to include(BankTools::SE::Errors::UNKNOWN_CLEARING_NUMBER)
+      expect(BankTools::SE::Account.new("11000000007").errors).not_to include(BankTools::SE::Errors::UNKNOWN_CLEARING_NUMBER)
     end
   end
 
   describe "#bank" do
     it "should return the bank for the current clearing number" do
-      BankTools::SE::Account.new("11000000007").bank.should == "Nordea"
-      BankTools::SE::Account.new("11550000001").bank.should == "Nordea"
-      BankTools::SE::Account.new("11990000009").bank.should == "Nordea"
-      BankTools::SE::Account.new("12000000005").bank.should == "Danske Bank"
+      expect(BankTools::SE::Account.new("11000000007").bank).to eq("Nordea")
+      expect(BankTools::SE::Account.new("11550000001").bank).to eq("Nordea")
+      expect(BankTools::SE::Account.new("11990000009").bank).to eq("Nordea")
+      expect(BankTools::SE::Account.new("12000000005").bank).to eq("Danske Bank")
     end
 
     it "should return nil for unknown clearing numbers" do
-      BankTools::SE::Account.new("10000000009").bank.should be_nil
+      expect(BankTools::SE::Account.new("10000000009").bank).to be_nil
     end
   end
 
   describe "#clearing_number" do
     it "should be the first four digits" do
-      BankTools::SE::Account.new("12345678").clearing_number.should == "1234"
+      expect(BankTools::SE::Account.new("12345678").clearing_number).to eq("1234")
     end
 
     it "should be the first five digits if there is a clearing number checksum" do
-      BankTools::SE::Account.new("8000-2-0000000000").clearing_number.should == "8000-2"
+      expect(BankTools::SE::Account.new("8000-2-0000000000").clearing_number).to eq("8000-2")
     end
   end
 
   describe "#serial_number" do
     it "should be the digits after the first four digits" do
-      BankTools::SE::Account.new("12345678").serial_number.should == "5678"
+      expect(BankTools::SE::Account.new("12345678").serial_number).to eq("5678")
     end
 
     it "should be the digits after the first five digits if there is a clearing number checksum" do
-      BankTools::SE::Account.new("8000-2-0000000000").serial_number.should == "0000000000"
+      expect(BankTools::SE::Account.new("8000-2-0000000000").serial_number).to eq("0000000000")
     end
 
     it "should be the empty string if there aren't enough numbers" do
-      BankTools::SE::Account.new("12").serial_number.should == ""
+      expect(BankTools::SE::Account.new("12").serial_number).to eq("")
     end
 
   end
 
   describe "#normalize" do
     it "should normalize to clearing number dash serial number" do
-      account = BankTools::SE::Account.new("11000000007").normalize.should == "1100-0000007"
+      account = expect(BankTools::SE::Account.new("11000000007").normalize).to eq("1100-0000007")
     end
 
     it "should keep any Swedbank/Sparbanker clearing checksum" do
-      BankTools::SE::Account.new("8000-2-0000000000").normalize.should == "8000-2-0000000000"
+      expect(BankTools::SE::Account.new("8000-2-0000000000").normalize).to eq("8000-2-0000000000")
     end
 
     it "should not attempt to normalize invalid numbers" do
-      account = BankTools::SE::Account.new(" 1-2-3 ").normalize.should == " 1-2-3 "
+      account = expect(BankTools::SE::Account.new(" 1-2-3 ").normalize).to eq(" 1-2-3 ")
     end
 
     it "should prepend zeroes to the serial number if necessary" do
-      BankTools::SE::Account.new("8000-2-80000003").normalize.should   == "8000-2-0080000003"
-      BankTools::SE::Account.new("8000-2-8000000003").normalize.should == "8000-2-8000000003"
+      expect(BankTools::SE::Account.new("8000-2-80000003").normalize).to   eq("8000-2-0080000003")
+      expect(BankTools::SE::Account.new("8000-2-8000000003").normalize).to eq("8000-2-8000000003")
     end
   end
 end

data/spec/bankgiro_spec.rb

@@ -3,20 +3,20 @@ require "banktools-se"
 
 describe BankTools::SE::Bankgiro do
   it "should initialize" do
-    BankTools::SE::Bankgiro.new("foo").should be_a(BankTools::SE::Bankgiro)
+    expect(BankTools::SE::Bankgiro.new("foo")).to be_a(BankTools::SE::Bankgiro)
   end
 
   describe "#valid?" do
     it "should be true with no errors" do
       account = BankTools::SE::Bankgiro.new("foo")
-      account.stub(:errors).and_return([])
-      account.should be_valid
+      allow(account).to receive(:errors).and_return([])
+      expect(account).to be_valid
     end
 
     it "should be false with errors" do
       account = BankTools::SE::Bankgiro.new("foo")
-      account.stub(:errors).and_return([:error])
-      account.should_not be_valid
+      allow(account).to receive(:errors).and_return([:error])
+      expect(account).not_to be_valid
     end
   end
 
@@ -28,59 +28,59 @@ describe BankTools::SE::Bankgiro do
       "640-5070",
     ].each do |number|
       it "should be empty for a valid number like #{number}" do
-        BankTools::SE::Bankgiro.new(number).errors.should be_empty
+        expect(BankTools::SE::Bankgiro.new(number).errors).to be_empty
       end
     end
 
     it "should include :too_short for numbers shorter than 7 digits" do
-      BankTools::SE::Bankgiro.new(nil).errors.should include(BankTools::SE::Errors::TOO_SHORT)
-      BankTools::SE::Bankgiro.new("").errors.should include(BankTools::SE::Errors::TOO_SHORT)
-      BankTools::SE::Bankgiro.new("54-0296").errors.should include(BankTools::SE::Errors::TOO_SHORT)
-      BankTools::SE::Bankgiro.new("54---------0296").errors.should include(BankTools::SE::Errors::TOO_SHORT)
+      expect(BankTools::SE::Bankgiro.new(nil).errors).to include(BankTools::SE::Errors::TOO_SHORT)
+      expect(BankTools::SE::Bankgiro.new("").errors).to include(BankTools::SE::Errors::TOO_SHORT)
+      expect(BankTools::SE::Bankgiro.new("54-0296").errors).to include(BankTools::SE::Errors::TOO_SHORT)
+      expect(BankTools::SE::Bankgiro.new("54---------0296").errors).to include(BankTools::SE::Errors::TOO_SHORT)
     end
 
     it "should include :too_long for numbers longer than 8 digits" do
-      BankTools::SE::Bankgiro.new("5402-96810").errors.should include(BankTools::SE::Errors::TOO_LONG)
+      expect(BankTools::SE::Bankgiro.new("5402-96810").errors).to include(BankTools::SE::Errors::TOO_LONG)
     end
 
     it "should include :invalid_characters for numbers with other character than digits, spaces and dashes" do
-      BankTools::SE::Bankgiro.new("5402-9681X").errors.should include(BankTools::SE::Errors::INVALID_CHARACTERS)
-      BankTools::SE::Bankgiro.new(" 5 4 0 2 - 9 6 8 1 ").errors.should_not include(BankTools::SE::Errors::INVALID_CHARACTERS)
+      expect(BankTools::SE::Bankgiro.new("5402-9681X").errors).to include(BankTools::SE::Errors::INVALID_CHARACTERS)
+      expect(BankTools::SE::Bankgiro.new(" 5 4 0 2 - 9 6 8 1 ").errors).not_to include(BankTools::SE::Errors::INVALID_CHARACTERS)
     end
 
     it "should include :bad_checksum if the Luhn/mod 10 checksum is incorrect" do
-      BankTools::SE::Bankgiro.new("5402-9682").errors.should include(BankTools::SE::Errors::BAD_CHECKSUM)
+      expect(BankTools::SE::Bankgiro.new("5402-9682").errors).to include(BankTools::SE::Errors::BAD_CHECKSUM)
     end
   end
 
   describe "#normalize" do
     it "should normalize 7-digit numbers to NNN-NNNN" do
       account = BankTools::SE::Bankgiro.new(" 6-40 - 5070")
-      account.normalize.should == "640-5070"
+      expect(account.normalize).to eq("640-5070")
     end
 
     it "should normalize 8-digit numbers to NNNN-NNNN" do
       account = BankTools::SE::Bankgiro.new(" 5-4-0-2-9-6- 81-  ")
-      account.normalize.should == "5402-9681"
+      expect(account.normalize).to eq("5402-9681")
     end
 
     it "should not attempt to normalize invalid numbers" do
       account = BankTools::SE::Bankgiro.new(" 1-2-3 ")
-      account.normalize.should == " 1-2-3 "
+      expect(account.normalize).to eq(" 1-2-3 ")
     end
   end
 
   describe "#fundraising? (90-konto)" do
     it "should be true for the number series 900-nnnn to 904-nnnn" do
-      BankTools::SE::Bankgiro.new("902-0033").should be_fundraising
+      expect(BankTools::SE::Bankgiro.new("902-0033")).to be_fundraising
     end
 
     it "should be false for invalid numbers in the right series" do
-      BankTools::SE::Bankgiro.new("902-0034").should_not be_fundraising
+      expect(BankTools::SE::Bankgiro.new("902-0034")).not_to be_fundraising
     end
 
     it "should be false for numbers outside the right series" do
-      BankTools::SE::Bankgiro.new("5402-9681").should_not be_fundraising
+      expect(BankTools::SE::Bankgiro.new("5402-9681")).not_to be_fundraising
     end
   end
 end

data/spec/ocr_spec.rb

@@ -2,22 +2,22 @@ require "spec_helper"
 require "banktools-se"
 
 describe BankTools::SE::OCR do
-  # http://web.archive.org/web/20111216065227/http://www.bgc.se/upload/Gemensamt/Trycksaker/Manualer/BG6070.pdf section 5.2
+  # https://www.bankgirot.se/globalassets/dokument/anvandarmanualer/bankgiroinbetalningar_anvandarmanual_sv_31okt2016.pdf section 5.2
   describe ".from_number" do
     it "adds a mod-10 check digit" do
-      BankTools::SE::OCR.from_number("123").should eq "1230"
+      expect(BankTools::SE::OCR.from_number("123")).to eq "1230"
     end
 
     it "handles integer input" do
-      BankTools::SE::OCR.from_number(123).should eq "1230"
+      expect(BankTools::SE::OCR.from_number(123)).to eq "1230"
     end
 
     it "can add an optional length digit" do
-      BankTools::SE::OCR.from_number("1234567890", length_digit: true).should eq "123456789023"
+      expect(BankTools::SE::OCR.from_number("1234567890", length_digit: true)).to eq "123456789023"
     end
 
     it "can pad the number" do
-      BankTools::SE::OCR.from_number("1234567890", length_digit: true, pad: "0").should eq "1234567890037"
+      expect(BankTools::SE::OCR.from_number("1234567890", length_digit: true, pad: "0")).to eq "1234567890037"
     end
 
     it "raises if resulting number is > 25 digits" do
@@ -31,19 +31,19 @@ describe BankTools::SE::OCR do
 
   describe ".to_number" do
     it "strips the mod-10 check digit" do
-      BankTools::SE::OCR.to_number("1230").should eq "123"
+      expect(BankTools::SE::OCR.to_number("1230")).to eq "123"
     end
 
     it "handles integer input" do
-      BankTools::SE::OCR.to_number(1230).should eq "123"
+      expect(BankTools::SE::OCR.to_number(1230)).to eq "123"
     end
 
     it "can strip an optional length digit" do
-      BankTools::SE::OCR.to_number("123456789023", length_digit: true).should eq "1234567890"
+      expect(BankTools::SE::OCR.to_number("123456789023", length_digit: true)).to eq "1234567890"
     end
 
     it "strips the given padding" do
-      BankTools::SE::OCR.to_number("1234567890037", length_digit: true, pad: "0").should eq "1234567890"
+      expect(BankTools::SE::OCR.to_number("1234567890037", length_digit: true, pad: "0")).to eq "1234567890"
     end
 
     it "raises if the given number is too short to be a valid OCR" do
@@ -74,32 +74,25 @@ describe BankTools::SE::OCR do
 
   describe ".find_all_in_string" do
     it "detects only number sequences that are valid OCRs" do
-      expect(BankTools::SE::OCR.find_all_in_string("1230 1234 4564")).to eq [ "1230", "4564" ]
+      expect(BankTools::SE::OCR.find_all_in_string("1230 1234 4564")).to include "1230", "4564"
+      expect(BankTools::SE::OCR.find_all_in_string("1230 1234 4564")).not_to include "1234"
     end
 
     it "requires OCRs to comply with the specified length_digit and pad options" do
       string = "1230 4564 123067 456061"
-      expect(BankTools::SE::OCR.find_all_in_string(string)).to eq [ "1230", "4564", "123067", "456061" ]
-      expect(BankTools::SE::OCR.find_all_in_string(string, length_digit: true, pad: "0")).to eq [ "123067", "456061" ]
+      expect(BankTools::SE::OCR.find_all_in_string(string)).to include "1230", "4564", "123067", "456061"
+
+      expect(BankTools::SE::OCR.find_all_in_string(string, length_digit: true, pad: "0")).to include "123067", "456061"
+      expect(BankTools::SE::OCR.find_all_in_string(string, length_digit: true, pad: "0")).not_to include "1230", "4564"
     end
 
     it "finds digits among any non-digit characters" do
       expect(BankTools::SE::OCR.find_all_in_string("x1230x")).to eq [ "1230" ]
     end
 
-    it "handles OCR numbers both separated and split by newlines" do
-      expect(BankTools::SE::OCR.find_all_in_string("1230\n4564")).to include "1230", "4564", "12304564"
-      expect(BankTools::SE::OCR.find_all_in_string("45\n64")).to eq [ "4564" ]
-    end
-
-    it "handles OCR numbers both separated and split by semicolons" do
-      expect(BankTools::SE::OCR.find_all_in_string("1230;4564")).to include "1230", "4564", "12304564"
-      expect(BankTools::SE::OCR.find_all_in_string("45;64")).to eq [ "4564" ]
-    end
-
-    it "handles OCR numbers both separated and split by '.'" do
-      expect(BankTools::SE::OCR.find_all_in_string("1230.4564")).to include "1230", "4564", "12304564"
-      expect(BankTools::SE::OCR.find_all_in_string("45.64")).to eq [ "4564" ]
+    it "handles OCR numbers both separated and split by non-digits" do
+      expect(BankTools::SE::OCR.find_all_in_string("12\n30\n4564")).to include "1230", "4564", "12304564"
+      expect(BankTools::SE::OCR.find_all_in_string("12;30.4564")).to include "1230", "4564", "12304564"
     end
 
     it "handles numbers smushed together" do
@@ -118,11 +111,13 @@ describe BankTools::SE::OCR do
     end
 
     it "lets you configure the accepted OCR min_length" do
-      expect(BankTools::SE::OCR.find_all_in_string("12304564")).to eq [ "12304564", "04564", "1230", "4564" ]
-      expect(BankTools::SE::OCR.find_all_in_string("12304564", min_length: 6)).to eq [ "12304564" ]
+      expect(BankTools::SE::OCR.find_all_in_string("12304564")).to include "1230", "12304564"
+
+      expect(BankTools::SE::OCR.find_all_in_string("12304564", min_length: 6)).to include "12304564"
+      expect(BankTools::SE::OCR.find_all_in_string("12304564", min_length: 6)).not_to include "1230"
 
       expect(BankTools::SE::OCR.find_all_in_string("1234")).to eq []
-      expect(BankTools::SE::OCR.find_all_in_string("1234", min_length: 2)).to eq [ "34" ]
+      expect(BankTools::SE::OCR.find_all_in_string("1234", min_length: 2)).to include "34"
     end
 
     it "lets you configure the accepted OCR max_length" do
@@ -138,7 +133,8 @@ describe BankTools::SE::OCR do
     end
 
     it "excludes duplicates" do
-      expect(BankTools::SE::OCR.find_all_in_string("1230 1230 4564")).to eq [ "1230", "4564" ]
+      results = BankTools::SE::OCR.find_all_in_string("1230 1230 4564")
+      expect(results.length).to eq results.uniq.length
     end
   end
 end

data/spec/plusgiro_spec.rb

@@ -4,21 +4,21 @@ require "banktools-se"
 describe BankTools::SE::Plusgiro do
 
   it "should initialize" do
-    BankTools::SE::Plusgiro.new("foo").should be_a(BankTools::SE::Plusgiro)
+    expect(BankTools::SE::Plusgiro.new("foo")).to be_a(BankTools::SE::Plusgiro)
   end
 
   describe "#valid?" do
 
     it "should be true with no errors" do
       account = BankTools::SE::Plusgiro.new("foo")
-      account.stub(:errors).and_return([])
-      account.should be_valid
+      allow(account).to receive(:errors).and_return([])
+      expect(account).to be_valid
     end
 
     it "should be false with errors" do
       account = BankTools::SE::Plusgiro.new("foo")
-      account.stub(:errors).and_return([:error])
-      account.should_not be_valid
+      allow(account).to receive(:errors).and_return([:error])
+      expect(account).not_to be_valid
     end
 
   end
@@ -30,28 +30,28 @@ describe BankTools::SE::Plusgiro do
       "4-2",  # Sveriges riksbank
     ].each do |number|
       it "should be empty for a valid number like #{number}" do
-        BankTools::SE::Plusgiro.new(number).errors.should be_empty
+        expect(BankTools::SE::Plusgiro.new(number).errors).to be_empty
       end
     end
 
     it "should include :too_short for numbers shorter than 2 digits" do
-      BankTools::SE::Plusgiro.new(nil).errors.should include(BankTools::SE::Errors::TOO_SHORT)
-      BankTools::SE::Plusgiro.new("").errors.should include(BankTools::SE::Errors::TOO_SHORT)
-      BankTools::SE::Plusgiro.new("1").errors.should include(BankTools::SE::Errors::TOO_SHORT)
-      BankTools::SE::Plusgiro.new("1---------").errors.should include(BankTools::SE::Errors::TOO_SHORT)
+      expect(BankTools::SE::Plusgiro.new(nil).errors).to include(BankTools::SE::Errors::TOO_SHORT)
+      expect(BankTools::SE::Plusgiro.new("").errors).to include(BankTools::SE::Errors::TOO_SHORT)
+      expect(BankTools::SE::Plusgiro.new("1").errors).to include(BankTools::SE::Errors::TOO_SHORT)
+      expect(BankTools::SE::Plusgiro.new("1---------").errors).to include(BankTools::SE::Errors::TOO_SHORT)
     end
 
     it "should include :too_long for numbers longer than 8 digits" do
-      BankTools::SE::Plusgiro.new("410 54 68-51").errors.should include(BankTools::SE::Errors::TOO_LONG)
+      expect(BankTools::SE::Plusgiro.new("410 54 68-51").errors).to include(BankTools::SE::Errors::TOO_LONG)
     end
 
     it "should include :invalid_characters for numbers with other character than digits, spaces and dashes" do
-      BankTools::SE::Plusgiro.new("410 54 68-5X").errors.should include(BankTools::SE::Errors::INVALID_CHARACTERS)
-      BankTools::SE::Plusgiro.new("4 1 0 5 4 6 8 - 5 ").errors.should_not include(BankTools::SE::Errors::INVALID_CHARACTERS)
+      expect(BankTools::SE::Plusgiro.new("410 54 68-5X").errors).to include(BankTools::SE::Errors::INVALID_CHARACTERS)
+      expect(BankTools::SE::Plusgiro.new("4 1 0 5 4 6 8 - 5 ").errors).not_to include(BankTools::SE::Errors::INVALID_CHARACTERS)
     end
 
     it "should include :bad_checksum if the Luhn/mod 10 checksum is incorrect" do
-      BankTools::SE::Plusgiro.new("410 54 68-6").errors.should include(BankTools::SE::Errors::BAD_CHECKSUM)
+      expect(BankTools::SE::Plusgiro.new("410 54 68-6").errors).to include(BankTools::SE::Errors::BAD_CHECKSUM)
     end
 
   end
@@ -60,22 +60,22 @@ describe BankTools::SE::Plusgiro do
 
     it "should normalize short numbers to the format N-N" do
       account = BankTools::SE::Plusgiro.new(" 4 - 2")
-      account.normalize.should == "4-2"
+      expect(account.normalize).to eq("4-2")
     end
 
     it "should normalize odd-length numbers to the format NN NN NN-N" do
       account = BankTools::SE::Plusgiro.new("2865434")
-      account.normalize.should == "28 65 43-4"
+      expect(account.normalize).to eq("28 65 43-4")
     end
 
     it "should normalize even-length numbers to the format NNN NN NN-N" do
       account = BankTools::SE::Plusgiro.new("41054685")
-      account.normalize.should == "410 54 68-5"
+      expect(account.normalize).to eq("410 54 68-5")
     end
 
     it "should not attempt to normalize invalid numbers" do
       account = BankTools::SE::Plusgiro.new(" 1-2-3 ")
-      account.normalize.should == " 1-2-3 "
+      expect(account.normalize).to eq(" 1-2-3 ")
     end
 
   end
@@ -83,15 +83,15 @@ describe BankTools::SE::Plusgiro do
   describe "#fundraising? (90-konto)" do
 
     it "should be true for the number series 90-nnnn" do
-      BankTools::SE::Plusgiro.new("90 20 03-3").should be_fundraising
+      expect(BankTools::SE::Plusgiro.new("90 20 03-3")).to be_fundraising
     end
 
     it "should be false for invalid numbers in the right series" do
-      BankTools::SE::Plusgiro.new("90 20 03-4").should_not be_fundraising
+      expect(BankTools::SE::Plusgiro.new("90 20 03-4")).not_to be_fundraising
     end
 
     it "should be false for numbers outside the right series" do
-      BankTools::SE::Plusgiro.new("4-2").should_not be_fundraising
+      expect(BankTools::SE::Plusgiro.new("4-2")).not_to be_fundraising
     end
 
   end

data/spec/spec_helper.rb

@@ -1,5 +1,4 @@
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.filter_run :focus => true
   config.run_all_when_everything_filtered = true
 end

data/spec/utils_spec.rb

@@ -19,7 +19,7 @@ describe BankTools::SE::Utils, "valid_luhn?" do
     "5402-9681",
   ].each do |number|
     it "should allow a valid number like #{number}" do
-      BankTools::SE::Utils.valid_luhn?(number).should eq(true)
+      expect(BankTools::SE::Utils.valid_luhn?(number)).to eq(true)
     end
   end
 
@@ -29,7 +29,7 @@ describe BankTools::SE::Utils, "valid_luhn?" do
     "5402-9682",
   ].each do |number|
     it "should disallow an invalid number like #{number}" do
-      BankTools::SE::Utils.valid_luhn?(number).should eq(false)
+      expect(BankTools::SE::Utils.valid_luhn?(number)).to eq(false)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: banktools-se
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.6.0
 platform: ruby
 authors:
 - Henrik Nyh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-26 00:00:00.000000000 Z
+date: 2016-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake