MX-ID 0.0.1.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c97a7fd9b2ed4c6157b6fce6cddc179e066ad90f
+  data.tar.gz: aacdcbcff79b8083d67148574cd9c545337bfc3e
+SHA512:
+  metadata.gz: 78cd1da4e9c78c109615a760db3e0fe8409e71feb6aed582cac69013b578dade9bf3794a0b0f176d3accd3d79842c1e8a21a23a73a034833686438cd46b25f42
+  data.tar.gz: 8369dccc130cd5a6063614d6a4e769fe3d5a60796b8305c7572b19f7860bc1832740e2e6e502d0ab08de3eb88d9631f5cfcc9b722d832ca4f90d622262dc3d90

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format progress
+--require spec_helper

data/.ruby-gemset

@@ -0,0 +1 @@
+mx-id

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.2.0

data/.travis.yml

@@ -0,0 +1,18 @@
+language: ruby
+
+before_install:
+  - gem install bundler -v '>= 1.5.1'
+
+bundler_args: --without ci_filter
+  
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+  - 2.2
+  - ruby-head
+  - jruby-19mode
+
+addons:
+  code_climate:
+    repo_token: 9fe9f9cbceefce33e5bbd46c28b97df24b01650457287a3d8a152315011ebf19 

data/.yardopts

@@ -0,0 +1,9 @@
+--title 'MX-ID'
+--output-dir ./doc
+--markup-provider redcarpet
+--markup markdown
+--protected --private
+--readme README.md
+lib/**/*.rb - LICENSE.txt REFERENCIAS.md
+
+

data/Gemfile

@@ -0,0 +1,34 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :ci_filter do
+  gem 'guard'
+  gem 'guard-bundler', require: false
+  gem 'guard-rspec', require: false
+  gem "pry"
+  gem "pry-remote"
+  gem "pry-byebug", platform: [:mri_20, :mri_21, :mri_22, :mri]
+  gem "pry-nav", platform: [:mri_19, :jruby]
+  gem 'terminal-notifier'
+  gem 'terminal-notifier-guard'
+end
+
+group :development, :test do
+  gem "bundler"
+  gem "rake"
+  gem "rspec", "~> 3.2"
+end
+
+group :test do
+  gem "coveralls", require: false
+  gem "codeclimate-test-reporter"
+  gem 'rspec-collection_matchers'
+  gem 'shoulda-matchers', require: false
+end
+
+group :doc do
+  gem 'yard'
+  gem 'redcarpet'
+  gem 'github-markup'
+end

data/Guardfile

@@ -0,0 +1,26 @@
+guard :rspec, cmd: "bundle exec rspec", cmd_additional_args: '-f progress', failed_mode: :focus do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end
+
+guard :bundler do
+  require 'guard/bundler'
+  require 'guard/bundler/verify'
+  helper = Guard::Bundler::Verify.new
+
+  files = ['Gemfile']
+  files += Dir['*.gemspec'] if files.any? { |f| helper.uses_gemspec?(f) }
+
+  # Assume files are symlinked from somewhere
+  files.each { |file| watch(helper.real_path(file)) }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Pablo Ruiz
+
+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/MX-ID.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'MX/ID/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "MX-ID"
+  spec.version       = MX::ID::VERSION # `git describe --tags --abbrev=0`.strip
+  spec.authors       = ["Pablo Ruiz"]
+  spec.email         = ["pjruiz@maquech.com.mx"]
+  spec.summary       = %q{Mexican government identifiers utilities / Utilerías para lidiar con identifcadores del gobierno mexicano}
+  spec.description   = %q{Mexican government identifiers utilities / Utilerías para lidiar con identifcadores del gobierno mexicano}
+  spec.homepage      = "https://github.com/Maquech/MX-ID"
+  spec.license       = "MIT"
+  spec.post_install_message = "¡Viva México!"
+
+  spec.required_ruby_version = '>= 1.9.3'
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'numbers_and_words'
+end

data/README.md

