valicuit 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 152af78be77b708c5f1250b822ba6e51c3f3a0d9
+  data.tar.gz: eb3e1a106becb4ee13dacca3d027a3428027fb37
+SHA512:
+  metadata.gz: 59f2ecf49e180404dae2d6e239d55dee15c2423f70ab8b311a9c78aa5a9857a64bdacce91c223273e22839978dc95cdb8a8e9bbf51241d9c277e39ab0a804088
+  data.tar.gz: d30e08ff153bf3f0b6dd5c1526a060288e8767cff022bdfc7429f1e62157a817f5083ff895843cf3663a603cad25e61daf2096c239fee1a45a4cc5768ed6316f

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+.ruby-version
+coverage

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+before_install:
+  - gem update bundler
+rvm:
+  - 2.2.2
+addons:
+  code_climate:
+    repo_token: 5c1793440af1121e6c37db409546cbddebe375c9e417f92444c0a6810433af6e

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,77 @@
+# ValiCUIT
+
+[![Build Status](https://travis-ci.org/lndl/valicuit.svg?branch=master)](https://travis-ci.org/lndl/valicuit) [![Code Climate](https://codeclimate.com/github/lndl/valicuit/badges/gpa.svg)](https://codeclimate.com/github/lndl/valicuit) [![Test Coverage](https://codeclimate.com/github/lndl/valicuit/badges/coverage.svg)](https://codeclimate.com/github/lndl/valicuit/coverage) [![Issue Count](https://codeclimate.com/github/lndl/valicuit/badges/issue_count.svg)](https://codeclimate.com/github/lndl/valicuit)
+
+Un validador de CUIT/CUIL para ActiveModel & Rails.
+
+## Instalación
+
+Lo de siempre... agregar esta línea en el Gemfile del proyecto:
+
+```
+gem 'valicuit', github: 'lndl/valicuit'
+```
+
+Y, finalmente, ejecutar **bundle install**
+
+## Uso
+
+Es un validador más. Dentro de cualquier modelo se especifica que un atributo X se valide con cuit (o cuil, es indistinto), de esta forma:
+
+```ruby
+class Persona < ActiveRecord::Base
+  validates :cuit, cuit: true  # Notar que también podría usarse cuil: true
+end
+```
+
+Con esto, se dispone de validación por formato (por defecto 11 dígitos, sin separador) y por dígito verificador (con el algoritomo módulo 11)
+
+## Opciones adicionales
+
+Se puede agregar la opción de incluir y validar un separador para los grupos que componen el CUIT/CUIL, de esta forma:
+
+```ruby
+class Persona < ActiveRecord::Base
+  validates :cuit, cuit: { separator: '-' }
+end
+```
+
+Adicionalmente se puede validar que la parte del género y del DNI del CUIT se corresponda con dichos campos propios en el mismo modelo.
+
+Por ejemplo, para el caso del DNI podría ser:
+
+```ruby
+class Persona < ActiveRecord::Base
+  validates :cuit, cuit: { dni_compatible: :documento }
+end
+```
+
+Y eso verificaría que la parte central del CUIT (que corresponde al DNI) sea igual al valor del campo 'documento' (qué, en dicho modelo, representaría el DNI de la persona)
+
+Análogamente se cumple lo mismo para el género:
+
+```ruby
+class Persona < ActiveRecord::Base
+  validates :cuit, cuit: { gender_compatible: { field: :genero, male: 'M', female: 'F' } }
+end
+```
+
+Y se especifica el campo que representa el género en el modelo, más los valores para validar tales géneros.
+
+
+## Tests
+
+Se corren con RSpec.
+
+## Agradecimientos
+
+- https://github.com/maxigarciaf/cuit_validator
+- https://github.com/codegram/date_validator
+
+## Contribuciones
+
+1. Clonar el proyecto.
+2. Crear un *feature branch* (`git checkout -b mi-nuevo-feature`).
+3. *Commitear* los cambios realizados (`git commit -am 'Agrego algo nuevo o mejoro algo'`).
+4. *Pushear* el *feature* (`git push origin mi-nuevo-feature`).
+5. Crear un *Pull Request*.

data/Rakefile

@@ -0,0 +1,9 @@
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+
+  task default: :spec
+rescue LoadError
+  # no rspec available
+end
+

data/lib/active_model/validations/cuit_validator.rb

@@ -0,0 +1,119 @@
+require 'active_model/validations'
+
+# ActiveModel module.
+module ActiveModel
+
+  # ActiveModel::Validations module. Contains all the default validators.
+  module Validations
+
+    # Here start the implementation of CUIT/CUIL validator
+    class CuitValidator < ActiveModel::EachValidator
+      CHECKS = [ :separator, :dni_compatible, :gender_compatible ].freeze
+
+      # Hook that checks the options validity
+      # for this validator
+      def check_validity!
+        invalid_options = options.keys - CHECKS
+        raise ArgumentError, "#{invalid_options} are invalid CUIT/CUIL options. You can use only these: #{CHECKS.join(', ')}" unless invalid_options.empty?
+      end
+
+      def validate_each(record, attr_name, value)
+        return if detect_any_failure_in :length, :digits, :dni_compatibility, :gender_compatibility, :v_digit,
+          data: [ record, attr_name, value ]
+      end
+
+      protected
+
+      # Sugar, turutu-tu-tuut-tu, ohhh, honey, honey
+      def detect_any_failure_in(*properties, data: [])
+        properties.detect { |prop| send "check_#{prop}_failure", *data }
+      end
+
+      def check_length_failure(record, attr_name, value)
+        type, dni, v_digit = separate_cuit_groups value
+        unless type.length == 2 && dni.length == 8 && v_digit.length == 1
+          record.errors.add(attr_name, :cuit_invalid_format)
+        end
+      end
+
+      def check_digits_failure(record, attr_name, value)
+        type, dni, v_digit = separate_cuit_groups value
+        unless (type + dni + v_digit) =~ /\A\d+\Z/
+          record.errors.add(attr_name, :cuit_invalid_format)
+        end
+      end
+
+      def check_dni_compatibility_failure(record, attr_name, value)
+        _, dni, _ = separate_cuit_groups value
+        unless !options[:dni_compatible].present? || record.public_send(options[:dni_compatible]) == dni
+          record.errors.add(attr_name, :cuit_dni_incompatible)
+        end
+      end
+
+      def check_gender_compatibility_failure(record, attr_name, value)
+        type, _, _ = separate_cuit_groups value
+
+        if options[:gender_compatible].present?
+          unless gender_validation_passing?(record, type)
+            record.errors.add(attr_name, :cuit_gender_incompatible)
+          end
+        end
+      end
+
+      def check_v_digit_failure(record, attr_name, value)
+        type, dni, v_digit = separate_cuit_groups value
+        unless v_digit.to_i == compute_v_digit(type, dni)
+          record.errors.add(attr_name, :cuit_invalid_v_digit)
+        end
+      end
+
+      # AFIP dependent logic. Trust or die
+      def compute_v_digit(type, dni)
+        sequence = [2,3,4,5,6,7,2,3,4,5].reverse
+        precomputed_v_digit = 11 - (type + dni)
+          .chars
+          .each_with_index
+          .inject(0) do |acc, (n, i)|
+            acc + n.to_i * sequence[i]
+          end % 11
+
+        case precomputed_v_digit
+        when 11
+          0
+        when 10
+          9
+        else
+          precomputed_v_digit
+        end
+      end
+
+      def separate_cuit_groups(cuit)
+        separator = options[:separator]
+        if separator
+          cuit.split(separator).first 3
+        else
+          # Take standard CUIT/CUIL layout (2 digit, 8 digit, 1 digit)
+          [ cuit[0..1], cuit[2..9], cuit[10] ]
+        end.map(&:to_s)
+      end
+
+      def gender_validation_passing?(record, type)
+        raise ArgumentError, 'Valicuit: gender field specification must be present!' unless options[:gender_compatible][:field].present?
+        raise ArgumentError, 'Valicuit: declaration of male value missing!'          unless options[:gender_compatible][:male].present?
+        raise ArgumentError, 'Valicuit: declaration of female value missing!'        unless options[:gender_compatible][:female].present?
+        case type
+        when '20'
+          options[:gender_compatible][:male]
+        when '27'
+          options[:gender_compatible][:female]
+        else
+          # Machist!
+          options[:gender_compatible][:male]
+        end == record.public_send(options[:gender_compatible][:field])
+      end
+    end
+
+    # CUIT/CUIL is the same for the purposes of validation
+    CuilValidator = CuitValidator
+  end
+end

data/lib/valicuit/engine.rb

@@ -0,0 +1,8 @@
+module Valicuit
+  class Engine < Rails::Engine
+    initializer 'valicuit' do
+      files = Dir[Pathname.new(File.dirname(__FILE__)).join('../..', 'locales', '*.yml')]
+      config.i18n.load_path += files
+    end
+  end
+end

data/lib/valicuit/version.rb

@@ -0,0 +1,3 @@
+module Valicuit
+  VERSION = "0.2.2"
+end

data/lib/valicuit.rb

@@ -0,0 +1,6 @@
+require 'active_model/validations/cuit_validator'
+require 'active_support/i18n'
+require 'valicuit/engine' if defined?(Rails)
+
+module Valicuit
+end

data/locales/es.yml

@@ -0,0 +1,7 @@
+es:
+  errors:
+    messages:
+      cuit_invalid_format: no posee el formato correcto
+      cuit_dni_incompatible: no es compatible con DNI de la persona
+      cuit_gender_incompatible: no es compatible con el género de la persona
+      cuit_invalid_v_digit: tiene colocado incorrectamente su dígito verificador

data/locales/test.yml

@@ -0,0 +1,7 @@
+test:
+  errors:
+    messages:
+      cuit_invalid_format: invalid_format
+      cuit_dni_incompatible: cuit_dni_incompatible
+      cuit_gender_incompatible: cuit_gender_incompatible
+      cuit_invalid_v_digit: invalid_v_digit

data/spec/cuit_validator_spec.rb

@@ -0,0 +1,216 @@
+require 'spec_helper'
+
+RSpec.describe ActiveModel::Validations::CuitValidator do
+  before do
+    TestModel.reset_callbacks(:validate)
+  end
+
+  context '#check_validity!' do
+    context 'when pass cuil option as validator' do
+      it 'returns the validation options passed (therefore, all is well defined)' do
+        expect(TestModel.validates :cuit, cuil: true).to eq(cuil: true)
+      end
+    end
+    context 'when invalid options are passed' do
+      it 'throws an ArgumentError' do
+        expect do
+          TestModel.validates :cuit, cuit: { separator: '/', wrong_param: true }
+        end.to raise_error(ArgumentError)
+      end
+    end
+    context 'when valid options are passed' do
+      it 'returns the validation options passed (therefore, all is well defined)' do
+        expect(TestModel.validates :cuit, cuit: { separator: '/' }).to eq(cuit: { separator: '/' })
+      end
+    end
+    context 'when no options are passed (only true)' do
+      it 'returns the validation options passed (therefore, all is well defined)' do
+        expect(TestModel.validates :cuit, cuit: true).to eq(cuit: true)
+      end
+    end
+  end
+
+  context '#separate_cuit_groups' do
+    context 'without provide separator' do
+      let(:validator) { ActiveModel::Validations::CuitValidator.new attributes: { _: :_ } }
+      it 'must return an 3-elements Array (Happy)' do
+        expect(validator.send(:separate_cuit_groups, '30615459190')).to be_an_instance_of(Array)
+        expect(validator.send(:separate_cuit_groups, '30615459190').size).to eq(3)
+      end
+
+      it 'must return an 3-elements Array (Sad)' do
+        expect(validator.send(:separate_cuit_groups, '306')).to be_an_instance_of(Array)
+        expect(validator.send(:separate_cuit_groups, '306').size).to eq(3)
+      end
+
+      it 'each element must be an instance of String (Happy)' do
+        validator.send(:separate_cuit_groups, '30615459190').each do |group|
+          expect(group).to be_an_instance_of String
+        end
+      end
+
+      it 'each element must be an instance of String (Sad)' do
+        validator.send(:separate_cuit_groups, '306').each do |group|
+          expect(group).to be_an_instance_of String
+        end
+      end
+    end
+    context 'providing separator' do
+      let(:validator) do
+        ActiveModel::Validations::CuitValidator.new attributes: { _: :_ },
+          separator: '-'
+      end
+      it 'must return an 3-elements Array (Happy)' do
+        expect(validator.send(:separate_cuit_groups, '30-61545919-0')).to be_an_instance_of(Array)
+        expect(validator.send(:separate_cuit_groups, '30-61545919-0').size).to eq(3)
+      end
+
+      it 'must return an 3-elements Array (Sad)' do
+        expect(validator.send(:separate_cuit_groups, '30- - - --')).to be_an_instance_of(Array)
+        expect(validator.send(:separate_cuit_groups, '30- - - --').size).to eq(3)
+      end
+
+      it 'each element must be an instance of String (Happy)' do
+        validator.send(:separate_cuit_groups, '30-61545919-0').each do |group|
+          expect(group).to be_an_instance_of String
+        end
+      end
+
+      it 'each element must be an instance of String (Sad)' do
+        validator.send(:separate_cuit_groups, '306---').each do |group|
+          expect(group).to be_an_instance_of String
+        end
+      end
+    end
+  end
+
+  context '#valid' do
+    context 'with standard options' do
+      before do
+        TestModel.validates :cuit, cuit: true
+      end
+      it 'must return true when CUIT/CUIL is valid' do
+        expect(TestModel.new(cuit: '30615459190')).to be_valid
+        expect(TestModel.new(cuit: '20118748698')).to be_valid
+        expect(TestModel.new(cuit: '20120112989')).to be_valid
+        expect(TestModel.new(cuit: '27049852032')).to be_valid
+        expect(TestModel.new(cuit: '23218381669')).to be_valid
+        expect(TestModel.new(cuit: '30709316547')).to be_valid
+        expect(TestModel.new(cuit: '20000000019')).to be_valid
+      end
+      context 'when CUIT/CUIL has strange characters' do
+        it 'must return false' do
+          expect(TestModel.new(cuit: '2061s459190')).to be_invalid
+        end
+        it 'must leave a specific message over :cuit in #errors array' do
+          record = TestModel.new(cuit: '2061s459190')
+          record.valid?
+          expect(record.errors[:cuit]).to match_array(['invalid_format'])
+        end
+      end
+      context 'when CUIT/CUIL has not the correct length' do
+        it 'must return false' do
+          expect(TestModel.new(cuit: '301110')).to be_invalid
+        end
+        it 'must leave a specific message over :cuit in #errors array' do
+          record = TestModel.new(cuit: '301110')
+          record.valid?
+          expect(record.errors[:cuit]).to match_array(['invalid_format'])
+        end
+      end
+      context 'when CUIT/CUIL is logically invalid, because verification digit is incorrect' do
+        it 'must return false' do
+          expect(TestModel.new(cuit: '20111111110')).to be_invalid
+        end
+        it 'must leave a specific message over :cuit in #errors array' do
+          record = TestModel.new(cuit: '20111111110')
+          record.valid?
+          expect(record.errors[:cuit]).to match_array(['invalid_v_digit'])
+        end
+      end
+    end
+    context 'with separator option' do
+      before do
+        TestModel.validates :cuit, cuit: { separator: '-' }
+      end
+      it 'must return true when CUIT/CUIL is valid' do
+        expect(TestModel.new(cuit: '30-61545919-0')).to be_valid
+        expect(TestModel.new(cuit: '20-11874869-8')).to be_valid
+        expect(TestModel.new(cuit: '20-12011298-9')).to be_valid
+        expect(TestModel.new(cuit: '27-04985203-2')).to be_valid
+        expect(TestModel.new(cuit: '23-21838166-9')).to be_valid
+        expect(TestModel.new(cuit: '30-70931654-7')).to be_valid
+        expect(TestModel.new(cuit: '20-00000001-9')).to be_valid
+      end
+      context 'when CUIT/CUIL has not the correct length' do
+        it 'must return false' do
+          expect(TestModel.new(cuit: '30-1110222222222-4')).to be_invalid
+        end
+        it 'must leave a specific message over :cuit in #errors array' do
+          record = TestModel.new(cuit: '30-1110222222222-4')
+          record.valid?
+          expect(record.errors[:cuit]).to match_array(['invalid_format'])
+        end
+      end
+      context 'when CUIT/CUIL has misplaced the separator' do
+        it 'must return false' do
+          expect(TestModel.new(cuit: '30-123-11114')).to be_invalid
+        end
+        it 'must leave a specific message over :cuit in #errors array' do
+          record = TestModel.new(cuit: '30-123-11114')
+          record.valid?
+          expect(record.errors[:cuit]).to match_array(['invalid_format'])
+        end
+      end
+    end
+    context 'with dni compatible option' do
+      before do
+        TestModel.validates :cuit, cuit: { dni_compatible: :dni }
+      end
+      it 'must return true when CUIT/CUIL is valid and central part of CUIT is equal to DNI' do
+        expect(TestModel.new(cuit: '30615459190', dni: '61545919')).to be_valid
+        expect(TestModel.new(cuit: '20118748698', dni: '11874869')).to be_valid
+        expect(TestModel.new(cuit: '20120112989', dni: '12011298')).to be_valid
+        expect(TestModel.new(cuit: '27049852032', dni: '04985203')).to be_valid
+        expect(TestModel.new(cuit: '23218381669', dni: '21838166')).to be_valid
+        expect(TestModel.new(cuit: '30709316547', dni: '70931654')).to be_valid
+        expect(TestModel.new(cuit: '20000000019', dni: '00000001')).to be_valid
+      end
+      it 'must return false when CUIT/CUIL is valid but central part of CUIT is not equal to DNI' do
+        expect(TestModel.new(cuit: '30615459190', dni: '62545919')).to be_invalid
+        expect(TestModel.new(cuit: '20118748698', dni: '11875869')).to be_invalid
+        expect(TestModel.new(cuit: '20120112989', dni: '12011278')).to be_invalid
+        expect(TestModel.new(cuit: '27049852032', dni: '04945203')).to be_invalid
+        expect(TestModel.new(cuit: '23218381669', dni: '21838196')).to be_invalid
+        expect(TestModel.new(cuit: '30709316547', dni: '70901654')).to be_invalid
+        expect(TestModel.new(cuit: '20000000019', dni: '03000001')).to be_invalid
+      end
+      it 'must leave a specific message over :cuit in #errors array' do
+        record = TestModel.new(cuit: '20120112989', dni: '12011278')
+        record.valid?
+        expect(record.errors[:cuit]).to match_array(['cuit_dni_incompatible'])
+      end
+    end
+    context 'with gender compatible option' do
+      before do
+        TestModel.validates :cuit, cuit: { gender_compatible: { field: :gender, male: 'M', female: 'F' } }
+      end
+      it 'must return true when CUIT/CUIL is valid and gender part is compatible with gender model' do
+        expect(TestModel.new(cuit: '20120112989', gender: 'M')).to be_valid
+        expect(TestModel.new(cuit: '27049852032', gender: 'F')).to be_valid
+      end
+      it 'must return true with cuit type different of 20/27 as "Male"' do
+        expect(TestModel.new(cuit: '30709316547', gender: 'M')).to be_valid
+      end
+      it 'must return false when CUIT/CUIL is valid but gender part is incompatible with gender model' do
+        expect(TestModel.new(cuit: '20120112989', gender: 'F')).to be_invalid
+        expect(TestModel.new(cuit: '27049852032', gender: 'M')).to be_invalid
+      end
+      it 'must leave a specific message over :cuit in #errors array' do
+        record = TestModel.new(cuit: '20120112989', gender: 'F')
+        record.valid?
+        expect(record.errors[:cuit]).to match_array(['cuit_gender_incompatible'])
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'active_model'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'valicuit'
+
+I18n.load_path += Dir[File.expand_path(File.join(File.dirname(__FILE__), '../locales', '*.yml')).to_s]
+I18n.default_locale = :test
+
+class TestModel
+  include ActiveModel::Validations
+
+  attr_accessor :cuit, :dni, :gender
+
+  def initialize(attributes = {})
+    self.cuit   = attributes[:cuit]
+    self.dni    = attributes[:dni]
+    self.gender = attributes[:gender]
+  end
+end

data/valicuit.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'valicuit/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'valicuit'
+  s.version     = Valicuit::VERSION
+  s.authors     = ['Lautaro Nahuel De León']
+  s.email       = ['laudleon@gmail.com', 'ldeleon@cespi.unlp.edu.ar']
+  s.homepage    = 'http://github.com/lndl/valicuit'
+  s.summary     = %q{A CUIT/CUIL validator for ActiveModel & Rails}
+  s.description = %q{A CUIT/CUIL validator for ActiveModel & Rails with multiple customizable options}
+  s.licenses    = ['MIT']
+
+  s.add_runtime_dependency 'activemodel', '~> 4'
+
+  s.add_development_dependency 'rake', '~> 11.3'
+  s.add_development_dependency 'rspec', '~> 3.5'
+  s.add_development_dependency 'simplecov', '~> 0.12'
+  s.add_development_dependency 'codeclimate-test-reporter', '~> 1.0'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: valicuit
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Lautaro Nahuel De León
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: A CUIT/CUIL validator for ActiveModel & Rails with multiple customizable
+  options
+email:
+- laudleon@gmail.com
+- ldeleon@cespi.unlp.edu.ar
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- lib/active_model/validations/cuit_validator.rb
+- lib/valicuit.rb
+- lib/valicuit/engine.rb
+- lib/valicuit/version.rb
+- locales/es.yml
+- locales/test.yml
+- spec/cuit_validator_spec.rb
+- spec/spec_helper.rb
+- valicuit.gemspec
+homepage: http://github.com/lndl/valicuit
+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.5.1
+signing_key: 
+specification_version: 4
+summary: A CUIT/CUIL validator for ActiveModel & Rails
+test_files:
+- spec/cuit_validator_spec.rb
+- spec/spec_helper.rb