resident 0.0.9 → 0.0.12

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f46bb28b43ee9e5b885a50fdad775f2730dfaf059d238bf78f2e4f687f015440
+  data.tar.gz: 3daabe1d914221094e18cc29032ffd365c3ce497150a3c92c2f9293255772214
+SHA512:
+  metadata.gz: c7156a5215a04bf80888f46a88b9d84979dc45097c8480184e58aed0c1b2d6548dbe31dd3e4e018be71e3a0f73e65b30c4601ae2791e96c7e1456c64fd2ba24c
+  data.tar.gz: 5e3b40279eabe8e69113a8767985e281adc2f7d8d30ffd48e887d8c3d7e4f80072c3fc66ed96825c325e1720b64ed3c47de9af3548cea14dbe37414b62e8cde4

data/{README.rdoc → README.md}

@@ -1,25 +1,31 @@
-= Resident
+# Resident
 
 Validates a National Identification Number (See http://en.wikipedia.org/wiki/National_identification_number).
 There are some 62 countries that have this type of number.
-This gem currently only supports Swedish (Personnummer) and Finnish (Henkilöasiakkaat) ones.
 
-There is a special focus on identifying these numbers robustly (i.e. you can safely validate a param[:number] directly, or cleanup your database by running every non-normalized value through this gem).
+This gem currently only supports Swedish (Personnummer), Finnish
+(Henkilöasiakkaat), Norwegian (Fødelsenummer) and Danish (CPR).
 
-== Installation
+There is a special focus on identifying these numbers robustly
+(i.e. you can safely validate a param[:number] directly, or cleanup
+your database by running every non-normalized value through this gem).
+
+## Installation
 
     gem install resident
 
-== Usage
+## Usage
 
-Really, you can just use <tt>valid?</tt> and <tt>to_s</tt> like so:
+Really, you can just use <tt>valid?</tt>, <tt>sanitize</tt>, <tt>to_s</tt>, and <tt>age</tt> like so:
 
     require 'resident'
 
     number = NationalIdentificationNumber::Swedish.new('0501261853')
 
-    number.valid?  #=> true
-    number.to_s    #=> "050126-1853"
+    number.valid?   #=> true
+    number.to_s     #=> "050126-1853"
+    number.sanitize #=> "050126-1853" (Would have been nil if invalid)
+    number.age      #=> 9
 
 Please have a look at the specs to see how the national identification numbers of various countries are handled.
 
@@ -27,7 +33,7 @@ An example of robustness:
 
     NationalIdentificationNumber::Swedish.new("19050126-185d3\n").to_s => "050126-1853"
 
-== License
+## License
 
 Some marked parts of the code are inspired or taken from MIT licensed code of
 
@@ -36,7 +42,7 @@ Some marked parts of the code are inspired or taken from MIT licensed code of
 
 Other than that you got:
 
-Copyright (c) 2011 Bukowskis.
+Copyright (c) 2011-2022 Bukowskis.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -54,4 +60,4 @@ 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.
+THE SOFTWARE.

data/lib/national_identification_number/base.rb

@@ -17,8 +17,23 @@ module NationalIdentificationNumber
       @number
     end
 
+    def sanitize
+      to_s if valid?
+    end
+
+    def age
+      age_for_dob date
+    end
+
     protected
 
+    # stackoverflow.com/questions/819263
+    def age_for_dob(dob)
+      today = Time.now.utc.to_date
+      return nil unless dob && today >= dob
+      today.year - dob.year - ((today.month > dob.month || (today.month == dob.month && today.day >= dob.day)) ? 0 : 1)
+    end
+
     def repair
       @number = @number.to_s.upcase.gsub(/\s/, '')
     end
@@ -26,6 +41,5 @@ module NationalIdentificationNumber
     def validate
       raise 'You need to implement at least this method in subclasses.'
     end
-
   end
 end

data/lib/national_identification_number/danish.rb

@@ -0,0 +1,43 @@
+require 'national_identification_number/base'
+
+module NationalIdentificationNumber
+  class Danish < Base
+    attr_reader :date
+
+    protected
+
+    def repair
+      super
+      @number.gsub!(/[^0-9]/, '')
+      if (matches = @number.match(/\A(?<birthday>[0-9]{6})(?<checksum>[0-9]{4})\z/))
+        birthday, checksum = matches.values_at(:birthday, :checksum)
+        @number = "#{birthday}-#{checksum}"
+      end
+    end
+
+    def validate
+      if (matches = @number.match(/\A(?<day>\d{2})(?<month>\d{2})(?<year>\d{2})-(?<serial>\d{3})(?<checksum>\d{1})\z/))
+        day, month, year, serial, checksum = matches.values_at(:day, :month, :year, :serial, :checksum)
+        begin
+          @date = Date.parse("#{full_year(serial, year)}-#{month}-#{day}")
+          @valid = true
+          @number = "#{day}#{month}#{year}-#{serial}#{checksum}"
+        rescue ArgumentError
+        end
+      end
+    end
+
+    private
+
+    def full_year(serial, year)
+      century(serial, year.to_i) + year.to_i
+    end
+
+    def century(serial, year)
+      first_digit = serial[0].to_i
+      return 1800 if (5..8).include?(first_digit) && year > 57
+      return 2000 if (4..9).include?(first_digit) && year < 37
+      1900
+    end
+  end
+end

data/lib/national_identification_number/finnish.rb

@@ -3,21 +3,23 @@ require 'national_identification_number/base'
 module NationalIdentificationNumber
   class Finnish < Base
 
+    attr_reader :date
+
     CHECKSUMS = %w{ 0 1 2 3 4 5 6 7 8 9 A B C D E F H J K L M N P R S T U V W X Y }
 
     protected
 
     def repair
       super
-      if @number.match(/(\d{6})(\-{0,1})(\d{3})([#{CHECKSUMS}]{1})/)
+      if @number.match(/(\d{6})(\-{0,1})(\d{3})([#{CHECKSUMS.join('')}]{1})/)
         @number = "#{$1}-#{$3}#{$4}"
       else
-        @number.gsub!(/[^#{CHECKSUMS}\-\+]/, '')
+        @number.gsub!(/[^#{CHECKSUMS.join('')}\-\+]/, '')
       end
     end
 
     def validate
-      if @number.match(/(\d{2})(\d{2})(\d{2})([\-\+A]{0,1})(\d{3})([#{CHECKSUMS}]{1})/)
+      if @number.match(/(\d{2})(\d{2})(\d{2})([\-\+A]{0,1})(\d{3})([#{CHECKSUMS.join('')}]{1})/)
         checksum = self.class.calculate_checksum("#{$1}#{$2}#{$3}#{$5}")
         if checksum == $6
 
@@ -34,7 +36,7 @@ module NationalIdentificationNumber
           end
 
           begin
-            Date.parse("#{century+year}-#{month}-#{day}")
+            @date = Date.parse("#{century+year}-#{month}-#{day}")
             @valid = true
             @number = ("#{$1}#{$2}#{$3}#{divider}#{$5}#{checksum}")
           rescue ArgumentError

data/lib/national_identification_number/norwegian.rb

@@ -0,0 +1,60 @@
+require 'national_identification_number/base'
+
+module NationalIdentificationNumber
+  class Norwegian < Base
+    attr_reader :date
+
+    protected
+
+    def repair
+      super
+      @number.gsub!(/[^0-9]/, '')
+    end
+
+    def validate
+      if (matches = @number.match(/\A(?<day>\d{2})(?<month>\d{2})(?<year>\d{2})(?<serial>\d{3})(?<checksum>\d{2})\z/))
+        day, month, year, serial, checksum = matches.values_at(:day, :month, :year, :serial, :checksum)
+        sans_checksum = "#{day}#{month}#{year}#{serial}"
+
+        if checksum == calculate_checksum(sans_checksum)
+          begin
+            @date = Date.parse("#{full_year(serial, year)}-#{month}-#{day}")
+            @valid = true
+            @number = "#{sans_checksum}#{checksum}"
+          rescue ArgumentError
+          end
+        end
+      end
+    end
+
+    private
+
+    def full_year(serial, year)
+      century(serial) + year.to_i
+    end
+
+    def century(serial)
+      case serial.to_i
+      when 0..499 then 1900
+      else 2000 # or 1800, not possible to tell.
+      end
+    end
+
+    def calculate_checksum(number)
+      digits = number.split('').map(&:to_i)
+      w1 = [3, 7, 6, 1, 8, 9, 4, 5, 2]
+      w2 = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
+
+      k1 = weighted_modulo_11(digits.zip(w1))
+      k2 = weighted_modulo_11([*digits, k1].zip(w2))
+      "#{k1}#{k2}"
+    end
+
+    def weighted_modulo_11(digits_and_weights)
+      result = 11 - (digits_and_weights.map do |terms|
+                       terms.reduce(:*)
+                     end.sum % 11)
+      result > 9 ? 0 : result
+    end
+  end
+end

data/lib/national_identification_number/swedish.rb

@@ -4,7 +4,6 @@ module NationalIdentificationNumber
   # Inspired by https://github.com/c7/personnummer/blob/master/lib/personnummer.rb
   # Copyright (c) 2008 Peter Hellberg MIT
   class Swedish < Base
-
     attr_reader :date # used for testing
 
     # Generator for valid Swedish personnummer: http://en.wikipedia.org/wiki/Personal_identity_number_(Sweden)
@@ -31,7 +30,12 @@ module NationalIdentificationNumber
       if @number.match(/\A(\d{0}|\d{2})(\d{6})(\-{0,1})(\d{4})\Z/)
         @number = "#{$2}-#{$4}"
       else
-        @number.gsub!(/[^\d\-\+]/, '')
+        candidate = @number.gsub(/[^\d\-\+]/, '')
+        if candidate.match(/\A(\d{0}|\d{2})(\d{6})(\-{0,1})(\d{4})\Z/)
+          @number = "#{$2}-#{$4}"
+        else
+          @number = candidate
+        end
       end
     end
 
@@ -54,7 +58,14 @@ module NationalIdentificationNumber
            elsif divider == '+'
              century = 1800
            else
-             century = 1900
+             preliminary_age = age_for_dob(Date.parse("#{1900 + year}-#{month}-#{day}")) rescue 0
+             #raise preliminary_age.inspect
+             if preliminary_age > 99
+               # It's unlikely that the person is older than 99, so assume a child when no divider was provided.
+               century = 2000
+             else
+               century = 1900
+             end
            end
 
            begin
@@ -91,15 +102,14 @@ module NationalIdentificationNumber
       end
       control_digit
     end
-
   end
 end
 
-if $0 == __FILE__
-  # Randomize every part
-  puts Bukowskis::NationalIdentificationNumber::Swedish.generate
-  # Use given date, randomize serial
-  puts Bukowskis::NationalIdentificationNumber::Swedish.generate(Date.new(1975,1,1))
-  # Use given date and serial, calculate checksum
-  puts Bukowskis::NationalIdentificationNumber::Swedish.generate(Date.new(1975,1,1), 123)
-end
+# if $0 == __FILE__
+#   # Randomize every part
+#   puts Bukowskis::NationalIdentificationNumber::Swedish.generate
+#   # Use given date, randomize serial
+#   puts Bukowskis::NationalIdentificationNumber::Swedish.generate(Date.new(1975,1,1))
+#   # Use given date and serial, calculate checksum
+#   puts Bukowskis::NationalIdentificationNumber::Swedish.generate(Date.new(1975,1,1), 123)
+# end

data/lib/national_identification_number.rb

@@ -1,2 +1,4 @@
 require 'national_identification_number/swedish'
 require 'national_identification_number/finnish'
+require 'national_identification_number/norwegian'
+require 'national_identification_number/danish'

data/spec/national_identification_number/base_spec.rb

@@ -1,74 +1,77 @@
 require 'spec_helper'
-require 'resident'
-
-include NationalIdentificationNumber
+require 'national_identification_number/base'
 
 class TestBaseChild < NationalIdentificationNumber::Base
   def set_valid_to_nil
     @valid = nil
   end
+
   protected
+
   def validate
     @valid = 'validates_to_true'
   end
 end
 
-describe Base, 'new' do
+describe NationalIdentificationNumber::Base do
 
-  it "should instantiate correctly" do
-    TestBaseChild.new('12345').should be_an_instance_of TestBaseChild
-  end
+  describe '#initialize' do
 
- it "should repair on initialization" do
-   TestBaseChild.new(' 12345abc ').to_s.should == '12345ABC'
- end
+    it "instantiates correctly" do
+      expect( TestBaseChild.new('12345') ).to be_an_instance_of TestBaseChild
+    end
 
- it "should validate on initialization" do
-   lambda {  NationalIdentificationNumber::Base.new('12345') }.should raise_error(RuntimeError, 'You need to implement at least this method in subclasses.')
- end
+    it "repairs on initialization" do
+      expect( TestBaseChild.new(' 12345abc ').to_s ).to eq '12345ABC'
+    end
 
-end
-
-describe Base, 'valid?' do
+    it "validates on initialization" do
+      expect { NationalIdentificationNumber::Base.new('12345') }.to raise_error(RuntimeError, 'You need to implement at least this method in subclasses.')
+    end
 
-  it "should return true if it is valid" do
-    TestBaseChild.new('12345abc').should be_valid
   end
 
-  it "should return true if it is valid" do
-    base = TestBaseChild.new('12345abc')
-    base.set_valid_to_nil
-    base.should_not be_valid
-  end
+  describe '#valid?' do
 
-end
+    it "should return true if it is valid" do
+      expect( TestBaseChild.new('12345abc') ).to be_valid
+    end
 
-describe Base, 'to_s' do
+    it "should return true if it is valid" do
+      base = TestBaseChild.new('12345abc')
+      base.set_valid_to_nil
+      expect( base ).to_not be_valid
+    end
 
-  it "should return the number" do
-    TestBaseChild.new('12345ABC').to_s.should == '12345ABC'
   end
 
-end
+  describe '#to_s' do
 
-describe Base, 'repair' do
+    it "should return the number" do
+      expect( TestBaseChild.new('12345ABC').to_s ).to eq '12345ABC'
+    end
 
-  it "should be a protected method" do
-    lambda { TestBaseChild.new('12345').repair }.should raise_error NoMethodError
   end
 
-  it "should strip whitespaces and capitalize everything" do
-    TestBaseChild.new(' 123  45  abc %&/ ').to_s.should == '12345ABC%&/'
-  end
+  describe '#repair' do
 
-  it "should make it a string" do
-    TestBaseChild.new(:symbol).to_s.should == 'SYMBOL'
-    TestBaseChild.new(1234).to_s.should == '1234'
-    TestBaseChild.new(nil).to_s.should == ''
-  end
+    it "should be a protected method" do
+      expect { TestBaseChild.new('12345').repair }.to raise_error NoMethodError
+    end
+
+    it "should strip whitespaces and capitalize everything" do
+      expect( TestBaseChild.new(' 123  45  abc %&/ ').to_s ).to eq '12345ABC%&/'
+    end
+
+    it "should make it a string" do
+      expect( TestBaseChild.new(:symbol).to_s ).to eq 'SYMBOL'
+      expect( TestBaseChild.new(1234).to_s ).to eq '1234'
+      expect( TestBaseChild.new(nil).to_s ).to eq ''
+    end
 
-  it "should strip newlines and tabs" do
-    TestBaseChild.new("one\ntwo\tthree\n").to_s.should == 'ONETWOTHREE'
+    it "should strip newlines and tabs" do
+      expect( TestBaseChild.new("one\ntwo\tthree\n").to_s ).to eq 'ONETWOTHREE'
+    end
   end
 
 end

data/spec/national_identification_number/danish_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'resident'
+
+describe NationalIdentificationNumber::Danish do
+  describe '#valid?' do
+    it 'recognizes valid numbers' do
+      expect(described_class.new('311257-1735')).to be_valid
+      expect(described_class.new('290444-0305')).to be_valid
+      expect(described_class.new('300168-0330')).to be_valid
+    end
+
+    it 'recognizes invalid numbers' do
+      expect(described_class.new('251379-4001')).not_to be_valid # invalid month
+      expect(described_class.new('300279-4001')).not_to be_valid # invalid day
+      expect(described_class.new('asdf')).not_to be_valid
+      expect(described_class.new('1234567890')).not_to be_valid
+      expect(described_class.new('0000000000000')).not_to be_valid
+      expect(described_class.new('000000-0000')).not_to be_valid
+      expect(described_class.new('')).not_to be_valid
+      expect(described_class.new(1234567890)).not_to be_valid
+      expect(described_class.new(:really_bad_input_value)).not_to be_valid
+    end
+  end
+
+  describe 'sanitize' do
+    context 'with valid numbers' do
+      it 'is the formatted number' do
+        expect(described_class.new('3112571735').sanitize).to eq '311257-1735'
+        expect(described_class.new('290444.0305').sanitize).to eq '290444-0305'
+        expect(described_class.new('30.01.68.03.30').sanitize).to eq '300168-0330'
+      end
+    end
+
+    context 'with invalid numbers' do
+      it 'is nil' do
+        expect(described_class.new('251379-4001').sanitize).to be_nil
+        expect(described_class.new('300279-4001').sanitize).to be_nil
+        expect(described_class.new('asdf').sanitize).to be_nil
+        expect(described_class.new('1234567890').sanitize).to be_nil
+        expect(described_class.new('0000000000000').sanitize).to be_nil
+        expect(described_class.new('000000-0000').sanitize).to be_nil
+        expect(described_class.new('').sanitize).to be_nil
+        expect(described_class.new(1234567890).sanitize).to be_nil
+        expect(described_class.new(:really_bad_input_value).sanitize).to be_nil
+      end
+    end
+  end
+
+  describe 'age' do
+    before do
+      Timecop.freeze Date.parse('2022-03-04')
+    end
+
+    it 'recognizes valid numbers' do
+      expect(described_class.new('110779-4101').age).to eq 42
+      expect(described_class.new('010100-1000').age).to eq 122
+      expect(described_class.new('110736-4002').age).to be_nil # Birthday in the future
+      expect(described_class.new('030320-5006').age).to eq 2
+      expect(described_class.new('110952-3113').age).to eq 69
+      expect(described_class.new('211164-2234').age).to eq 57
+    end
+
+    it 'is nil for invalid numbers' do
+      expect(described_class.new('251379-4001').age).to be_nil # invalid month
+      expect(described_class.new('300279-4001').age).to be_nil # invalid day
+      expect(described_class.new('asdf').age).to be_nil
+      expect(described_class.new('1234567890').age).to be_nil
+      expect(described_class.new('0000000000000').age).to be_nil
+      expect(described_class.new('000000-0000').age).to be_nil
+      expect(described_class.new('').age).to be_nil
+      expect(described_class.new(1234567890).age).to be_nil
+      expect(described_class.new(:really_bad_input_value).age).to be_nil
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns the number normalized regardless of wether its valid' do
+      expect(described_class.new('251.379.4001').to_s).to eq '251379-4001'
+    end
+  end
+end

data/spec/national_identification_number/finnish_spec.rb

@@ -3,58 +3,126 @@ require 'resident'
 
 include NationalIdentificationNumber
 
-describe Finnish, 'valid?' do
-
-  it "should recognize valid numbers" do
-    Finnish.new('311280-999J').should be_valid
-    Finnish.new('131052-308T').should be_valid
-    Finnish.new('290164-862u').should be_valid
-    Finnish.new('270368A172X').should be_valid
-    Finnish.new('310145A586a').should be_valid
-    Finnish.new('080266+183P').should be_valid
-    Finnish.new('290248+145c').should be_valid
+describe Finnish do
+  describe '#valid?' do
+    it "recognizes valid numbers" do
+      expect( Finnish.new('311280-999J') ).to be_valid
+      expect( Finnish.new('131052-308T') ).to be_valid
+      expect( Finnish.new('290164-862u') ).to be_valid
+      expect( Finnish.new('270368A172X') ).to be_valid
+      expect( Finnish.new('310145A586a') ).to be_valid
+      expect( Finnish.new('080266+183P') ).to be_valid
+      expect( Finnish.new('290248+145c') ).to be_valid
+    end
+
+    it "recognizes invalid numbers" do
+      expect( Finnish.new('671301A172V') ).to_not be_valid # valid checksum, invalid month
+      expect( Finnish.new('830231A172M') ).to_not be_valid # valid checksum, invalid day
+      expect( Finnish.new('311180-999J') ).to_not be_valid
+      expect( Finnish.new('131052-308S') ).to_not be_valid
+      expect( Finnish.new('290164X862U') ).to_not be_valid
+      expect( Finnish.new('670368A172X') ).to_not be_valid
+      expect( Finnish.new('310145--586A') ).to_not be_valid
+      expect( Finnish.new('asdf') ).to_not be_valid
+      expect( Finnish.new('1234567890') ).to_not be_valid
+      expect( Finnish.new('0000000000000') ).to_not be_valid
+      expect( Finnish.new('000000-0000') ).to_not be_valid
+      expect( Finnish.new('') ).to_not be_valid
+      expect( Finnish.new(1234567890) ).to_not be_valid
+      expect( Finnish.new(:really_bad_input_value) ).to_not be_valid
+    end
   end
 
-  it "should recognize invalid numbers" do
-    Finnish.new('671301A172V').should_not be_valid # valid checksum, invalid month
-    Finnish.new('830231A172M').should_not be_valid # valid checksum, invalid day
-    Finnish.new('311180-999J').should_not be_valid
-    Finnish.new('131052-308S').should_not be_valid
-    Finnish.new('290164X862U').should_not be_valid
-    Finnish.new('670368A172X').should_not be_valid
-    Finnish.new('310145--586A').should_not be_valid
-    Finnish.new('asdf').should_not be_valid
-    Finnish.new('1234567890').should_not be_valid
-    Finnish.new('0000000000000').should_not be_valid
-    Finnish.new('000000-0000').should_not be_valid
-    Finnish.new('').should_not be_valid
-    Finnish.new(1234567890).should_not be_valid
-    Finnish.new(:really_bad_input_value).should_not be_valid
+  describe 'sanitize' do
+    context 'valid numbers' do
+      it 'is the formatted number' do
+        expect(Finnish.new('311280-999J').sanitize).to eq '311280-999J'
+        expect(Finnish.new('131052-308T').sanitize).to eq '131052-308T'
+        expect(Finnish.new('290164-862u').sanitize).to eq '290164-862U'
+        expect(Finnish.new('270368A172X').sanitize).to eq '270368A172X'
+        expect(Finnish.new('310145A586a').sanitize).to eq '310145A586A'
+        expect(Finnish.new('080266+183P').sanitize).to eq '080266+183P'
+        expect(Finnish.new('290248+145c').sanitize).to eq '290248+145C'
+      end
+    end
+
+    context 'invalid numbers' do
+      it 'is nil' do
+        expect(Finnish.new('671301A172V').sanitize).to be nil
+        expect(Finnish.new('830231A172M').sanitize).to be nil
+        expect(Finnish.new('311180-999J').sanitize).to be nil
+        expect(Finnish.new('131052-308S').sanitize).to be nil
+        expect(Finnish.new('290164X862U').sanitize).to be nil
+        expect(Finnish.new('670368A172X').sanitize).to be nil
+        expect(Finnish.new('310145--586A').sanitize).to be nil
+        expect(Finnish.new('asdf').sanitize).to be nil
+        expect(Finnish.new('1234567890').sanitize).to be nil
+        expect(Finnish.new('0000000000000').sanitize).to be nil
+        expect(Finnish.new('000000-0000').sanitize).to be nil
+        expect(Finnish.new('').sanitize).to be nil
+        expect(Finnish.new(1234567890).sanitize).to be nil
+        expect(Finnish.new(:really_bad_input_value).sanitize).to be nil
+      end
+    end
   end
 
-end
+  describe 'age' do
 
-describe Finnish, 'to_s' do
+    before do
+      Timecop.freeze Date.parse('2014-05-20')
+    end
 
-  it "should repair missing dashes, even if the number is invalid" do
-    Finnish.new('311280999K').to_s.should == '311280-999K'
-  end
+    it "recognizes valid numbers" do
+      expect( Finnish.new('230118-999H').age ).to eq 96
+      expect( Finnish.new('311280-999J').age ).to eq 33
+      expect( Finnish.new('131052-308T').age ).to eq 61
+      expect( Finnish.new('290164-862u').age ).to eq 50
+      expect( Finnish.new('270368A172X').age ).to be_nil # Birthday in the future
+      expect( Finnish.new('310145A586a').age ).to be_nil # Birthday in the future
+      expect( Finnish.new('080266+183P').age ).to eq 148
+      expect( Finnish.new('290248+145c').age ).to eq 166
+    end
 
-  it "should return the number normalized if the number is valid" do
-    Finnish.new('311280999J').to_s.should == '311280-999J'
-    Finnish.new('270368A172X  ').to_s.should == '270368A172X'
-    Finnish.new('xx270368A172X  ').to_s.should == '270368A172X'
-    Finnish.new('xxx270368A172Xt  ').to_s.should == '270368A172X'
-    Finnish.new('\t050126-1853').to_s.should == '050126-1853'
+    it "is nil for invalid numbers" do
+      expect( Finnish.new('671301A172V').age ).to be_nil
+      expect( Finnish.new('830231A172M').age ).to be_nil
+      expect( Finnish.new('311180-999J').age ).to be_nil
+      expect( Finnish.new('131052-308S').age ).to be_nil
+      expect( Finnish.new('290164X862U').age ).to be_nil
+      expect( Finnish.new('670368A172X').age ).to be_nil
+      expect( Finnish.new('310145--586A').age ).to be_nil
+      expect( Finnish.new('asdf').age ).to be_nil
+      expect( Finnish.new('1234567890').age ).to be_nil
+      expect( Finnish.new('0000000000000').age ).to be_nil
+      expect( Finnish.new('000000-0000').age ).to be_nil
+      expect( Finnish.new('').age ).to be_nil
+      expect( Finnish.new(1234567890).age ).to be_nil
+      expect( Finnish.new(:really_bad_input_value).age ).to be_nil
+    end
   end
 
-  it "should always be injection safe, valid or not" do
-    Finnish.new(%Q{270368"A172   \tX}).to_s.should == '270368A172X'
-    Finnish.new(%Q{270368"A172\tX\n\n}).to_s.should == '270368A172X'
-    Finnish.new(%Q{270368"A172X}).to_s.should == '270368A172X'
-    Finnish.new(%Q{270368A<172X}).to_s.should == '270368A172X'
-    Finnish.new(%Q{270368A'172X}).to_s.should == '270368A172X'
-    Finnish.new(%Q{270368A>172X}).to_s.should == '270368A172X'
-  end
+  describe '#to_s' do
 
-end
+    it "repairs missing dashes, even if the number is invalid" do
+      expect( Finnish.new('311280999K').to_s ).to eq '311280-999K'
+    end
+
+    it "returns the number normalized if the number is valid" do
+      expect( Finnish.new('311280999J').to_s ).to eq '311280-999J'
+      expect( Finnish.new('270368A172X  ').to_s ).to eq '270368A172X'
+      expect( Finnish.new('xx270368A172X  ').to_s ).to eq '270368A172X'
+      expect( Finnish.new('xxx270368A172Xt  ').to_s ).to eq '270368A172X'
+      expect( Finnish.new('\t050126-1853').to_s ).to eq '050126-1853'
+    end
+
+    it "is always injection safe, valid or not" do
+      expect( Finnish.new(%Q{270368"A172   \tX}).to_s ).to eq '270368A172X'
+      expect( Finnish.new(%Q{270368"A172\tX\n\n}).to_s ).to eq '270368A172X'
+      expect( Finnish.new(%Q{270368"A172X}).to_s ).to eq '270368A172X'
+      expect( Finnish.new(%Q{270368A<172X}).to_s ).to eq '270368A172X'
+      expect( Finnish.new(%Q{270368A'172X}).to_s ).to eq '270368A172X'
+      expect( Finnish.new(%Q{270368A>172X}).to_s ).to eq '270368A172X'
+    end
+
+  end
+end

data/spec/national_identification_number/norwegian_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'resident'
+
+describe NationalIdentificationNumber::Norwegian do
+  describe '#valid?' do
+    it 'recognizes valid numbers' do
+      expect(described_class.new('11077941012')).to be_valid
+    end
+
+    it 'recognizes invalid numbers' do
+      expect(described_class.new('671301A172V')).not_to be_valid # valid checksum, invalid month
+      expect(described_class.new('830231A172M')).not_to be_valid # valid checksum, invalid day
+      expect(described_class.new('11077941010')).not_to be_valid
+      expect(described_class.new('670368A172X')).not_to be_valid
+      expect(described_class.new('310145--586A')).not_to be_valid
+      expect(described_class.new('asdf')).not_to be_valid
+      expect(described_class.new('1234567890')).not_to be_valid
+      expect(described_class.new('0000000000000')).not_to be_valid
+      expect(described_class.new('000000-0000')).not_to be_valid
+      expect(described_class.new('')).not_to be_valid
+      expect(described_class.new(1234567890)).not_to be_valid
+      expect(described_class.new(:really_bad_input_value)).not_to be_valid
+    end
+  end
+
+  describe 'sanitize' do
+    context 'with valid numbers' do
+      it 'is the formatted number' do
+        expect(described_class.new('11077941012').sanitize).to eq '11077941012'
+        expect(described_class.new('11.07.79.410.12').sanitize).to eq '11077941012'
+        expect(described_class.new('11 07 79 41012').sanitize).to eq '11077941012'
+      end
+    end
+
+    context 'with invalid numbers' do
+      it 'is nil' do
+        expect(described_class.new('11077941010').sanitize).to be_nil
+        expect(described_class.new('671301A172V').sanitize).to be_nil
+        expect(described_class.new('830231A172M').sanitize).to be_nil
+        expect(described_class.new('311180-999J').sanitize).to be_nil
+        expect(described_class.new('131052-308S').sanitize).to be_nil
+        expect(described_class.new('290164X862U').sanitize).to be_nil
+        expect(described_class.new('670368A172X').sanitize).to be_nil
+        expect(described_class.new('310145--586A').sanitize).to be_nil
+        expect(described_class.new('asdf').sanitize).to be_nil
+        expect(described_class.new('1234567890').sanitize).to be_nil
+        expect(described_class.new('0000000000000').sanitize).to be_nil
+        expect(described_class.new('000000-0000').sanitize).to be_nil
+        expect(described_class.new('').sanitize).to be_nil
+        expect(described_class.new(1234567890).sanitize).to be_nil
+        expect(described_class.new(:really_bad_input_value).sanitize).to be_nil
+      end
+    end
+  end
+
+  describe 'age' do
+    before do
+      Timecop.freeze Date.parse('2022-03-04')
+    end
+
+    it 'recognizes valid numbers' do
+      expect(described_class.new('11077941012').age).to eq 42
+      expect(described_class.new('01010010000').age).to eq 122
+      expect(described_class.new('11077950020').age).to be_nil # Birthday in the future
+      expect(described_class.new('03032050068').age).to eq 2
+      expect(described_class.new('11095231138').age).to eq 69
+      expect(described_class.new('21116422341').age).to eq 57
+    end
+
+    it 'is nil for invalid numbers' do
+      expect(described_class.new('671301A172V').age).to be_nil
+      expect(described_class.new('830231A172M').age).to be_nil
+      expect(described_class.new('311180-999J').age).to be_nil
+      expect(described_class.new('131052-308S').age).to be_nil
+      expect(described_class.new('290164X862U').age).to be_nil
+      expect(described_class.new('670368A172X').age).to be_nil
+      expect(described_class.new('310145--586A').age).to be_nil
+      expect(described_class.new('asdf').age).to be_nil
+      expect(described_class.new('1234567890').age).to be_nil
+      expect(described_class.new('0000000000000').age).to be_nil
+      expect(described_class.new('000000-0000').age).to be_nil
+      expect(described_class.new('').age).to be_nil
+      expect(described_class.new(1234567890).age).to be_nil
+      expect(described_class.new(:really_bad_input_value).age).to be_nil
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns the number normalized regardless of wether it is valid' do
+      expect(described_class.new('311280999J').to_s).to eq '311280999'
+      expect(described_class.new('27..036.8A172X  ').to_s).to eq '270368172'
+      expect(described_class.new('xx270368A172X  ').to_s).to eq '270368172'
+      expect(described_class.new('xxx270368A172Xt  ').to_s).to eq '270368172'
+      expect(described_class.new('\t050126-1853').to_s).to eq '0501261853'
+    end
+  end
+end

data/spec/national_identification_number/swedish_spec.rb

@@ -1,147 +1,218 @@
 require 'spec_helper'
-require 'resident'
+require 'national_identification_number/swedish'
 
 include NationalIdentificationNumber
 
 describe Swedish, '.generate' do
 
-  it "should generate valid numbers" do
-    50.times { Swedish.new(Swedish.generate).should be_valid } # I know, it feels weird :)
+  it "generates valid numbers" do
+    50.times { expect( Swedish.new(Swedish.generate) ).to be_valid } # I know, it feels weird :)
   end
 
-end
-
-describe Swedish, 'valid?' do
-
-  it "should recognize valid numbers" do
-    Swedish.new("19180123-2669").should be_valid
-    Swedish.new("00180123-2669").should be_valid
-    Swedish.new("000180123-2669").should be_valid
-    Swedish.new("050126-1853").should be_valid
-    Swedish.new("0asdfghj501261853").should be_valid
-    Swedish.new("050112-2451").should be_valid
-    Swedish.new("450202-6950").should be_valid
-    Swedish.new("19450202-6950").should be_valid
-  end
-
-  it "should recognize invalid numbers" do
-    Swedish.new("991301-1236").should_not be_valid # valid checksum, invalid month
-    Swedish.new("830231-5554").should_not be_valid # valid checksum, invalid day
-    Swedish.new("050112--2451").should_not be_valid
-    Swedish.new("123456-1239").should_not be_valid
-    Swedish.new("180123-2668").should_not be_valid
-    Swedish.new("150D1261853").should_not be_valid
-    Swedish.new("750112-2451").should_not be_valid
-    Swedish.new("123").should_not be_valid
-    Swedish.new("000000-0000").should_not be_valid
-    Swedish.new("0000000000").should_not be_valid
-    Swedish.new("asdfghj").should_not be_valid
-    Swedish.new("").should_not be_valid
-    Swedish.new(12345678).should_not be_valid
-    Swedish.new(:really_bad_input).should_not be_valid
-  end
-
-end
-
-describe Swedish, 'to_s' do
-
-  it "should repair missing dashes and a superfluous century, even if the number is invalid" do
-    Swedish.new('1234561239').to_s.should == '123456-1239'
-    Swedish.new('123456-1239').to_s.should == '123456-1239'
-    Swedish.new("191234561239").to_s.should == '123456-1239'
-    Swedish.new("19123456-1239").to_s.should == '123456-1239'
-  end
-
-  it "should return the number normalized if the number is valid" do
-    Swedish.new('0501261853').to_s.should == '050126-1853'
-    Swedish.new('050126-1853').to_s.should == '050126-1853'
-    Swedish.new("190501261853").to_s.should == '050126-1853'
-    Swedish.new("19050126-1853").to_s.should == '050126-1853'
-    Swedish.new("19050126-185d3").to_s.should == '050126-1853'
-    Swedish.new("19050126-185d3\n").to_s.should == '050126-1853'
-  end
+  describe '#valid?' do
+
+    it "recognizes valid numbers" do
+      expect( Swedish.new("19180123-2669") ).to be_valid
+      expect( Swedish.new("00180123-2669") ).to be_valid
+      expect( Swedish.new("000180123-2669") ).to be_valid
+      expect( Swedish.new("050126-1853") ).to be_valid
+      expect( Swedish.new("0asdfghj501261853") ).to be_valid
+      expect( Swedish.new("050112-2451") ).to be_valid
+      expect( Swedish.new("450202-6950") ).to be_valid
+      expect( Swedish.new("19450202-6950") ).to be_valid
+    end
+
+    it "recognizes invalid numbers" do
+      expect( Swedish.new("991301-1236") ).to_not be_valid # valid checksum, invalid month
+      expect( Swedish.new("830231-5554") ).to_not be_valid # valid checksum, invalid day
+      expect( Swedish.new("050112--2451") ).to_not be_valid
+      expect( Swedish.new("123456-1239") ).to_not be_valid
+      expect( Swedish.new("180123-2668") ).to_not be_valid
+      expect( Swedish.new("150D1261853") ).to_not be_valid
+      expect( Swedish.new("750112-2451") ).to_not be_valid
+      expect( Swedish.new("123") ).to_not be_valid
+      expect( Swedish.new("000000-0000") ).to_not be_valid
+      expect( Swedish.new("0000000000") ).to_not be_valid
+      expect( Swedish.new("asdfghj") ).to_not be_valid
+      expect( Swedish.new("") ).to_not be_valid
+      expect( Swedish.new(12345678) ).to_not be_valid
+      expect( Swedish.new(:really_bad_input) ).to_not be_valid
+    end
 
-  it "should always be injection safe, valid or not" do
-    Swedish.new("    180 123  -  2669 \n\n\t").to_s.should == '180123-2669'
-    Swedish.new("    180 123  -  2669 \n").to_s.should == '180123-2669'
-    Swedish.new(%Q{180123-"2669}).to_s.should == '180123-2669'
-    Swedish.new(%Q{180123-<2669}).to_s.should == '180123-2669'
-    Swedish.new(%Q{1801D23-'2669}).to_s.should == '180123-2669'
-    Swedish.new(%Q{180s123->2669}).to_s.should == '180123-2669'
-    Swedish.new(%Q{19180s123->2669}).to_s.should == '180123-2669'
   end
 
-end
-
-describe Swedish, 'date' do # For testing only, no public API
-
-  it "should recognize babies born today" do
-    today = Date.today.strftime("%y%m%d")
-    born_today = Swedish.new("#{today}-000#{Swedish.luhn_algorithm("#{today}000")}")
-    born_today.should be_valid
-    born_today.date.should == Date.today
+  describe 'sanitize' do
+    context 'invalid numbers' do
+      it 'is nil' do
+        expect(Swedish.new('991301-1236').sanitize).to be nil # valid checksum, invalid month
+        expect(Swedish.new('830231-5554').sanitize).to be nil # valid checksum, invalid day
+        expect(Swedish.new('050112--2451').sanitize).to be nil
+        expect(Swedish.new('123456-1239').sanitize).to be nil
+        expect(Swedish.new('180123-2668').sanitize).to be nil
+        expect(Swedish.new('150D1261853').sanitize).to be nil
+        expect(Swedish.new('750112-2451').sanitize).to be nil
+        expect(Swedish.new('123').sanitize).to be nil
+        expect(Swedish.new('000000-0000').sanitize).to be nil
+        expect(Swedish.new('0000000000').sanitize).to be nil
+        expect(Swedish.new('asdfghj').sanitize).to be nil
+        expect(Swedish.new('').sanitize).to be nil
+        expect(Swedish.new(12345678).sanitize).to be nil
+        expect(Swedish.new(:really_bad_input).sanitize).to be nil
+      end
+    end
+
+    context 'valid numbers' do
+      it 'is the sanitize dnumber' do
+        expect(Swedish.new('19180123-2669').sanitize).to eq '180123-2669'
+        expect(Swedish.new('00180123-2669').sanitize).to eq '180123-2669'
+        expect(Swedish.new('000180123-2669').sanitize).to eq '180123-2669'
+        expect(Swedish.new('050126-1853').sanitize).to eq '050126-1853'
+        expect(Swedish.new('0asdfghj501261853').sanitize).to eq '050126-1853'
+        expect(Swedish.new('050112-2451').sanitize).to eq '050112-2451'
+        expect(Swedish.new('450202-6950').sanitize).to eq '450202-6950'
+        expect(Swedish.new('19450202-6950').sanitize).to eq '450202-6950'
+      end
+    end
   end
 
-  it "should recognize babies born yesterday" do
-    today = (Date.today - 1).strftime("%y%m%d")
-    born_yesterday = Swedish.new("#{today}-000#{Swedish.luhn_algorithm("#{today}000")}")
-    born_yesterday.should be_valid
-    born_yesterday.date.should == (Date.today - 1)
-  end
+  describe '#age' do
+
+    before do
+      Timecop.freeze Date.parse('2014-01-20')
+    end
+
+    it "knows the age" do
+      expect( Swedish.new("19180123-2669").age ).to eq 95
+      expect( Swedish.new("19180123-2669").age ).to eq 95
+      expect( Swedish.new("00180123-2669").age ).to eq 95
+      expect( Swedish.new("000180123-2669").age ).to eq 95
+      expect( Swedish.new("050126-1853").age ).to eq 8
+      expect( Swedish.new("0asdfghj501261853").age ).to eq 8
+      expect( Swedish.new("050112-2451").age ).to eq 9
+      expect( Swedish.new("450202-6950").age ).to eq 68
+      expect( Swedish.new("19450202-6950").age ).to eq 68
+    end
+
+    it "is nil for invalid numbers" do
+      expect( Swedish.new("991301-1236").age ).to be_nil
+      expect( Swedish.new("830231-5554").age ).to be_nil
+      expect( Swedish.new("050112--2451").age ).to be_nil
+      expect( Swedish.new("123456-1239").age ).to be_nil
+      expect( Swedish.new("180123-2668").age ).to be_nil
+      expect( Swedish.new("150D1261853").age ).to be_nil
+      expect( Swedish.new("750112-2451").age ).to be_nil
+      expect( Swedish.new("123").age ).to be_nil
+      expect( Swedish.new("000000-0000").age ).to be_nil
+      expect( Swedish.new("0000000000").age ).to be_nil
+      expect( Swedish.new("asdfghj").age ).to be_nil
+      expect( Swedish.new("").age ).to be_nil
+      expect( Swedish.new(12345678).age ).to be_nil
+      expect( Swedish.new(:really_bad_input).age ).to be_nil
+    end
 
-  it "should recognize people born in the year 2000" do
-    beginning_of_year = Swedish.new("000101-0008")
-    beginning_of_year.should be_valid
-    beginning_of_year.date.should == Date.new(2000, 1, 1)
-    leap_year = Swedish.new("000229-0005") # 2000 was a leap year, 1900 not
-    leap_year.should be_valid
-    leap_year.date.should == Date.new(2000, 2, 29)
-    end_of_year = Swedish.new("001231-0009")
-    end_of_year.should be_valid
-    end_of_year.date.should == Date.new(2000, 12, 31)
   end
 
-  it "should recognize people born in the year 1999" do
-    beginning_of_year = Swedish.new("990101-0000")
-    beginning_of_year.should be_valid
-    beginning_of_year.date.should == Date.new(1999, 1, 1)
-    end_of_year = Swedish.new("991231-0001")
-    end_of_year.should be_valid
-    end_of_year.date.should == Date.new(1999, 12, 31)
-  end
+  describe '#to_s' do
+
+    it "repair missing dashes and a superfluous century, even if the number is invalid" do
+      expect( Swedish.new('1234561239').to_s ).to eq '123456-1239'
+      expect( Swedish.new('123456-1239').to_s ).to eq '123456-1239'
+      expect( Swedish.new("191234561239").to_s ).to eq '123456-1239'
+      expect( Swedish.new("19123456-1239").to_s ).to eq '123456-1239'
+    end
+
+    it "return the number normalized if the number is valid" do
+      expect( Swedish.new('0501261853').to_s ).to eq '050126-1853'
+      expect( Swedish.new('050126-1853').to_s ).to eq '050126-1853'
+      expect( Swedish.new('0asdfghj501261853').to_s).to eq '050126-1853'
+      expect( Swedish.new("190501261853").to_s ).to eq '050126-1853'
+      expect( Swedish.new("19050126-1853").to_s ).to eq '050126-1853'
+      expect( Swedish.new("19050126-185d3").to_s ).to eq '050126-1853'
+      expect( Swedish.new("19050126-185d3\n").to_s ).to eq '050126-1853'
+    end
+
+    it "always be injection safe, valid or not" do
+      expect( Swedish.new("    180 123  -  2669 \n\n\t").to_s ).to eq '180123-2669'
+      expect( Swedish.new("    180 123  -  2669 \n").to_s ).to eq '180123-2669'
+      expect( Swedish.new(%Q{180123-"2669}).to_s ).to eq '180123-2669'
+      expect( Swedish.new(%Q{180123-<2669}).to_s ).to eq '180123-2669'
+      expect( Swedish.new(%Q{1801D23-'2669}).to_s ).to eq '180123-2669'
+      expect( Swedish.new(%Q{180s123->2669}).to_s ).to eq '180123-2669'
+      expect( Swedish.new(%Q{19180s123->2669}).to_s ).to eq '180123-2669'
+    end
 
-  it "should recognize all other people less than 100 years old" do
-    will_turn_99_this_year = Date.new(Date.today.year - 99, 12, 31).strftime("%y%m%d")
-    soon_99 = Swedish.new("#{will_turn_99_this_year}-000#{Swedish.luhn_algorithm("#{will_turn_99_this_year}000")}")
-    soon_99.should be_valid
-    soon_99.date.should == Date.new(Date.today.year - 99, 12, 31)
-    turned_99_this_year = Date.new(Date.today.year - 99, 1, 1).strftime("%y%m%d")
-    already_99 = Swedish.new("#{turned_99_this_year}-000#{Swedish.luhn_algorithm("#{turned_99_this_year}000")}")
-    already_99.should be_valid
-    already_99.date.should == Date.new(Date.today.year - 99, 1, 1)
   end
 
-  it "should recognize people that turn 100 years in this year" do
-    will_turn_100_this_year = Date.new(Date.today.year - 100, 12, 31).strftime("%y%m%d")
-    soon_100 = Swedish.new("#{will_turn_100_this_year}+000#{Swedish.luhn_algorithm("#{will_turn_100_this_year}000")}")
-    soon_100.should be_valid
-    soon_100.date.should == Date.new(Date.today.year - 100, 12, 31)
-    turned_100_this_year = Date.new(Date.today.year - 100, 1, 1).strftime("%y%m%d")
-    already_100 = Swedish.new("#{turned_100_this_year}+000#{Swedish.luhn_algorithm("#{turned_100_this_year}000")}")
-    already_100.should be_valid
-    already_100.date.should == Date.new(Date.today.year - 100, 1, 1)
+  describe '#date' do
+
+    it "recognizes babies born today" do
+      today = Date.today.strftime("%y%m%d")
+      born_today = Swedish.new("#{today}-000#{Swedish.luhn_algorithm("#{today}000")}")
+      expect( born_today ).to be_valid
+      expect( born_today.date).to eq Date.today
+    end
+
+    it "recognizes babies born yesterday" do
+      today = (Date.today - 1).strftime("%y%m%d")
+      born_yesterday = Swedish.new("#{today}-000#{Swedish.luhn_algorithm("#{today}000")}")
+      expect( born_yesterday ).to be_valid
+      expect( born_yesterday.date ).to eq (Date.today - 1)
+    end
+
+    it "recognizes people born in the year 2000" do
+      beginning_of_year = Swedish.new("000101-0008")
+      expect( beginning_of_year ).to be_valid
+      expect( beginning_of_year.date ).to eq Date.new(2000, 1, 1)
+      leap_year = Swedish.new("000229-0005") # 2000 was a leap year, 1900 not
+      expect( leap_year ).to be_valid
+      expect( leap_year.date ).to eq Date.new(2000, 2, 29)
+      end_of_year = Swedish.new("001231-0009")
+      expect( end_of_year ).to be_valid
+      expect( end_of_year.date ).to eq Date.new(2000, 12, 31)
+    end
+
+    it "recognizes people born in the year 1999" do
+      beginning_of_year = Swedish.new("990101-0000")
+      expect( beginning_of_year ).to be_valid
+      expect( beginning_of_year.date ).to eq Date.new(1999, 1, 1)
+      end_of_year = Swedish.new("991231-0001")
+      expect( end_of_year ).to be_valid
+      expect( end_of_year.date ).to eq Date.new(1999, 12, 31)
+    end
+
+    it "recognizes all other people less than 100 years old" do
+      will_turn_99_this_year = Date.new(Date.today.year - 99, 12, 31).strftime("%y%m%d")
+      soon_99 = Swedish.new("#{will_turn_99_this_year}-000#{Swedish.luhn_algorithm("#{will_turn_99_this_year}000")}")
+      expect( soon_99 ).to be_valid
+      expect( soon_99.date ).to eq Date.new(Date.today.year - 99, 12, 31)
+      turned_99_this_year = Date.new(Date.today.year - 99, 1, 1).strftime("%y%m%d")
+      already_99 = Swedish.new("#{turned_99_this_year}-000#{Swedish.luhn_algorithm("#{turned_99_this_year}000")}")
+      expect( already_99 ).to be_valid
+      expect( already_99.date ).to eq Date.new(Date.today.year - 99, 1, 1)
+    end
+
+    it "recognizes people that turn 100 years in this year" do
+      will_turn_100_this_year = Date.new(Date.today.year - 100, 12, 31).strftime("%y%m%d")
+      soon_100 = Swedish.new("#{will_turn_100_this_year}+000#{Swedish.luhn_algorithm("#{will_turn_100_this_year}000")}")
+      expect( soon_100 ).to be_valid
+      expect( soon_100.date ).to eq Date.new(Date.today.year - 100, 12, 31)
+      turned_100_this_year = Date.new(Date.today.year - 100, 1, 1).strftime("%y%m%d")
+      already_100 = Swedish.new("#{turned_100_this_year}+000#{Swedish.luhn_algorithm("#{turned_100_this_year}000")}")
+      expect( already_100 ).to be_valid
+      expect( already_100.date ).to eq Date.new(Date.today.year - 100, 1, 1)
+    end
+
+    it "recognizes people older than 100 years born after 1900" do
+      normal = Swedish.new("010101+0007")
+      expect( normal ).to be_valid
+      expect( normal.date ).to eq Date.new(1901, 1, 1)
+    end
+
+    it "recognizes people older than 100 years born before 1900" do
+      normal = Swedish.new("991231+0001")
+      expect( normal ).to be_valid
+      expect( normal.date ).to eq Date.new(1899, 12, 31)
+    end
   end
 
-  it "should recognize people older than 100 years born after 1900" do
-    normal = Swedish.new("010101+0007")
-    normal.should be_valid
-    normal.date.should == Date.new(1901, 1, 1)
-  end
-
-  it "should recognize people older than 100 years born before 1900" do
-    normal = Swedish.new("991231+0001")
-    normal.should be_valid
-    normal.date.should == Date.new(1899, 12, 31)
-  end
-
-end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'timecop'
+require 'resident'
+
+RSpec.configure do |config|
+
+  config.after(:each) do
+    # Preventing the mistake of forgetting to return to present time
+    # See http://www.51degrees.net/2010/01/18/global-after-blocks-or-keeping-timcop-happy.html
+    Timecop.return
+  end
+
+end

metadata

@@ -1,98 +1,86 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: resident
-version: !ruby/object:Gem::Version 
-  hash: 13
-  prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 9
-  version: 0.0.9
+version: !ruby/object:Gem::Version
+  version: 0.0.12
 platform: ruby
-authors: 
+authors:
 - Bukowskis
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-12-19 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2022-03-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email: 
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- README.rdoc
+extra_rdoc_files: []
+files:
 - MIT-LICENSE
-files: 
+- README.md
+- lib/national_identification_number.rb
 - lib/national_identification_number/base.rb
+- lib/national_identification_number/danish.rb
 - lib/national_identification_number/finnish.rb
+- lib/national_identification_number/norwegian.rb
 - lib/national_identification_number/swedish.rb
-- lib/national_identification_number.rb
 - lib/resident.rb
-- MIT-LICENSE
-- README.rdoc
-- .gemtest
 - spec/national_identification_number/base_spec.rb
+- spec/national_identification_number/danish_spec.rb
 - spec/national_identification_number/finnish_spec.rb
+- spec/national_identification_number/norwegian_spec.rb
 - spec/national_identification_number/swedish_spec.rb
-has_rdoc: true
+- spec/spec_helper.rb
 homepage: http://github.com/bukowskis/national_identification_number/
-licenses: 
+licenses:
 - MIT-LICENSE
+metadata: {}
 post_install_message: 
-rdoc_options: 
-- --main
-- README.rdoc
-- --charset=UTF-8
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 57
-      segments: 
-      - 1
-      - 8
-      - 7
-      version: 1.8.7
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.5.3
+rubygems_version: 3.0.3.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Validate National Identification Numbers.
-test_files: 
-- spec/national_identification_number/base_spec.rb
-- spec/national_identification_number/finnish_spec.rb
-- spec/national_identification_number/swedish_spec.rb
+test_files: []