@@ -0,0 +1,113 @@
+# MX::ID
+
+Utilites for validation of Mexican government identifiers.
+
+---
+
+Utilerías para validación de identificadores del gobierno mexicano.
+
+## Why and what for / Por qué y para qué
+
+This gem is conceived as an utility for proyects that involve identifiers issued by the Mexican government to its citizens and organizations.
+
+For example, the R.F.C. (acronym in Spanish for Federal Taxpayer Registry) is an identifier issued by the Ministry of Tresasury and Public Credit for the different kind of taxpayers there is.
+
+This project is not endorsed in any way by the Mexican government.
+
+
+---
+
+Esta gema está pensada para usarse en proyectos que tienen que ver con las diversas formas en que el gobierno mexicano identifica a ciudadanos y organizaciones.
+
+Por ejemplo, el Registro Federal de Contribuyentes (R.F.C.) es un identificador expedido por la Secretaría de Hacienda y Crédito Público (SHCP) a través del Servicio de Administración Tributaria (SAT) para los distintos tipos de contribuyentes que existen.
+
+Este proyecto no está patrocinado de ninguna forma por el gobierno mexicano. Es un esfuerzo para contribuir a la sanidad mental de los programadores que tenemos que lidiar con estas cosas :)
+
+
+## Installation / Instalación
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mx-id'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mx-id
+
+---
+
+Agrega esta línea al archivo Gemfile de tu aplicación:
+
+```ruby
+gem 'mx-id'
+```
+
+Luego ejecuta:
+
+    $ bundle
+
+O instálalo tu mismo usando:
+
+    $ gem install mx-id
+
+
+## Usage / Uso
+
+### R.F.C. (Registro Federal de Contribuyentes)
+
+
+El Registro Federal de Contribuyentes (R.F.C.) es un identificador expedido por la Secretaría de Hacienda y Crédito Público (SHCP) a través del Servicio de Administración Tributaria (SAT) para los distintos tipos de contribuyentes que existen. Este identificador se encuentra en la Cédula de Identificación Fiscal que el SAT expide al inscribirse en este registro.
+
+El algoritmo aquí implementado para generar y validar un R.F.C. ha salido de varias fuentes en la red, pues al parecer el algoritmo para calcularlo ha cambiado con el paso del tiempo. Estas son algunas de los cambios que he notado:
+
+1. para personas morales registradas antes y después de 1998
+
+Pendiente...
+
+
+## Contributing / Contribuir
+
+1. Fork it ( https://github.com/Maquech/MX-ID/fork )
+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 a new Pull Request
+
+You can also submit technical observations on the algorithms here implemented alongside with references to official documentation that supports it.
+
+---
+
+Puedes contribuir mandándonos tus observaciones sobre la implementación de los algoritmos aquí implementados o referencias a documentos oficiales que las respalde.
+
+Ahora, diviérte con esta traducción (si sabes el término correcto en español, háznoslo saber por favor):
+
+1. Crea tu copia del repositorio ( https://github.com/Maquech/MX-ID/fork )
+2. Crea tu rama con la funcionalidad propuesta (`git checkout -b mi-nueva-funcionalidad-shubiduby`)
+3. Compromete tus cambios (`git commit -am 'Nueva funcionalidad shubiduby'`)
+4. Empuja la rama a tu repositorio (`git push origin mi-nueva-funcionalidad-shubiduby`)
+5. Crea una nueva petición de jalada|tirada|extracción|acarreo
+
+
+## Docs
+
+Use `bundle exec yard server --port 8828 --reload` para generar la documentación. También revisa las [referencias](REFERENCIAS.md)
+
+
+## Code status / Estado del código
+
+[![Build Status][Travis-CI-badge]][Travis-CI-url] [![Code Climate][Code Climate-badge]][Code Climate-url] [![Coverage Status][Coveralls-badge]][Coveralls-url]
+
+
+[Travis-CI-badge]: https://travis-ci.org/Maquech/MX-ID.svg?branch=master
+[Travis-CI-url]: https://travis-ci.org/Maquech/MX-ID
+[Code Climate-badge]: https://codeclimate.com/github/Maquech/MX-ID/badges/gpa.svg
+[Code Climate-url]: https://codeclimate.com/github/Maquech/MX-ID
+[Coveralls-badge]: https://coveralls.io/repos/Maquech/MX-ID/badge.svg?branch=master
+[Coveralls-url]: https://coveralls.io/r/Maquech/MX-ID?branch=master
+

data/REFERENCIAS.md

@@ -0,0 +1,8 @@
+## Referencias oficiales y no tan oficiales
+
+### Oficiales
+
+
+### No oficiales, pero confiables aparentemente
+
+1. [Solución Factible, especificación sobre el R.F.C](http://solucionfactible.com/sfic/capitulos/timbrado/rfc.jsp)

data/Rakefile

@@ -0,0 +1,15 @@
+begin
+  require 'bundler/gem_tasks'
+  require 'rspec/core/rake_task'
+  require 'yard'
+  YARD::Rake::YardocTask.new
+  
+  RSpec::Core::RakeTask.new(:spec, :tag) do |t, task_args|
+    t.rspec_opts = ["--tag #{task_args[:tag]}", "--format", "--color"]
+  end
+  
+  task default: :spec
+  task test: :spec
+rescue LoadError
+end
+

data/lib/MX/ID.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+#require "i18n"
+require "numbers_and_words"
+require "activesupport" unless defined?(ActiveSupport)
+require "MX/numero_romano"
+require "MX/ID/version"
+require "MX/ID/auxiliar"
+require "MX/ID/RFC"
+
+if defined?(I18n) # Dependencia de numbers_and_words
+  I18n.enforce_available_locales = false
+  I18n.default_locale = :es
+end

data/lib/MX/ID/RFC.rb

@@ -0,0 +1,424 @@
+# encoding: utf-8
+# @author Pablo Ruiz <pjruiz@maquech.com.mx>
+# @org Maquech Technology Services
+# @fecha 15/07/2014
+#
+# Herramientas para obtener y validar un Registro Federal de Contribuyentes para una persona moral o física.
+# @see {http://es.wikipedia.org/wiki/Registro_Federal_de_Contribuyentes_(M%C3%A9xico)} R.F.C (Wikipedia)
+#
+class MX::ID::RFC
+  include MX::ID::Auxiliar
+  
+  ### Tablas de los Anexos ###
+  ANEXO_I = {
+    " " => "00",
+    "0" => "00", "1" => "01", "2" => "02", "3" => "03", "4" => "04", "5" => "05", "6" => "06", "7" => "07", "8" => "08", "9" => "09",
+    "&" => "10",
+    "A" => "11", "B" => "12", "C" => "13", "D" => "14", "E" => "15", "F" => "16", "G" => "17", "H" => "18", "I" => "19", "J" => "21",
+    "K" => "22", "L" => "23", "M" => "24", "N" => "25", "O" => "26", "P" => "27", "Q" => "28", "R" => "29", "S" => "32", "T" => "33",
+    "U" => "34", "V" => "35", "W" => "36", "X" => "37", "Y" => "38", "Z" => "39", "Ñ" => "40"
+  }.freeze
+  ### Anexo II ###
+  ANEXO_II = {
+    "0" => "1", "1" => "2", "2" => "3", "3" => "4", "4" => "5", "5" => "6", "6" => "7", "7" => "8", "8" => "9",
+    "9" => "A", "10" => "B", "11" => "C", "12" => "D", "13" => "E", "14" => "F", "15" => "G", "16" => "H",
+    "17" => "I", "18" => "J", "19" => "K", "20" => "L", "21" => "M", "22" => "N", "23" => "P", "24" => "Q",
+    "25" => "R", "26" => "S", "27" => "T", "28" => "U", "29" => "V", "30" => "W", "31" => "X", "32" => "Y",
+    "33" => "Z"
+  }.freeze
+  ### Termina tablas Anexo II ###
+   
+  ### Anexo III ###
+  ANEXO_III = {
+    "0" => 0, "1" => 1, "2" => 2, "3" => 3, "4" => 4, "5" => 5, "6" => 6, "7" => 7, "8" => 8, "9" => 9,
+    "A" => 10, "B" => 11, "C" => 12, "D" => 13, "E" => 14, "F" => 15, "G" => 16, "H" => 17, "I" => 18, "J" => 19,
+    "K" => 20, "L" => 21, "M" => 22, "N" => 23, "&" => 24, "O" => 25, "P" => 26, "Q" => 27, "R" => 28, "S" => 29,
+    "T" => 30, "U" => 31, "V" => 32, "W" => 33, "X" => 34, "Y" => 35, "Z" => 36, " " => 37, "Ñ" => 38
+  }.freeze
+  ### Termina tablas Anexo III ###
+  
+  ### Anexo IV ###
+  ANEXO_IV = [
+    "BUEI", "BUEY", "CACA", "CACO", "CAGA", "CAGO", "CAKA", "CAKO", "COGE", "COJA", "COJE", "COJI", "COJO", "CULO",
+    "FETO", "GUEY", "JOTO", "KACA", "KACO", "KAGA", "KAGO", "KAKA", "KOGE", "KOJO", "KULO", "MAME", "MAMO", "MEAR",
+    "MEAS", "MEON", "MION", "MOCO", "MULA", "PEDA", "PEDO", "PENE", "PUTA", "PUTO", "QULO", "RATA", "RUIN"
+  ].freeze
+  ### Termina tablas Anexo IV ###
+  
+  ### Anexo V ###
+  ANEXO_V_PERSONA_MORAL_COMPUESTAS = [
+    "A EN P", "S DE RL", "S EN C", "S EN C POR A", "S EN NC", "SA DE CV", "SA DE CV MI", "SA MI", "SOCIEDAD", "SOFOM ENR",
+    "SRL CV", "SRL CV MI", "SRL MI"
+  ].freeze
+  
+  ANEXO_V_PERSONA_MORAL_SIMPLES = [
+    "A", "AL", "AND", "CIA", "CO", "COMPA&IA", "COMPA&ÍA", "COMPANY", "COMPAÑÍA", "COMPAÑIA", "CON", "COOP", "COOPERATIVA", "DE", "DEL", "E", "EL", "EN", 
+    "LA", "LAS", "LOS", "MAC", "MC", "MI", "OF", "PARA", "POR", "SA", "SC", "SCL", "SCS", "SNC", "SOC", "SOCIEDAD", "SUS", "THE",
+    "VAN", "VON", "Y"
+  ].freeze
+  
+  ANEXO_V_PERSONA_FISICA = [ "DE", "DEL", "LA", "LAS", "LOS", "MAC", "MC", "MI", "VAN", "VON", "Y" ].freeze
+  ### Termina tablas Anexo V ###
+  
+  ### Anexo VI ###
+  ANEXO_VI_PERSONA_MORAL = {
+    '@' => 'ARROBA', "'" => 'APOSTROFE', '%' => 'PORCIENTO', '#' => 'NUMERO', '!' => 'ADMIRACION', '.' => 'PUNTO',
+    '$' => 'PESOS', '"' => 'COMILLAS', '-' => 'GUION', '/' => 'DIAGONAL', '+' => 'SUMA', '(' => 'ABRE PARENTESIS',
+    ')' => 'CIERRA PARENTESIS'
+  }.freeze
+  
+  ANEXO_VI_PERSONA_FISICA = { "'" => 'APOSTROFE', '.' => 'PUNTO' }.freeze
+  ### Termina tablas Anexo VI ###
+  
+  # Expresión regular para identificar los símbolos permitidos acorde al Anexo VI para personas Morales
+  #
+  REGEXP_SIMBOLO_PERSONA_MORAL = /#{ANEXO_VI_PERSONA_MORAL.keys.map{|k| Regexp.escape(k)}.join("|")}/.freeze
+  
+  # Expresión regular para identificar los símbolos permitidos acorde al Anexo VI para personas Físicas
+  #
+  REGEXP_SIMBOLO_PERSONA_FISICA = /#{ANEXO_VI_PERSONA_FISICA.keys.map{|k| Regexp.escape(k)}.join("|")}/.freeze
+  
+  # Vocales
+  #
+  VOCALES = ["A", "E", "I", "O", "U"].freeze
+  # Expresión regular para identificar vocales
+  #
+  REGEXP_VOCALES = /#{VOCALES.join("|")}/.freeze
+  
+  # Consonantes
+  #
+  CONSONANTES = [ "B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z", "Ñ" ].freeze
+  
+  # Expresión regular para identificar vocales
+  #
+  REGEXP_CONSONANTES = /#{CONSONANTES.join("|")}/.freeze
+  
+  # Símbolos válidos para personas morales
+  SIMBOLOS_PERSONA_MORAL = ANEXO_VI_PERSONA_MORAL.keys.freeze
+  
+  # Símbolos válidos para personas físicas
+  SIMBOLOS_PERSONA_FISICA = ANEXO_VI_PERSONA_FISICA.keys.freeze
+  
+  # Expresión regular para validar R.F.C. de persona moral con grupos de captura con nombres
+  #
+  REGEXP_PERSONA_MORAL = /\A(?<iniciales>[A-ZÑ&]{3})(?<año>[0-9]{2})(?<mes>[0-1][0-9])(?<dia>[0-3][0-9])(?<homoclave>[A-Z0-9]{2})(?<verificador>[0-9A])\z/i.freeze
+  
+  # Expresión regular para validar R.F.C. de persona física con grupos de captura con nombres
+  #
+  REGEXP_PERSONA_FISICA = /\A(?<iniciales>[A-ZÑ&]{4})(?<año>[0-9]{2})(?<mes>[0-1][0-9])(?<dia>[0-3][0-9])(?<homoclave>[A-Z0-9]{2})(?<verificador>[0-9A])\z/i.freeze
+  
+  # Al parecer los RFCs de personas morales anteriores a este año tomaban en cuenta el tipo de razón social para calcular la clave diferenciadora de homonimia.
+  #
+  AÑO_CAMBIO_CALCULO_CVE_HOMONIMIA = 2008
+  
+  # RFC para operaciones con el público en general
+  RFC_PUBLICO_GENERAL = "XAXX010101000".freeze
+  
+  # RFC para operaciones con extranjeros
+  RFC_EXTRANJEROS = "XEXX010101000".freeze
+  
+  class << self
+    
+    # Valida el R.F.C. dado.
+    #
+    # @param [String] rfc Un R.F.C.
+    # @param [Date] fecha La fecha de nacimiento o de constitución.
+    # @param [String] msgs Mensajes de error. La cadena vacía por default.
+    # @param [Boolean] persona_fisica True para indicar que el R.F.C. corresponde a una persona física, false cuando corresponde a una persona moral. Default true.
+    # @return [Boolean] True si es válido el R.F.C., false de lo contrario.
+    #
+    def valido?(rfc, fecha = nil, msgs = "", persona_fisica = true)
+      msgs = "" if msgs.nil?
+      msg = []
+      unless rfc.blank?
+        return true if rfc == RFC_EXTRANJEROS or rfc == RFC_PUBLICO_GENERAL
+        errores = false
+        error_match = true
+        rfc.match(persona_fisica ? REGEXP_PERSONA_FISICA : REGEXP_PERSONA_MORAL) {|m|
+          errores = !fecha_coincide?(m[:dia], m[:mes], m[:año], fecha, 
+            (persona_fisica ? "nacimiento" : "constitución"), msg)
+          if digito_verificador(rfc[0..-2]) != m[:verificador] 
+            errores = true
+            msg << "El dígito verificador es incorrecto."
+          end
+          error_match = false
+        }
+        if error_match
+          longitud_rfc_valida = persona_fisica ? 13 : 12
+          if rfc.size != longitud_rfc_valida
+            msg << "No tiene la longitud correcta (#{longitud_rfc_valida} caracteres)."
+          else
+            msg << "No tiene el formato correcto."
+          end
+        end
+        msgs << msg.join(" ")
+        !errores && !error_match
+      else
+        msgs << "No debe estar vacío."
+        false
+      end
+    end
+    
+    # Regresa el Registro Federal de Contribuyentes (R.F.C.) de una persona física de acuerdo a su nombre completo y fecha de nacimiento.
+    # Tomar en cuenta las siguientes condiciones para los parámetros:
+    #  1. Todos los parámetros deben escribirse en mayúsculas.
+    #  2. Convertir letras acentuadas a la letra sin acento.
+    #  3. Los símbolos permitidos son el punto "." y el apóstrofe "'". 
+    #  4. La información debe tomarse tal cual se encuentra en el acta de nacimiento.
+    # 
+    # @param [String] nombres Nombres de la persona física.
+    # @param [String] apellido_paterno Nombres completo, incluir artículos, preposiciones y conjunciones.
+    # @param [String] apellido_materno Apellido paterno completo, incluir artículos, preposiciones y conjunciones.
+    # @param [Date] fecha_nacimiento fecha de nacimiento.
+    # @return [String] El R.F.C. de la persona física con Homoclave y dígito verificador
+    #
+    def persona_fisica(nombres, apellido_paterno, apellido_materno, fecha_nacimiento)
+      nombres_limpios, apellido_paterno_limpio, apellido_materno_limpio = procesar_nombre_completo(nombres, 
+        apellido_paterno, apellido_materno)
+      rfc = primeras_cuatro_letras(nombres_limpios, apellido_paterno_limpio, apellido_materno_limpio) +
+        fecha_con_formato(fecha_nacimiento) +
+        clave_diferenciadora_homonimia(nombre_reverso(nombres, apellido_paterno, apellido_materno))
+      rfc + digito_verificador(rfc)
+    end
+  
+    # Regresa el Registro Federal de Contribuyentes (R.F.C.) de una persona moral de acuerdo a la denominación o razón social completa.
+    # Tomar en cuenta las siguientes condiciones para los parámetros:
+    #  1. Todos los parámetros deben escribirse en mayúsculas.
+    #  2. Convertir letras acentuadas a la letra sin acento.
+    #  3. @see ANEXO_VI_PERSONA_MORAL para los símbolos permitidos. 
+    #  4. La información debe tomarse tal cual se encuentra en el acta constitutiva (incluir el tipo de sociedad, i.e. SA de CV).
+    # 
+    # @param [String] razon_social Razón o denominación social completa, incluir artículos, preposiciones, conjunciones y tipo de sociedad.
+    # @param [Date] fecha_constitucion fecha de constitución de la empresa.
+    # @return [String] El R.F.C. de la persona moral con Homoclave y dígito verificador
+    #
+    def persona_moral(razon_social, fecha_constitucion)
+      rfc = primeras_tres_letras(razon_social) + fecha_con_formato(fecha_constitucion) +
+        clave_diferenciadora_homonimia(razon_social_para_clave_diferenciadora_homonimia(razon_social, fecha_constitucion))
+      rfc + digito_verificador(rfc)
+    end
+    
+    # Método para obtención de la Clave Diferenciadora de Homonimia (Homoclave)
+    #
+    # @param [String] nombre_o_razon_social el nombre o la razón social conteniendo caracteres válidos.
+    #  En caso de ser persona física el nombre debe estar acomodado como "Paterno Materno Nombres" y estar completo, i.e. 'DEL LEON RUIZ JOSE ANGEL'.
+    #  En caso se ser persona moral incluir el tipo de sociedad, i.e. 'OPERACIONES EVE SA DE CV'
+    # @return [String] la Clave Diferenciadora de Homonimia (Homoclave)
+    #
+    def clave_diferenciadora_homonimia(nombre_o_razon_social)
+      cadena_anexo_1 = obtener_cadena_anexo_1(nombre_o_razon_social)
+      ultimas_tres_cifras_resultado = multiplicar_y_sumar(cadena_anexo_1).to_s[-3..-1].to_i
+      cociente_y_residuo = ultimas_tres_cifras_resultado.divmod(34)
+      return ANEXO_II[cociente_y_residuo[0].to_s] + ANEXO_II[cociente_y_residuo[1].to_s]
+    end
+    
+    # Método para obtención del Dígito Verificador
+    #
+    # @param [String] rfc el R.F.C. a 11 ó 12 posiciones (persona moral o física respectivamente).
+    # @return [String] el Dígito Verificador.
+    #
+    def digito_verificador(rfc)
+      raise ArgumentError.new("la longitud del R.F.C. es incorrecta. Usar 11 o 12 caracteres.") unless rfc.size.between?(11,12)
+      rfc_12_posiciones = rfc.size == 11 ? " " + rfc : rfc
+      suma = 0
+      13.downto(2){ |i| suma += ANEXO_III[rfc_12_posiciones[(i-13)*(-1)]].to_i * i }
+      residuo = suma % 11
+      return "0" if residuo.zero?
+      resta = 11 - residuo
+      resta == 10 ? "A" : resta.to_s
+    end
+    
+    private
+      
+      #### Métodos auxiliares para R.F.C. de personas morales
+      
+      def razon_social_para_clave_diferenciadora_homonimia(razon_social, fecha_constitucion)
+        elementos = quitar_tipo_razon_social(razon_social).split(" ")
+        elementos = sustituir_abreviaturas(elementos)
+        elementos = sustituir_simbolos_individuales_persona_moral(elementos)
+        elementos = sustituir_numeros(elementos)
+        if fecha_constitucion.year < AÑO_CAMBIO_CALCULO_CVE_HOMONIMIA
+          elementos << obtener_tipo_sociedad(razon_social)
+        end
+        quitar_simbolos_persona_moral(elementos).join(" ")
+      end
+      
+      def obtener_tipo_sociedad(razon_social)
+        tipo_sociedad = nil
+        regexp = /\A(#{ANEXO_V_PERSONA_MORAL_COMPUESTAS.join(")|(")})/
+        regexp.match(razon_social) do |m|
+          tipo_sociedad = m.captures.compact.first
+        end
+        return tipo_sociedad
+      end
+
+      def primeras_tres_letras(razon_social)
+        elementos = quitar_elementos_sobrantes_clave(razon_social)
+        elementos = sustituir_abreviaturas(elementos)
+        elementos = sustituir_simbolos_individuales_persona_moral(elementos)
+        elementos = quitar_simbolos_persona_moral(elementos)
+        elementos = sustituir_numeros(elementos)
+        obtener_tres_letras_iniciales(elementos)
+      end
+      
+      def quitar_elementos_sobrantes_clave(razon_social)
+        elementos = quitar_tipo_razon_social(razon_social).split(" ") 
+        for elemento in elementos # regla 9ª, 11ª
+          elementos.delete(elemento) if ANEXO_V_PERSONA_MORAL_SIMPLES.member?(elemento)
+        end
+        return elementos
+      end
+      
+      def quitar_tipo_razon_social(razon_social)
+        regexp = /\A(#{ANEXO_V_PERSONA_MORAL_COMPUESTAS.join("\s?)|(")}\s?)/
+        razon_social.gsub(regexp, "").strip # regla 5ª
+      end
+      
+      def sustituir_abreviaturas(elementos_razon_social)
+        elementos = elementos_razon_social.dup
+        sustituciones = {}
+        elementos_razon_social.each_with_index do |elemento, index|
+          nvo = abreviatura_a_palabras(elemento)
+          sustituciones[index] = nvo unless nvo.nil?
+        end
+        sustituciones.each_pair{|k,v| elementos[k] = v}
+        return elementos.join(" ").split(" ")
+      end
+      
+      def abreviatura_a_palabras(elemento)
+        elemento.gsub(/\./, " ").strip if elemento =~ /\A[A-ZÑ]{1}\.([A-ZÑ]\.){0,2}/
+      end
+      
+      def sustituir_simbolos_individuales_persona_moral(elementos_razon_social)
+        elementos = elementos_razon_social.dup
+        elementos_razon_social.each_with_index do |elemento, index|
+          elementos[index] = ANEXO_VI_PERSONA_MORAL[elemento] if ANEXO_VI_PERSONA_MORAL.member?(elemento)
+        end
+        return elementos
+      end
+      
+      def quitar_simbolos_persona_moral(elementos_razon_social)
+        simbolos = ANEXO_VI_PERSONA_MORAL.keys.map{|s| Regexp.escape(s)}
+        elementos_razon_social.join(" ").gsub( /#{simbolos.join("|")}/, "").split(" ")
+      end
+      
+      def sustituir_numeros(elementos_razon_social)
+        elementos = elementos_razon_social.dup
+        elementos_razon_social.each_with_index do |elemento, index|
+          if elemento =~ /\A[-+]?[0-9]+\z/
+            elementos[index] = numero_a_palabras(elemento.to_i).upcase
+          elsif NumeroRomano.romano?(elemento)
+            elementos[index] = numero_a_palabras(NumeroRomano.a_decimal(elemento)).upcase
+          else
+            next
+          end
+        end
+        return elementos
+      end
+      
+      def obtener_tres_letras_iniciales(elementos_razon_social)
+        case elementos_razon_social.size
+        when 3
+          elementos_razon_social[0][0] + elementos_razon_social[1][0] + elementos_razon_social[2][0]
+        when 2
+          elementos_razon_social[0][0] + elementos_razon_social[1][0..1]
+        when 1
+          if elementos_razon_social[0].size >= 3
+            elementos_razon_social[0][0..2]
+          else
+            elementos_razon_social[0] + ("X" * (3 - elementos_razon_social[0].size)) # regla 8
+          end
+        end
+      end
+      
+      
+      
+      #### Métodos auxiliares para R.F.C. de personas físicas
+      
+      def nombre_reverso(nombres, apellido_paterno, apellido_materno)
+        apellidos = if en_blanco?(apellido_materno)
+          sustituir_simbolos_persona_fisica(apellido_paterno).strip
+        elsif en_blanco?(apellido_paterno)
+          sustituir_simbolos_persona_fisica(apellido_materno)
+        else
+          "#{sustituir_simbolos_persona_fisica(apellido_paterno).strip} #{sustituir_simbolos_persona_fisica(apellido_materno)}"
+        end
+        "#{apellidos} #{sustituir_simbolos_persona_fisica(nombres)}"
+      end
+      
+      def procesar_nombre_completo(nombres, apellido_paterno, apellido_materno)
+        regexp = /\A(#{ANEXO_V_PERSONA_FISICA.join("\s)|(")}\s)/
+        nombres_limpios = sustituir_simbolos_persona_fisica(nombres.gsub(regexp, "")).strip
+        apellido_paterno_limpio = sustituir_simbolos_persona_fisica(apellido_paterno.gsub(regexp, "")).strip unless en_blanco?(apellido_paterno)
+        apellido_materno_limpio = sustituir_simbolos_persona_fisica(apellido_materno.gsub(regexp, "")).strip unless en_blanco?(apellido_materno)
+        [nombres_limpios, apellido_paterno_limpio, apellido_materno_limpio]
+      end
+      
+      def primeras_cuatro_letras(nombres, apellido_paterno, apellido_materno)
+        if en_blanco?(apellido_materno)
+          regla_7(nombres, apellido_paterno)
+        elsif en_blanco?(apellido_paterno)
+          regla_7(nombres, apellido_materno)
+        elsif !apellido_paterno.nil? and apellido_paterno.size.between?(1,2)
+          regla_4(nombres, apellido_paterno, apellido_materno)
+        else
+          letras_apellido_paterno(apellido_paterno) + apellido_materno[0] + letra_nombres(nombres)
+        end
+      end
+      
+      def sustituir_simbolos_persona_fisica(cadena)
+        sustitucion = cadena.dup
+        ANEXO_VI_PERSONA_FISICA.each_pair{ |llave, valor| sustitucion.gsub!(llave, valor[0]) }
+        return sustitucion
+      end
+      
+      def filtro_cuatro_letras_convenientes(cuatro_letras)
+        ANEXO_IV.member?(cuatro_letras) ? cuatro_letras[0..2] + "X" : cuatro_letras
+      end
+      
+      def letra_nombres(nombres)
+        # Primera letra primer nombre
+        obtener_primer_nombre_valido(nombres)[0]
+      end
+      
+      def letras_apellido_paterno(apellido_paterno)
+        # Primera letra y primera vocal
+        primera_vocal = nil
+        apellido_paterno[1..-1].each_char do |c|
+          if VOCALES.member?(c)
+            primera_vocal = c
+            break
+          end
+        end
+        apellido_paterno[0] + (primera_vocal || "X")
+      end
+      
+      def regla_4(nombres, apellido_paterno, apellido_materno)
+        apellido_paterno[0] + apellido_materno[0] + obtener_primer_nombre_valido(nombres)[0..1]
+      end
+      
+      def regla_7(nombres, apellido)
+        apellido[0..1] + obtener_primer_nombre_valido(nombres)[0..1]
+      end
+
+      def obtener_cadena_anexo_1(nombre_o_razon_social)
+        cadena_anexo_1 = ""
+        nombre_o_razon_social.each_char{|c| cadena_anexo_1 << ANEXO_I[c]}
+        cadena_anexo_1.prepend("0") if cadena_anexo_1.size.even?
+        return cadena_anexo_1
+      end
+      
+      def multiplicar_y_sumar(cadena_anexo_1)
+        suma = 0
+        cadena_anexo_1.split("").each_with_index do |actual, idx|
+          idx_siguiente = idx + 1
+          if idx_siguiente < cadena_anexo_1.size
+            siguiente = cadena_anexo_1[idx_siguiente]
+            suma += (actual + siguiente).to_i * siguiente.to_i
+          end
+        end
+        return suma
+      end
+
+  end
+end