citizenship 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9e3144972c896bbb5b398689419c22a0a2b1a851
+  data.tar.gz: 5e104377c0d24d3df7eb08f0e9e6cf76f1cdaa61
+SHA512:
+  metadata.gz: a1256fe4db0f000a8620cebbc32a2e7055b01e0c59ce3d1c51f361f2ff3eb67dbe900d0488ffc325dce56ae736db7e079894b51814bac5c2e345570e0328cca0
+  data.tar.gz: 33887abb5376484c9edeba657c8b5bc635ad1d067f3ed6ff7414bf397b939cd660439abf81062b04037483dd37105000bf0608ef0615473b3afe663eaabcb3aa

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rvmrc
+.rspec

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.2
+  - 2.2.0
+  - rbx-2
+script: bundle exec rake test
+notifications:
+  recipients:
+    - s.freire@runtime-revolution.com

data/CHANGELOG

@@ -0,0 +1,10 @@
+1.0.0
+
+  * Public version, published to Rubygems
+  * Updated tests in order to run with recent RSpec
+  * Updated documentation and added this CHANGELOG
+  * Updated gemspec
+
+0.0.1.beta
+
+  * First "internal" version (not tagged)

data/Gemfile

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

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,141 @@
+# Citizenship
+
+[![Gem Version](https://badge.fury.io/rb/citizen.svg)](http://badge.fury.io/rb/citizen)
+[![Build Status](https://travis-ci.org/runtimerevolution/citizenship.svg?branch=master)](https://travis-ci.org/runtimerevolution/citizenship)
+[![Code Climate](https://codeclimate.com/github/runtimerevolution/citizenship/badges/gpa.svg)](https://codeclimate.com/github/runtimerevolution/citizenship)
+[![Dependency Status](https://gemnasium.com/runtimerevolution/citizenship.svg)](https://gemnasium.com/runtimerevolution/citizenship)
+
+Citizenship provides a set of easy validations on personal documents, addresses, bank account numbers and other personal information, of Portuguese citizens or of citizens living in Portugal ;)
+
+It supports validation of:
+
+- NIB (i.e. "banking account number")
+- NIF (i.e. "fiscal number")
+- local phone numbers
+- identification card ('bilhetes de identidade'), were the old id Portuguese id documents. They are no longer issue, but many haven't yet expired, so are still used alongside the Citizen Card.
+- citizen card ('cartão do cidadão'), are the new ID cards currently in use
+- zip code (partial validation)
+- e-mail (well, just because :) )
+
+
+## Installation
+
+Add this line to your Rails application's Gemfile:
+
+    gem 'citizenship'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install citizenship
+
+and use it standalone.
+
+## Validations
+
+### NIB
+
+```ruby 
+result=Citizenship.valid_nib?("003503730000539151280") # returns true
+result=Citizenship.valid_nib?('0035.03730000539.1512.80') # returns true
+result=Citizenship.valid_nib?('38476129847') # returns false (since it fails proper size and CRC)
+result=Citizenship.valid_nib?('0035.03730000539.1512.80', strict: true) # returns false
+Citizenship.valid_nib!(nib) # raises Citizenship::Error if invalid
+```
+
+### NIF
+
+```ruby 
+result=Citizenship.valid_nif?("123456789") # returns true
+Citizenship.valid_nif!(nif) # raises Citizenship::Error if invalid
+nif=Citizenship.valid_nif!("123456789") # returns "123456789"
+result=Citizenship.valid_nif?(' 123456789', strict: true) # returns false (strict validation disallows whitespaces and others)
+```
+
+### Phone Number
+
+```ruby 
+phone=Citizenship.valid_phone!('+351 96 933 2233', only_prefixes: ['93', '96']) # returns "+351 96 933 2233"
+phone=Citizenship.valid_phone!('262-999-666') # returns "262-999-666"
+result=Citizenship.valid_phone?('262999666', strict: true) # returns true
+result=Citizenship.valid_phone?('+351 93 933 2233', allow_country_prefix: false) # returns false (since country prefix was used)
+phone=Citizenship.valid_phone!('+351 93 933 2233') # returns "+351 93 933 2233"
+```
+
+### Identification Card
+
+```ruby 
+result=Citizenship.valid_identification_card?('156 944 80', '4') # returns true
+id=Citizenship.valid_identification_card!('156 944 8', '8') # returns '156 944 8'
+```
+
+### Citizen Card
+
+```ruby 
+result=Citizenship.valid_citizen_card?('00000000 0 ZZ 4') # returns true
+id=Citizenship.valid_citizen_card('00000000-0-ZZ-4') # returns '00000000-0-ZZ-4'
+```
+
+### Zip Code
+
+```ruby 
+result=Citizenship.valid_zip_code?('1000-100') # returns true
+```
+
+### E-mail
+
+```ruby 
+result=Citizenship.valid_email?("user@example.org") # returns true
+result=Citizenship.valid_email?("  user@example.org ") # returns false (due to whitespaces)
+result=Citizenship.valid_email?("@example.org") # returns false (due to missing user)
+```
+
+## Rails Validators
+
+We provide a useful range of Rails validators that you can include in your models, namely:
+
+* NifValidator
+* NibValidator
+* PhoneValidator
+* EmailValidator
+* ZipCodeValidor
+
+### Example
+
+
+    class User < ActiveRecord::Base
+      validates :fiscal_number, nif: true
+      ...
+    end
+ 
+
+## Future Developments
+
+* Support full zip code validation
+* Support IBAN
+* Support validating documents for other EU countries
+
+## References
+
+* [NIB](http://pt.wikipedia.org/wiki/N%C3%BAmero_de_Identifica%C3%A7%C3%A3o_Banc%C3%A1ria)
+* [NIF](http://pt.wikipedia.org/wiki/N%C3%BAmero_de_identifica%C3%A7%C3%A3o_fiscal)
+* [Citizen Card](http://www.cartaodecidadao.pt/images/stories/Algoritmo_Num_Documento_CC.pdf)
+* [(old) Identification Card](http://geramat.blogs.sapo.pt/13528.html)
+* [ZIP codes](http://pt.wikipedia.org/wiki/N%C3%BAmero_de_Identifica%C3%A7%C3%A3o_Banc%C3%A1ria)
+
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+Copyright © 2015 [Runtime Revolution](http://www.runtime-revolution.com), released under the MIT license.
+

data/Rakefile

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'bundler/gem_tasks'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+require 'simplecov'
+
+task :test =>    :spec
+task :default => :spec
+
+RSpec::Core::RakeTask.new do |task|
+  task.rspec_opts = ["-c", "-f documentation", "-r ./spec/helper.rb"]
+  task.pattern    = 'spec/**/*_spec.rb'
+end
+
+desc "Open an interactive session preloaded with this gem's code"
+task :console do
+  if gem_available?("pry")
+    sh "pry -I lib -r citizenship.rb"
+  else
+    sh "irb -rubygems -I lib -r citizenship.rb"
+  end
+end
+
+#
+# Determins if a gem is available at the current runtime
+#
+def gem_available?(name)
+  Gem::Specification.find_by_name(name)
+rescue Gem::LoadError
+  false
+rescue
+  Gem.available?(name) #for backwards compatibility
+end

data/citizenship.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'citizenship/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "citizenship"
+  gem.version       = Citizenship::VERSION
+  gem.platform    = Gem::Platform::RUBY
+  gem.authors       = ["Runtime Revolution"]
+  gem.description   = %q{citizenship checks validity of civil id numbers and similar used in Portugal}
+  gem.summary       = %q{citizenship checks validity of civil id numbers and similar used in Portugal}
+  gem.homepage      = "https://github.com/runtimerevolution/citizenship"
+  gem.email         = 'info@runtime-revolution.com'
+  gem.license     = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'i18n', ['>= 0.6.4', '<= 0.7.0']
+
+  gem.add_development_dependency "bundler", "~> 1.3"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec", "~> 3.2.0"
+
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'pry'
+end

data/lib/citizenship.rb

@@ -0,0 +1,41 @@
+require 'citizenship/version'
+require 'citizenship/errors'
+require 'citizenship/nif'
+require 'citizenship/nib'
+require 'citizenship/citizen_card'
+require 'citizenship/identification_card'
+require 'citizenship/phone'
+require 'citizenship/email'
+require 'citizenship/zip_code'
+require 'citizenship/rails/validators' if defined?(ActiveModel)
+
+module Citizenship
+  private
+  #Decimal check bit common processing
+  def self.decimal_check_digit(number, cover_digit_collision_flaw = true)
+    number = String(number)
+
+    multiplier = 1
+    result = number.delete(' ').split('').map(&:to_i).reverse.map do |digit|
+      digit * (multiplier += 1)
+    end.reduce(:+) || 0
+
+    #Cover for the digit collision flaw?
+    return 0 if (control_number = 11 - result % 11) > 9 and cover_digit_collision_flaw
+    control_number
+  end
+
+  def self.decimal_check_digit_match?(number, check_digit, cover_digit_collision_flaw = true)
+    decimal_check_digit(number, cover_digit_collision_flaw) == check_digit.to_i
+  end
+
+  def self.is_number?(i)
+    true if Float(i) rescue false
+  end
+
+  def self.remove_special_chars(str)
+    String(str).delete(' ').delete('-').delete('.')
+  end
+end
+
+I18n.load_path += Dir.glob( File.join(File.dirname(__FILE__), 'locales'.freeze, '*.yml'.freeze) )

data/lib/citizenship/citizen_card.rb

@@ -0,0 +1,36 @@
+module Citizenship
+  #http://www.cartaodecidadao.pt/images/stories/Algoritmo_Num_Documento_CC.pdf
+  def self.valid_citizen_card!(number)
+    id_number = remove_special_chars(number)
+
+    raise CitizenCardError, :size if id_number.size != 12
+
+    double_digit = false
+    conversion_table = ('a'..'z').to_a
+    check_digit = id_number.reverse.split('').map do |element|
+      #switch letters for the value in the conversion table (see 2.3. on Algoritmo_Num_Documento_CC.pdf)
+      is_number?(element) ? element : conversion_table.find_index(element.downcase) + 10
+    end.map(&:to_i).map do |digit|
+      begin
+        if double_digit #starting on the 2nd value double every value steping by 2
+          value = digit * 2
+          value >= 10 ? value - 9 : value #If the doubling result is 10 or more, subtract 9
+        else
+          digit
+        end
+      ensure
+        double_digit = not(double_digit)
+      end
+    end.reduce(:+) #sum everything
+
+    raise CitizenCardError, :invalid_check_digit if check_digit % 10 != 0
+    number
+  end
+
+  def self.valid_citizen_card?(number)
+    valid_citizen_card!(number)
+    true
+  rescue CitizenCardError
+    false
+  end
+end

data/lib/citizenship/email.rb

@@ -0,0 +1,15 @@
+module Citizenship
+  EMAIL_REGEXP = /\A[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]+\z/i
+
+  def self.valid_email!(email)
+    raise EmailError, :invalid_email unless email.match(EMAIL_REGEXP)
+    email
+  end
+
+  def self.valid_email?(email)
+    valid_email!(email)
+    true
+  rescue EmailError
+    false
+  end
+end

data/lib/citizenship/errors.rb

@@ -0,0 +1,52 @@
+require 'pathname'
+require 'i18n'
+
+module Citizenship
+  class Error < StandardError
+    def initialize(key, values = {}, scope)
+      super(I18n.t(key, values.merge(scope: "citizenship.#{scope}")))
+    end
+  end
+
+  class NIFError < Error
+    def initialize(key, values = {})
+      super(key, values, :nif)
+    end
+  end
+
+  class NIBError < Error
+    def initialize(key, values = {})
+      super(key, values, :nib)
+    end
+  end
+
+  class CitizenCardError < Error
+    def initialize(key, values = {})
+      super(key, values, :citizen_card)
+    end
+  end
+
+  class IdentificationCardError < Error
+    def initialize(key, values = {})
+      super(key, values, :identification_card)
+    end
+  end
+
+  class PhoneError < Error
+    def initialize(key, values = {})
+      super(key, values, :phone)
+    end
+  end
+
+  class EmailError < Error
+    def initialize(key, values = {})
+      super(key, values, :email)
+    end
+  end
+
+  class ZipCodeError < Error
+    def initialize(key, values = {})
+      super(key, values, :zip_code)
+    end
+  end
+end

data/lib/citizenship/identification_card.rb

@@ -0,0 +1,17 @@
+#see: http://geramat.blogs.sapo.pt/13528.html
+module Citizenship
+  def self.valid_identification_card!(number, check_digit)
+    id_number, check_digit = String(number).delete(' '), String(check_digit)
+
+    raise IdentificationCardError, :size unless id_number.size == 7 or id_number.size == 8
+    raise IdentificationCardError, :invalid_check_digit unless decimal_check_digit_match?(id_number, check_digit)
+    number
+  end
+
+  def self.valid_identification_card?(number, check_digit)
+    valid_identification_card!(number, check_digit)
+    true
+  rescue IdentificationCardError
+    false
+  end
+end

data/lib/citizenship/nib.rb

@@ -0,0 +1,49 @@
+#see: http://pt.wikipedia.org/wiki/N%C3%BAmero_de_Identifica%C3%A7%C3%A3o_Banc%C3%A1ria
+module Citizenship
+  def self.valid_nib!(nib, options = {})
+    strict = options.fetch(:strict, false)
+    bank_codes = ['0007', #BES
+                  '0010', #BPI
+                  '0018', #Santander
+                  '0019', #BBVA
+                  '0025', #Caixa BI
+                  '0032', #Barclays
+                  '0033', #BCP
+                  '0034', #BNP Paribas
+                  '0035', #CGD
+                  '0036', #Montepio
+                  '0038', #Banif
+                  '0043', #Deutsche Bank
+                  '0045', #CA Crédito Agrícola
+                  '0046', #Banco Popular
+                  '0061', #BiG
+                  '0065', #Best
+                  '0076', #Finibanco
+                  '0079', #BPN
+                  '0781', #Direcção Geral do Tesouro
+                  '5180'] #Caixa Central de Crédito Agrícola Mútuo
+
+    escaped_nib = strict ? nib : remove_special_chars(nib)
+    raise NIBError.new(:size) unless escaped_nib.size == 21
+    raise NIBError.new(:invalid_bank_code, bank_code: escaped_nib[0..3]) unless bank_codes.include?(escaped_nib[0..3])
+
+    check_digit = escaped_nib[19..20].to_i
+    escaped_nib = escaped_nib[0..18]
+
+    conversion_table = [73, 17, 89, 38, 62, 45, 53, 15, 50, 5, 49, 34, 81, 76, 27, 90, 9, 30, 3]
+    sum = (0..18).map do |i|
+      escaped_nib.slice(i).to_i * conversion_table[i]
+    end.reduce(:+)
+
+    control_number = 98 - sum % 97
+    raise NIBError.new(:invalid_check_digit) unless check_digit == control_number
+    nib
+  end
+
+  def self.valid_nib?(nib, options = {})
+    valid_nib!(nib, options)
+    true
+  rescue NIBError
+    false
+  end
+end

data/lib/citizenship/nif.rb

@@ -0,0 +1,20 @@
+#see: http://pt.wikipedia.org/wiki/N%C3%BAmero_de_identifica%C3%A7%C3%A3o_fiscal
+module Citizenship
+  def self.valid_nif!(number, options = {})
+    strict = options.fetch(:strict, false)
+    id_number = strict ? number : String(number).delete(' ')
+    first_digit_universe = [1, 2, 5, 6, 8, 9]
+
+    raise NIFError.new(:size) if id_number.size != 9
+    raise NIFError.new(:prefix, prefixes: first_digit_universe.join(', ')) unless first_digit_universe.include?(id_number[0].to_i)
+    raise NIFError.new(:invalid_check_digit) unless decimal_check_digit_match?(id_number[0..-2], id_number[-1])
+    number
+  end
+
+  def self.valid_nif?(number, options = {})
+    valid_nif!(number, options)
+    true
+  rescue NIFError
+    false
+  end
+end

data/lib/citizenship/phone.rb

@@ -0,0 +1,27 @@
+module Citizenship
+  def self.valid_phone!(number, opts = {})
+    allow_country_prefix = opts.fetch(:allow_country_prefix, true)
+    prefix_whitelist = network_prefix_white_list(opts[:only_prefixes])
+    strict = opts.fetch(:strict, false)
+
+    country_prefix = allow_country_prefix ? '((\+351|00351|351)?)' : ''
+    regexp_template = "^#{country_prefix}(#{prefix_whitelist}\\d{7})$"
+
+    phone_number = strict ? number : String(number).delete(' ').delete('-')
+    raise PhoneError, :invalid_phone_number unless phone_number.match(Regexp.new(regexp_template))
+    number
+  end
+
+  def self.valid_phone?(number, opts = {})
+    valid_phone!(number, opts)
+    true
+  rescue Error
+    false
+  end
+
+  private
+  def self.network_prefix_white_list(prefixes)
+    return '(2\d{1}|(9(3|6|2|1)))' if prefixes.nil?
+    prefixes.is_a?(Array) ? "(#{prefixes.map(&:to_s).join('|')})" : "(#{prefixes})"
+  end
+end

data/lib/citizenship/rails/validators.rb

@@ -0,0 +1,47 @@
+module Citizenship
+  module Rails
+    module Validators
+      class NifValidator < ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          Citizenship.valid_nif!(value, options) if value.present?
+        rescue Citizenship::NIFError => e
+          record.errors[attribute] << (options[:message] || e.message)
+        end
+      end
+
+      class NibValidator < ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          Citizenship.valid_nib!(value, options) if value.present?
+        rescue Citizenship::NIBError => e
+          record.errors[attribute] << (options[:message] || e.message)
+        end
+      end
+
+      class PhoneValidator < ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          Citizenship.valid_phone!(value, options) if value.present?
+        rescue Citizenship::PhoneError => e
+          record.errors[attribute] << (options[:message] || e.message)
+        end
+      end
+
+      class EmailValidator < ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          Citizenship.valid_email!(value) if value.present?
+        rescue Citizenship::EmailError => e
+          record.errors[attribute] << (options[:message] || e.message)
+        end
+      end
+
+      class ZipCodeValidator < ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          Citizenship.valid_zip_code!(value) if value.present?
+        rescue Citizenship::ZipCodeError => e
+          record.errors[attribute] << (options[:message] || e.message)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, Citizenship::Rails::Validators)

data/lib/citizenship/version.rb

@@ -0,0 +1,3 @@
+module Citizenship
+  VERSION = "1.0.0"
+end

data/lib/citizenship/zip_code.rb

@@ -0,0 +1,14 @@
+module Citizenship
+  def self.valid_zip_code!(zip_code)
+    regexp = /^(\d{4})-(\d{3})$/
+    raise ZipCodeError, :invalid_zip_code unless zip_code.match(regexp)
+    zip_code
+  end
+
+  def self.valid_zip_code?(zip_code)
+    valid_zip_code!(zip_code)
+    true
+  rescue ZipCodeError
+    false
+  end
+end

data/lib/locales/en.yml

@@ -0,0 +1,24 @@
+en:
+  citizenship:
+    nif:
+      size: "must have 9 digits"
+      prefix: "first number has to be one of the following: %{prefixes}"
+      invalid_check_digit: "Invalid check digit"
+    nib:
+      size: "must have 21 digits"
+      invalid_bank_code: "Invalid bank code: %{bank_code}"
+      invalid_check_digit: "Invalid check digit"
+    citizen_card:
+      size: "Invalid size"
+      invalid_check_digit: "Invalid check digit"
+    identification_card:
+      size: "Invalid size"
+      invalid_check_digit: "Invalid check digit"
+    phone:
+      invalid_phone_number: "Invalid phone number"
+
+
+
+
+
+

data/lib/locales/pt-PT.yml

@@ -0,0 +1,22 @@
+"pt-PT":
+  citizenship:
+    nif:
+      size: "deve conter 9 digitos"
+      prefix: "o primeiro digito tem de ser um dos seguintes: %{prefixes}"
+      invalid_check_digit: "inválido"
+    nib:
+      size: "deve conter 21 digitos"
+      invalid_bank_code: "Código bancário inválido: %{bank_code}"
+      invalid_check_digit: "inválido"
+    citizen_card:
+      size: "Tamanho inválido"
+      invalid_check_digit: "Cartão de cidadão inválido"
+    identification_card:
+      size: "Tamanho inválido"
+      invalid_check_digit: "inválido"
+    phone:
+      invalid_phone_number: "inválido"
+    email:
+      invalid_email: "inválido"
+    zip_code:
+      invalid_zip_code: "inválido"

data/lib/locales/pt.yml

@@ -0,0 +1,22 @@
+"pt":
+  citizenship:
+    nif:
+      size: "deve conter 9 digitos"
+      prefix: "o primeiro digito tem de ser um dos seguintes: %{prefixes}"
+      invalid_check_digit: "inválido"
+    nib:
+      size: "deve conter 21 digitos"
+      invalid_bank_code: "Código bancário inválido: %{bank_code}"
+      invalid_check_digit: "inválido"
+    citizen_card:
+      size: "Tamanho inválido"
+      invalid_check_digit: "Cartão de cidadão inválido"
+    identification_card:
+      size: "Tamanho inválido"
+      invalid_check_digit: "inválido"
+    phone:
+      invalid_phone_number: "inválido"
+    email:
+      invalid_email: "inválido"
+    zip_code:
+      invalid_zip_code: "inválido"

data/spec/citizenship/citizen_card_spec.rb

@@ -0,0 +1,16 @@
+describe 'citizen card validation' do
+  it 'passes on valid citizen card numbers' do
+    cc_number = '00000000 0 ZZ 4'
+
+    expect(Citizenship.valid_citizen_card?(cc_number)).to be_truthy
+    expect(Citizenship.valid_citizen_card!(cc_number)).to eq(cc_number)
+    expect(Citizenship.valid_citizen_card!('00000000-0-ZZ-4')).to eq('00000000-0-ZZ-4')
+    expect(Citizenship.valid_citizen_card!('00000000.0.ZZ.4')).to eq('00000000.0.ZZ.4')
+  end
+
+  it 'fails on invalid citizen card numbers' do
+    expect(Citizenship.valid_citizen_card?('')).to be_falsy
+    expect { Citizenship.valid_citizen_card!(nil) }.to raise_error(Citizenship::Error)
+    expect { Citizenship.valid_citizen_card!('12345678 9 ZZ8') }.to raise_error(Citizenship::Error)
+  end
+end

data/spec/citizenship/email_spec.rb

@@ -0,0 +1,12 @@
+describe 'Email validation' do
+  it 'passes on valid emails' do
+    expect(Citizenship.valid_email?('user@example.org')).to be_truthy
+  end
+
+  it 'falid on invalid emails' do
+    expect {Citizenship.valid_email!(' user@example.org')}.to raise_error(Citizenship::EmailError)
+    expect(Citizenship.valid_email?('user@example.org ')).to be_falsy
+    expect(Citizenship.valid_email?('email@')).to be_falsy
+    expect(Citizenship.valid_email?('@example.com')).to be_falsy
+  end
+end

data/spec/citizenship/identification_card_spec.rb

@@ -0,0 +1,19 @@
+describe 'identification card validation' do
+  it 'passes on valid identification card numbers' do
+    expect(Citizenship.valid_identification_card?('156 944 8', '8')).to be_truthy
+    expect(Citizenship.valid_identification_card?('156 944 80', '4')).to be_truthy
+    expect(Citizenship.valid_identification_card!('156 944 8', '8')).to eq('156 944 8')
+  end
+
+  it 'fails on invalid identification card numbers' do
+    expect(Citizenship.valid_identification_card?('156 944 8', '7')).to be_falsy
+    expect { Citizenship.valid_identification_card!('156 944 8', '7') }.to raise_error(Citizenship::Error)
+    expect { Citizenship.valid_identification_card!('', '0') }.to raise_error(Citizenship::Error)
+    expect { Citizenship.valid_identification_card!(nil, nil) }.to raise_error(Citizenship::Error)
+  end
+
+  it 'covers control digit collision flaw' do
+    #see http://dokatano.blogspot.pt/2008/10/o-mistrio-do-bilhete-de-identidade.html
+    expect(Citizenship.valid_identification_card?('6617080', 0)).to be_truthy
+  end
+end

data/spec/citizenship/nib_spec.rb

@@ -0,0 +1,27 @@
+describe 'NIB validation' do
+  it 'passes for valid NIBs', focus: true do
+    nib = '003503730000539151280'
+
+    expect(Citizenship.valid_nib!(nib)).to eq(nib)
+    expect(Citizenship.valid_nib?(nib)).to be_truthy
+    expect(Citizenship.valid_nib?('0035-03730000539-1512-80')).to be_truthy
+    expect(Citizenship.valid_nib?('0035.03730000539.1512.80')).to be_truthy
+  end
+
+  it 'fails for invalid NIBs' do
+    nib = '003503730000539151200'
+
+    expect{ Citizenship.valid_nib!(nib) }.to raise_error(Citizenship::Error)
+    expect{ Citizenship.valid_nib!('000003730000539151252') }.to raise_error(Citizenship::Error) #invalid bank code
+    expect(Citizenship.valid_nib?(nib)).to be_falsy
+    expect(Citizenship.valid_nib?('')).to be_falsy
+  end
+
+  it 'strict validation disallow whitspaces, dashes and dots' do
+    expect(Citizenship.valid_nib?('0035-03730000539-1512-80', strict: true)).to be_falsy
+    expect(Citizenship.valid_nib?('0035.03730000539.1512.80', strict: true)).to be_falsy
+    expect(Citizenship.valid_nib?('0035 03730000539 1512 80', strict: true)).to be_falsy
+    expect(Citizenship.valid_nib?('0035 03730000539 1512 80 ', strict: true)).to be_falsy
+    expect(Citizenship.valid_nib?('003503730000539151280', strict: true)).to be_truthy
+  end
+end

data/spec/citizenship/nif_spec.rb

@@ -0,0 +1,21 @@
+describe 'NIF validation' do
+  it 'passes for valid NIFs' do
+    expect(Citizenship.valid_nif?('123456789')).to be_truthy
+    expect(Citizenship.valid_nif!('123456789')).to eq('123456789')
+    expect(Citizenship.valid_nif!('123456789')).to eq('123456789')
+  end
+
+  it 'fails on invalid NIFs' do
+    expect(Citizenship.valid_nif?('223456789')).to be_falsy
+    expect(Citizenship.valid_nif?('12345678')).to be_falsy
+    expect { Citizenship.valid_nif!('223456789') }.to raise_error(Citizenship::Error)
+    expect(Citizenship.valid_nif?(nil)).to be_falsy
+  end
+
+  it 'strict validation disallow whitspaces and others' do
+    expect(Citizenship.valid_nif?(' 123456789', strict: true)).to be_falsy
+    expect(Citizenship.valid_nif?('123456789 ', strict: true)).to be_falsy
+    expect(Citizenship.valid_nif?('12345 6789', strict: true)).to be_falsy
+    expect(Citizenship.valid_nif?('123456789', strict: true)).to be_truthy
+  end
+end

data/spec/citizenship/phone_spec.rb

@@ -0,0 +1,59 @@
+describe 'phone number validation' do
+  context 'passes for valid phone numbers' do
+    it 'land lines' do
+      expect(Citizenship.valid_phone!('262-999-666')).to eq('262-999-666')
+    end
+
+    it 'mobile' do
+      expect(Citizenship.valid_phone!('939332233')).to eq('939332233')
+      expect(Citizenship.valid_phone!('969332233')).to eq('969332233')
+      expect(Citizenship.valid_phone!('929332233')).to eq('929332233')
+      expect(Citizenship.valid_phone?('919332233')).to be_truthy
+    end
+
+    it 'with country prefix' do
+      expect(Citizenship.valid_phone!('+351 93 933 2233')).to eq('+351 93 933 2233')
+
+    end
+
+    it 'without countryprefix' do
+      expect(Citizenship.valid_phone?('+351 93 933 2233', allow_country_prefix: false)).to be_falsy
+    end
+
+    it 'by designated prefix', focus: true do
+      expect(Citizenship.valid_phone!('+351 93 933 2233', only_prefixes: ['93', '96'])).to eq('+351 93 933 2233')
+      expect(Citizenship.valid_phone!('+351 96 933 2233', only_prefixes: ['93', '96'])).to eq('+351 96 933 2233')
+    end
+
+    it 'strict validation disallow whitspaces, dashes and dots' do
+      expect(Citizenship.valid_phone?('262999666', strict: true)).to be_truthy
+    end
+  end
+
+  context 'fails for invalid phone numbers' do
+    it 'land lines' do
+      expect { Citizenship.valid_phone!('662-999-666') }.to raise_error(Citizenship::Error)
+    end
+
+    it 'mobile' do
+      expect(Citizenship.valid_phone?('999332233')).to be_falsy
+    end
+
+    it 'with country prefix' do
+      expect(Citizenship.valid_phone?('+350 93 933 2233')).to be_falsy
+    end
+
+    it 'by designated prefix' do
+      expect(Citizenship.valid_phone?('96 933 2233', only_prefixes: '93')).to be_falsy
+      expect(Citizenship.valid_phone?('96 933 2233', only_prefixes: ['91', '93'])).to be_falsy
+    end
+
+
+    it 'strict validation disallow whitspaces, dashes and dots' do
+      expect(Citizenship.valid_phone?('262-999-666', strict: true)).to be_falsy
+      expect(Citizenship.valid_phone?('262 999 666', strict: true)).to be_falsy
+      expect(Citizenship.valid_phone?(' 262999666', strict: true)).to be_falsy
+      expect(Citizenship.valid_phone?(' 262999666 ', strict: true)).to be_falsy
+    end
+  end
+end

data/spec/citizenship/zip_code_spec.rb

@@ -0,0 +1,13 @@
+describe 'Zip code validation' do
+  it 'passes for valid Zip codes' do
+    expect(Citizenship.valid_zip_code?('1000-100')).to be_truthy
+  end
+
+  it 'fails for invalid Zip codes' do
+    expect {Citizenship.valid_zip_code!('1000')}.to raise_error(Citizenship::ZipCodeError)
+    expect(Citizenship.valid_zip_code?('1000-00')).to be_falsy
+    expect(Citizenship.valid_zip_code?(' 1000-000')).to be_falsy
+    expect(Citizenship.valid_zip_code?('1000-100 ')).to be_falsy
+    expect(Citizenship.valid_zip_code?('1000 - 100')).to be_falsy
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,9 @@
+require 'simplecov'
+require 'pry'
+
+#setup simplecov
+SimpleCov.start do
+  add_filter "/spec"
+end
+
+require File.expand_path('../../lib/citizenship', __FILE__)

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: citizenship
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Runtime Revolution
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.4
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.4
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: pry
+  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: citizenship checks validity of civil id numbers and similar used in Portugal
+email: info@runtime-revolution.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- citizenship.gemspec
+- lib/citizenship.rb
+- lib/citizenship/citizen_card.rb
+- lib/citizenship/email.rb
+- lib/citizenship/errors.rb
+- lib/citizenship/identification_card.rb
+- lib/citizenship/nib.rb
+- lib/citizenship/nif.rb
+- lib/citizenship/phone.rb
+- lib/citizenship/rails/validators.rb
+- lib/citizenship/version.rb
+- lib/citizenship/zip_code.rb
+- lib/locales/en.yml
+- lib/locales/pt-PT.yml
+- lib/locales/pt.yml
+- spec/citizenship/citizen_card_spec.rb
+- spec/citizenship/email_spec.rb
+- spec/citizenship/identification_card_spec.rb
+- spec/citizenship/nib_spec.rb
+- spec/citizenship/nif_spec.rb
+- spec/citizenship/phone_spec.rb
+- spec/citizenship/zip_code_spec.rb
+- spec/helper.rb
+homepage: https://github.com/runtimerevolution/citizenship
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: citizenship checks validity of civil id numbers and similar used in Portugal
+test_files:
+- spec/citizenship/citizen_card_spec.rb
+- spec/citizenship/email_spec.rb
+- spec/citizenship/identification_card_spec.rb
+- spec/citizenship/nib_spec.rb
+- spec/citizenship/nif_spec.rb
+- spec/citizenship/phone_spec.rb
+- spec/citizenship/zip_code_spec.rb
+- spec/helper.rb