resident 0.0.9 → 0.0.10

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d93a0b9f267f96e0a266917baa460796b855613a
+  data.tar.gz: b3fe8f7e4392247dd2f2184562a7c347ae8d2e62
+SHA512:
+  metadata.gz: 206a9d30f1f4d83d75e007b192fa56fe682750fc7c1aaf9fc5b092eeb3f54c600e43c0f0ba7872637cfc523b451348e69d2cca941de579affc114ce6f7dafe77
+  data.tar.gz: a1e8a71fdbcc5b007ddf25e61e449254da96cfcf9f78452111bc4ec697db99f2ce2a700ed708efdba38ee4933aee8b4368a7b222f1767cb1f1509ba397308ee0

data/{README.rdoc → README.md}

@@ -1,4 +1,4 @@
-= 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.
@@ -6,13 +6,13 @@ This gem currently only supports Swedish (Personnummer) and Finnish (Henkilöasi
 
 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
+## 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>to_s</tt>, and <tt>age</tt> like so:
 
     require 'resident'
 
@@ -20,6 +20,7 @@ Really, you can just use <tt>valid?</tt> and <tt>to_s</tt> like so:
 
     number.valid?  #=> true
     number.to_s    #=> "050126-1853"
+    number.age     #=> 9
 
 Please have a look at the specs to see how the national identification numbers of various countries are handled.
 
@@ -27,7 +28,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 +37,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-2014 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

data/lib/national_identification_number/base.rb

@@ -17,8 +17,19 @@ module NationalIdentificationNumber
       @number
     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

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/swedish.rb

@@ -54,7 +54,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

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/finnish_spec.rb

@@ -3,58 +3,95 @@ 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
-  end
+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
 
-  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
   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
 
+    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/swedish_spec.rb

@@ -1,147 +1,183 @@
 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 '#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
 
-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
+  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 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
 
-  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
-  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
-
-  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
-
-  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)
-  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("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 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)
+  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
 
 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,111 @@
---- !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.10
 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: 2014-06-24 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
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-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: rb-fsevent
+  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'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  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'
 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/finnish.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/finnish_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: 2.2.2
 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: []