resident 0.0.9

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,57 @@
+= 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).
+
+== Installation
+
+    gem install resident
+
+== Usage
+
+Really, you can just use <tt>valid?</tt> and <tt>to_s</tt> like so:
+
+    require 'resident'
+
+    number = NationalIdentificationNumber::Swedish.new('0501261853')
+
+    number.valid?  #=> true
+    number.to_s    #=> "050126-1853"
+
+Please have a look at the specs to see how the national identification numbers of various countries are handled.
+
+An example of robustness:
+
+    NationalIdentificationNumber::Swedish.new("19050126-185d3\n").to_s => "050126-1853"
+
+== License
+
+Some marked parts of the code are inspired or taken from MIT licensed code of
+
+* Peter Hellberg https://github.com/c7/personnummer/blob/master/lib/personnummer.rb
+* Henrik Nyh http://henrik.nyh.se
+
+Other than that you got:
+
+Copyright (c) 2011 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/national_identification_number/base.rb

@@ -0,0 +1,31 @@
+require 'date'
+
+module NationalIdentificationNumber
+  class Base
+
+    def initialize(number)
+      @number = number
+      repair
+      validate
+    end
+
+    def valid?
+      !!@valid
+    end
+
+    def to_s
+      @number
+    end
+
+    protected
+
+    def repair
+      @number = @number.to_s.upcase.gsub(/\s/, '')
+    end
+
+    def validate
+      raise 'You need to implement at least this method in subclasses.'
+    end
+
+  end
+end

data/lib/national_identification_number/finnish.rb

@@ -0,0 +1,53 @@
+require 'national_identification_number/base'
+
+module NationalIdentificationNumber
+  class Finnish < Base
+
+    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})/)
+        @number = "#{$1}-#{$3}#{$4}"
+      else
+        @number.gsub!(/[^#{CHECKSUMS}\-\+]/, '')
+      end
+    end
+
+    def validate
+      if @number.match(/(\d{2})(\d{2})(\d{2})([\-\+A]{0,1})(\d{3})([#{CHECKSUMS}]{1})/)
+        checksum = self.class.calculate_checksum("#{$1}#{$2}#{$3}#{$5}")
+        if checksum == $6
+
+          day     = $1.to_i
+          month   = $2.to_i
+          year    = $3.to_i
+          divider ||= $4 ||'-'
+          serial  = $5.to_i
+
+          century = case divider
+          when '+' then 1800
+          when 'A' then 2000
+          else          1900
+          end
+
+          begin
+            Date.parse("#{century+year}-#{month}-#{day}")
+            @valid = true
+            @number = ("#{$1}#{$2}#{$3}#{divider}#{$5}#{checksum}")
+          rescue ArgumentError
+          end
+        end
+      end
+    end
+
+    private
+
+    def self.calculate_checksum(number)
+      CHECKSUMS[number.to_i % 31]
+    end
+
+  end
+end

data/lib/national_identification_number/swedish.rb

@@ -0,0 +1,105 @@
+require 'national_identification_number/base'
+
+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)
+    # By Henrik Nyh <http://henrik.nyh.se> 2009-01-29 under the MIT license.
+    def self.generate(date=nil, serial=nil)
+      date ||= Date.new(1900+rand(100), 1+rand(12), 1+rand(28))
+      serial = serial ? serial.to_s : format("%03d", rand(999)+1)  # 001-999
+      date_part = date.strftime('%y%m%d')
+      pnr = [date_part, serial].join
+      digits = []
+      pnr.split('').each_with_index do |n,i|
+        digits << n.to_i * (2 - i % 2)
+      end
+      sum = digits.join.split('').inject(0) {|sum,digit| sum + digit.to_i }
+      checksum = 10 - sum % 10
+      checksum = 0 if checksum == 10
+      "#{date_part}-#{serial}#{checksum}"
+    end
+
+    protected
+
+    def repair
+      super
+      if @number.match(/\A(\d{0}|\d{2})(\d{6})(\-{0,1})(\d{4})\Z/)
+        @number = "#{$2}-#{$4}"
+      else
+        @number.gsub!(/[^\d\-\+]/, '')
+      end
+    end
+
+    def validate
+      if @number.match(/(\d{2})(\d{2})(\d{2})([\-\+]{0,1})(\d{3})(\d{1})/)
+        checksum = self.class.luhn_algorithm("#{$1}#{$2}#{$3}#{$5}")
+        if checksum == $6.to_i
+
+           year    = $1.to_i
+           month   = $2.to_i
+           day     = $3.to_i
+           divider ||= $4 ||'-'
+           serial  = $5.to_i
+
+           today = Date.today
+           if year <= (today.year-2000) && divider == '-'
+             century = 2000
+           elsif year <= (today.year-2000) && divider == '+'
+             century = 1900
+           elsif divider == '+'
+             century = 1800
+           else
+             century = 1900
+           end
+
+           begin
+             @date = Date.parse("#{century+year}-#{month}-#{day}")
+             @valid = true
+             @number = ("#{$1}#{$2}#{$3}#{divider}#{$5}#{checksum}")
+           rescue ArgumentError
+           end
+        end
+      end
+    end
+
+    private
+
+    def self.luhn_algorithm(number)
+      multiplications = []
+      number.split(//).each_with_index do |digit, i|
+        if i % 2 == 0
+          multiplications << digit.to_i*2
+        else
+          multiplications << digit.to_i
+        end
+      end
+      sum = 0
+      multiplications.each do |number|
+        number.to_s.each_byte do |character|
+          sum += character.chr.to_i
+        end
+      end
+      if sum % 10 == 0
+        control_digit = 0
+      else
+        control_digit = (sum / 10 + 1) * 10 - sum
+      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

data/lib/national_identification_number.rb

@@ -0,0 +1,2 @@
+require 'national_identification_number/swedish'
+require 'national_identification_number/finnish'

data/lib/resident.rb

@@ -0,0 +1 @@
+require 'national_identification_number'

data/spec/national_identification_number/base_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'resident'
+
+include NationalIdentificationNumber
+
+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
+
+  it "should instantiate correctly" do
+    TestBaseChild.new('12345').should be_an_instance_of TestBaseChild
+  end
+
+ it "should repair on initialization" do
+   TestBaseChild.new(' 12345abc ').to_s.should == '12345ABC'
+ 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
+
+end
+
+describe Base, 'valid?' do
+
+  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
+
+end
+
+describe Base, 'to_s' do
+
+  it "should return the number" do
+    TestBaseChild.new('12345ABC').to_s.should == '12345ABC'
+  end
+
+end
+
+describe Base, 'repair' do
+
+  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
+
+  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 strip newlines and tabs" do
+    TestBaseChild.new("one\ntwo\tthree\n").to_s.should == 'ONETWOTHREE'
+  end
+
+end

data/spec/national_identification_number/finnish_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+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
+
+  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 Finnish, 'to_s' do
+
+  it "should repair missing dashes, even if the number is invalid" do
+    Finnish.new('311280999K').to_s.should == '311280-999K'
+  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'
+  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
+
+end

data/spec/national_identification_number/swedish_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+require 'resident'
+
+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 :)
+  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
+
+  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
+
+  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

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: resident
+version: !ruby/object:Gem::Version 
+  hash: 13
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 9
+  version: 0.0.9
+platform: ruby
+authors: 
+- Bukowskis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-12-19 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- MIT-LICENSE
+files: 
+- 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
+homepage: http://github.com/bukowskis/national_identification_number/
+licenses: 
+- MIT-LICENSE
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+- --charset=UTF-8
+require_paths: 
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  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 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+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