CurpMX 0.3.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7819449ad32b97f499f11eb10f68db65583939637084330439c750c898e11e98
-  data.tar.gz: 604fb5e29eeef5d75879de5ae325430012484253765239724d8e95c882a6fcf1
+  metadata.gz: 0b322b557bf790e15b26b0d5d950f370e1e56d458e49e74490746d2eac61433f
+  data.tar.gz: 7af4e03b90b08fab6cfedfa9d49484219ba48bb5eeff27f9bf587ac93b9a1d8b
 SHA512:
-  metadata.gz: f1b4c3b213baa582c13107df963805b42b3a52a18fec062f4689e638b35f9d3160c62bd76d277da365841298b1ec4ee2de505adc118377e32781748d7d4ca46f
-  data.tar.gz: c9f9256bcdde887f8ec5f0d328cc1e5f67876b264acaaa940d55639071b9c0a7e666a7420964b9041b08c200794cad0da552c80bea8ea53bdfca1f997c8ef604
+  metadata.gz: f2133105cf7c325814b4a485abe0d457e2f3f35f6e5acc5b266f7b1346d6fa6eab620f5070ed50ccba8c9ffb4b92e73ddbc41d172dc460a34826db6af0c68e56
+  data.tar.gz: 39322eb5225a390fcaa7e9ab2d8119d1db09d62aaaa247268466f79c9ba69d873c5359f693baa2034cab76eb17872edde252b09ed6affc97c465669ebbc517d3

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/CHANGELOG.md

@@ -0,0 +1,49 @@
+# Changelog
+
+Formato basado en [Keep a Changelog](https://keepachangelog.com/es-ES/1.0.0/),
+y este proyecto sigue [Versionado Semántico](https://semver.org/lang/es/).
+
+## [1.0.1] - 2026-07-04
+
+### Cambiado
+- La gema se publica bajo el nombre existente `CurpMX` (RubyGems rechaza
+  `curp_mx` por ser demasiado similar). La ruta de `require` sigue siendo
+  `curp_mx`.
+
+## [1.0.0] - 2026-07-04
+
+Primera versión funcional y estable. `CurpMx::Validator` valida la formación de
+un CURP conforme al Instructivo Normativo (DOF 18-10-2021) y a las Reglas para
+la ejecución de los procedimientos para la asignación de la CURP.
+
+### Agregado
+- Validación del dígito verificador (posición 18) con el algoritmo del RENAPO,
+  disponible también como `CurpMx::Validator.check_digit`.
+- Aceptación del marcador de sexo `X` (CURPs de género no binario).
+- Aceptación de CURPs anteriores y posteriores al año 2000 (homoclave `0-9` o
+  `A-J` en la posición 17).
+- Código de entidad `NE` (nacido en el extranjero).
+- Normalización de la entrada a mayúsculas.
+- Manejo seguro de entradas `nil` o que no son cadenas (regresan `format` en
+  lugar de lanzar una excepción).
+
+### Cambiado
+- Catálogo de palabras altisonantes ampliado a las 82 entradas del Anexo 01.
+- Catálogo de entidades corregido a los 33 códigos del Anexo 03 (se eliminó el
+  código inexistente `CX`; la Ciudad de México es `DF`).
+- Reescritura interna del validador: búsquedas con `Set`, extracción por
+  posición fija y `String#match?`, sin asignar `MatchData`. La validación
+  completa es ~2x más rápida que la implementación previa.
+
+### Eliminado
+- Dependencia de `parslet`. La gema ya no tiene dependencias en tiempo de
+  ejecución (solo la librería estándar de Ruby).
+
+### Corregido
+- Los errores de `state` y `problematic_name` lanzaban `NoMethodError` porque
+  el arreglo de errores nunca se inicializaba.
+- El formato rechazaba todo CURP emitido a partir del año 2000 (posición 17 con
+  letra).
+
+[1.0.1]: https://github.com/hslzr/curp_mx/releases/tag/v1.0.1
+[1.0.0]: https://github.com/hslzr/curp_mx/releases/tag/v1.0.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 TODO: Write your name
+
+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,178 @@
+# CurpMx
+
+Librería para validar CURPs. Nada complicado: esencialmente un regex más un
+par de comprobaciones que regresan una lista de errores, de haber alguno.
+
+Sin dependencias en tiempo de ejecución (solo usa la librería estándar de Ruby).
+
+## Instalación
+
+Agrega la gema a tu `Gemfile`:
+
+```ruby
+gem "curp_mx"
+```
+
+Y luego:
+
+```bash
+bundle install
+```
+
+O instálala directamente:
+
+```bash
+gem install curp_mx
+```
+
+## Uso
+
+### Validación rápida
+
+Cuando solo te interesa saber si el CURP es válido o no:
+
+```ruby
+CurpMx::Validator.valid?("TOGG641009HJCRML99")
+#=> true | false
+```
+
+### Validación a detalle
+
+Cuando necesitas saber *por qué* un CURP es inválido:
+
+```ruby
+validator = CurpMx::Validator.new("TOGG641009HZZRML99")
+# El método #validate se llama automáticamente al inicializar.
+
+validator.valid?
+#=> false
+
+validator.errors
+#=> { :state => ["Invalid state: 'ZZ'"] }
+```
+
+Si el formato no coincide con el de un CURP, la validación se detiene ahí y
+solo se reporta el error de `format`:
+
+```ruby
+CurpMx::Validator.new("no-es-un-curp").errors
+#=> { :format => ["Invalid format"] }
+```
+
+Un CURP válido regresa un hash de errores vacío:
+
+```ruby
+validator = CurpMx::Validator.new("TOGG641009HJCRML99")
+validator.valid?  #=> true
+validator.errors  #=> {}
+```
+
+## Validaciones
+
+`errors` es un `Hash` donde cada llave es el campo con problema y su valor es un
+arreglo de mensajes.
+
+| Llave | Significado |
+|:--- |:---|
+| `format` | El formato no coincide con el de un CURP |
+| `state` | El estado no coincide con las abreviaciones del RENAPO |
+| `problematic_name` | Las iniciales forman una palabra altisonante (ej. `CACA`) |
+| `birth_day` | Día de nacimiento `<= 0` o `> 31` |
+| `birth_month` | Mes de nacimiento `<= 0` o `> 12` |
+| `birth_date` | Fecha de nacimiento inexistente (ej. `30/02/1989`) |
+| `check_digit` | El dígito verificador (posición 18) no coincide con el calculado |
+
+## Notas
+
+- Se aceptan los marcadores de sexo `H`, `M` y `X`.
+- Se aceptan CURPs anteriores y posteriores al año 2000 (la homoclave puede ser
+  dígito o letra).
+- Se valida el dígito verificador (posición 18) con el algoritmo del RENAPO.
+  También se puede calcular por separado a partir de los primeros 17 caracteres:
+
+  ```ruby
+  CurpMx::Validator.check_digit("BEBE900101HDFXXX0") #=> 7
+  ```
+
+## Dígito verificador
+
+### Cómo se dedujo
+
+El algoritmo del dígito verificador **no aparece publicado** en el Instructivo
+Normativo: éste solo describe la posición 18 como *"un carácter asignado […] a
+través de la aplicación de un algoritmo que permite calcular y verificar la
+correcta conformación de la clave"*, sin dar la fórmula ni la tabla de valores.
+
+Por eso el algoritmo de esta gema es, en parte, **ingeniería inversa**. Se
+partió del algoritmo estándar del RENAPO que circula públicamente y se confirmó
+de forma empírica contra CURPs reales, válidas y conocidas: para cada una se
+calculó el dígito a partir de sus primeros 17 caracteres y se comparó con el
+carácter 18 real. Varias CURPs independientes coinciden, así que la confianza es
+alta, pero conviene tenerlo presente: **es la única regla de la gema que no está
+respaldada por una fuente oficial directa**, sino por verificación empírica.
+
+Sugiero ampliamente hacer validaciones con CURPs propias para corroborar que, en
+CURPs ya existentes y en circulación, este algoritmo siga siendo válido. Si tu
+CURP es detectada como no válida puedes crear un issue en este repo para refinar
+el cálculo.
+
+### Cómo funciona
+
+Dados los primeros 17 caracteres del CURP:
+
+1. **Valor de cada carácter.** Los dígitos `0`–`9` valen `0`–`9`. Las letras
+   `A`–`N` valen `10`–`23`, y las letras `O`–`Z` valen `25`–`36`.
+
+2. **Suma ponderada.** Cada valor se multiplica por un peso descendente según su
+   posición: el primer carácter por `18`, el segundo por `17`, … y el carácter
+   17 por `2`. Se suman todos los productos.
+
+3. **Complemento a 10.** El dígito verificador es `(10 - (suma mod 10)) mod 10`,
+   siempre un número del `0` al `9`.
+
+Ejemplo con `BEBE900101HDFXXX0` (17 caracteres):
+
+```
+  B  E  B  E  9  0  0  1  0  1  H  D  F  X  X  X  0
+ 11 14 11 14  9  0  0  1  0  1 17 13 15 34 34 34  0   ← valor
+×18 17 16 15 14 13 12 11 10  9  8  7  6  5  4  3  2   ← peso
+
+suma = 1693 ;  1693 mod 10 = 3 ;  (10 - 3) mod 10 = 7  →  dígito = 7
+```
+
+Por eso `BEBE900101HDFXXX07` es válido.
+
+Internamente el cálculo se hace sobre los bytes ASCII (los tres tramos de
+valores son contiguos), sin construir tablas ni objetos, para que sea rápido.
+
+## Desarrollo
+
+```bash
+bin/setup        # instala dependencias
+bundle exec rspec # corre las pruebas
+```
+
+## Normativa
+La gema en su estado actual valida la formación del CURP de acuerdo al
+**Instructivo Normativo Para La Asignación De La Clave Única De Registro De
+Población**, publicado en el Diario Oficial de la Federación el día 18 de
+Octubre de 2021. El documento en formato PDF puede ser leído [en este
+enlace](https://www.gob.mx/cms/uploads/attachment/file/337251/Instructivo_Normativo_para_la_Asignacion_de_la_CURP.pdf)
+
+Sin embargo, cabe aclarar que **no soy abogado**, así que mis fuentes podrían no
+ser las más precisas. Durante mi investigación, encontré además las [REGLAS PARA
+LA EJECUCIÓN DE LOS PROCEDIMIENTOS PARA LA ASIGNACIÓN DE LA CLAVE ÚNICA DE
+POBLACIÓN](https://www.gob.mx/cms/uploads/attachment/file/960109/Reglas_para_la_Ejecucion_de_los_Procedimientos_para_la_Asignacion_de_la_CURP.pdf),
+que si bien no contradice el documento anterior, ésta tiene ejemplos más
+precisos y un par de anexos para la validación de los datos – la lista de
+palabras altisonantes en la página 86, por ejemplo.
+
+La gema actual permite el uso de la letra `X` en el
+género del individuo a pesar de no estar dentro de la normativa; esto debido a
+un antecedente de [una CURP emitida en
+2023](https://quinto-poder.mx/orgullomx/2023/2/23/expiden-la-primera-curp-de-genero-no-binario-18792.html),
+lo que implica que más CURPs con formato similar podrían existir allá afuera.
+
+## Licencia
+
+Disponible como software libre bajo los términos de la [licencia MIT](LICENSE.txt).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/curp_mx.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "lib/curp_mx/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "CurpMX"
+  spec.version = CurpMx::VERSION
+  spec.authors = ["Salazar"]
+
+  spec.summary = "Parse and validate CURP (Clave Única de Registro de Población) from Mexico."
+  spec.description = "Parse and validate CURP (Clave Única de Registro de Población) from Mexico."
+  spec.homepage = "https://github.com/hslzr/curp_mx"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git appveyor Gemfile])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # No runtime dependencies: validation is a regex + stdlib Date.
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/curp_mx/validator.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'set'
+
+module CurpMx
+  # Validates a CURP's format and a few data points in it.
+  #
+  # Hot-path notes: the format check uses String#match? (no MatchData
+  # allocation) and fields are read by fixed offset. Lookups go through
+  # frozen Sets, not Array scans. See spec + benchmarks.
+  class Validator
+    attr_reader :errors, :raw_input
+
+    # Format only — no captures. Fields are sliced by offset afterwards.
+    #   0-3  name initials      4-5 year   6-7 month   8-9 day
+    #   10   sex                11-12 state            13-15 consonants
+    #   16   homoclave          17 check digit
+    #
+    # Position 16 (homoclave/century): 0-9 for births before 2000, A-J for
+    # 2000 onward, per the Instructivo Normativo (DOF 18-10-2021).
+    # Sex accepts X (non-binary CURPs issued since 2023) beyond the H/M
+    # in that same text.
+    FORMAT = /\A[A-Z]{4}\d{2}[0-1]\d[0-3]\d[HMX][A-Z]{2}[^AEIOU]{3}[0-9A-J]\d\z/.freeze
+
+    # Entity codes for positions 12-13, from Anexo 03 "Catálogo de
+    # Entidades Federativas para la conformación de la CURP" of the
+    # Instructivo Normativo (DOF 18-10-2021). 32 entities (Mexico City is
+    # DF; there is no CX) plus NE for people born abroad.
+    STATES_RENAPO = %w[AS BC BS CC CL CM CS CH DF DG GT GR HG JC MC MN MS
+                       NT NL OC PL QT QR SP SL SR TC TS TL VZ YN ZS NE].freeze
+
+    # Problematic name initials (RENAPO substitutes the 2nd letter with X
+    # when the first four letters spell one of these). Full catalog of 82
+    # words from Anexo 01 "Catálogo de palabras altisonantes" of the
+    # Instructivo Normativo (DOF 18-10-2021).
+    NAME_ISSUES = %w[BACA BAKA BUEI BUEY CACA CACO CAGA CAGO CAKA CAKO
+                     COGE COGI COJA COJE COJI COJO COLA CULO FALO FETO
+                     GETA GUEI GUEY JETA JOTO KACA KACO KAGA KAGO KAKA
+                     KAKO KOGE KOGI KOJA KOJE KOJI KOJO KOLA KULO LILO
+                     LOCA LOCO LOKA LOKO MAME MAMO MEAR MEAS MEON MIAR
+                     MION MOCO MOKO MULA MULO NACA NACO ORIN PEDA PEDO
+                     PENE PIPI PITO POPO PUTA PUTO QULO RATA ROBA ROBE
+                     ROBO RUIN SENO TETA VACA VAGA VAGO VAKA VUEI VUEY
+                     WUEI WUEY].freeze
+
+    # O(1) lookup copies of the constants above (the public constants stay
+    # as readable frozen Arrays).
+    STATES = STATES_RENAPO.to_set.freeze
+    WORDS  = NAME_ISSUES.to_set.freeze
+
+    # Computes the RENAPO check digit (0-9) from the first 17 characters.
+    #
+    # Works on raw bytes: RENAPO's value table is contiguous in ASCII —
+    # '0'-'9' = 48-57 (=> 0-9), 'A'-'N' = 65-78 (=> 10-23), 'O'-'Z' =
+    # 79-90 (=> 25-36). The unused value 24 is Ñ's slot in the table;
+    # Ñ never appears in a CURP (RENAPO substitutes it), so we only need
+    # its offset (the -54 shift from 'O' on), not the character itself.
+    # Returns nil for input shorter than 17 bytes.
+    def self.check_digit(str)
+      return nil if str.bytesize < 17
+
+      sum = 0
+      17.times do |i|
+        b = str.getbyte(i)
+        value = b < 58 ? b - 48 : (b < 79 ? b - 55 : b - 54)
+        sum += value * (18 - i)
+      end
+      (10 - sum % 10) % 10
+    end
+
+    def self.valid?(curp)
+      new(curp).valid?
+    end
+
+    def initialize(curp)
+      @raw_input = curp.is_a?(String) ? curp.upcase : curp
+      @errors = {}
+
+      validate
+    end
+
+    def valid?
+      @errors.empty?
+    end
+
+    def validate
+      unless @raw_input.is_a?(String) && FORMAT.match?(@raw_input)
+        add_error(:format, 'Invalid format')
+        return false
+      end
+
+      validate_state
+      validate_name_initials
+      validate_birth_date
+      validate_date_exists
+      validate_check_digit
+    end
+
+    private
+
+    def add_error(key, message)
+      (@errors[key] ||= []) << message
+    end
+
+    def validate_state
+      state = @raw_input[11, 2]
+      return if STATES.include?(state)
+
+      add_error(:state, "Invalid state: '#{state}'")
+    end
+
+    def validate_name_initials
+      initials = @raw_input[0, 4]
+      return unless WORDS.include?(initials)
+
+      add_error(:problematic_name, "Problematic name initials: '#{initials}'")
+    end
+
+    def validate_birth_date
+      day = @raw_input[8, 2].to_i
+      add_error(:birth_day, "Invalid birth day: '#{@raw_input[8, 2]}'") if day <= 0 || day > 31
+
+      month = @raw_input[6, 2].to_i
+      add_error(:birth_month, "Invalid birth month: '#{@raw_input[6, 2]}'") if month <= 0 || month > 12
+    end
+
+    def validate_date_exists
+      return if Date.valid_date?(birth_year, @raw_input[6, 2].to_i, @raw_input[8, 2].to_i)
+
+      add_error(:birth_date,
+                "Invalid birth date (YYYY-mm-dd): #{birth_year}-#{@raw_input[6, 2]}-#{@raw_input[8, 2]}")
+    end
+
+    def validate_check_digit
+      expected = self.class.check_digit(@raw_input)
+      return if expected && @raw_input[17].to_i == expected
+
+      add_error(:check_digit,
+                "Invalid check digit: expected '#{expected}', got '#{@raw_input[17]}'")
+    end
+
+    # Full 4-digit year, using the homoclave to pick the century: a digit
+    # at position 17 means <2000, a letter means >=2000. Keeps leap-year
+    # checks (e.g. Feb 29) correct. Letters sort after '9' in ASCII.
+    def birth_year
+      century = @raw_input[16] >= 'A' ? 2000 : 1900
+      century + @raw_input[4, 2].to_i
+    end
+  end
+end

data/lib/curp_mx/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CurpMx
+  VERSION = "1.0.1"
+end

data/lib/curp_mx.rb

@@ -1,124 +1,8 @@
 # frozen_string_literal: true
 
-require 'date'
+require_relative "curp_mx/version"
+require_relative "curp_mx/validator"
 
 module CurpMx
-  VERSION = '0.1.0'
-
-  # Used to validate a CURPs format and a few data points in it
-  class Validator
-    attr_reader :errors, :raw_input
-
-    # Basic CURP regex structure
-    REGEX = /\A(?<father_initial>[A-Z]{2})
-                (?<mother_initial>[A-Z]{1})
-                (?<name_initial>[A-Z]{1})
-                (?<birth_year>[0-9]{2})
-                (?<birth_month>[0-1][0-9])
-                (?<birth_day>[0-3][0-9])
-                (?<sex>[HM])
-                (?<state>[A-Z]{2})
-                (?<father_consonant>[^AEIOU])
-                (?<mother_consonant>[^AEIOU])
-                (?<name_consonant>[^AEIOU])
-                (?<key>[0-9]{2})\z/x.freeze
-
-    # States' initials as listed in
-    # Registro Nacional de Población (RENAPO)
-    STATES_RENAPO = %w[AS BC BS CC CS CH CL CM DF CX DG GT GR HG JC MC MN MS
-                       NT NL OC PL QT QR SP SL SR TC TS TL VZ YN ZS].freeze
-
-    # Problematic name initials
-    NAME_ISSUES = %w[BACA LOCO BUEI BUEY MAME CACA MAMO
-                     CAGA MEAS CAGO MEON CAKA MIAR CAKO MION COGE
-                     MOCO COGI MOKO COJA MULA COJE MULO COJI NACA
-                     COJO NACO COLA PEDA CULO PEDO FALO PENE FETO
-                     PIPI GETA PITO GUEI POPO GUEY PUTA JETA PUTO
-                     JOTO QULO KACA RATA KACO ROBA KAGA ROBE KAGO
-                     ROBO KAKA RUIN KAKO SENO KOGE TETA KOGI VACA
-                     KOJA VAGA KOJE VAGO KOJI VAKA KOJO VUEI KOLA
-                     VUEY KULO WUEI LILO WUEY LOCA CACO MEAR].freeze
-
-    def self.valid?(curp)
-      new(curp).valid?
-    end
-
-    def initialize(curp)
-      @raw_input = curp
-      @errors = {}
-
-      validate
-    end
-
-    def valid?
-      @errors.empty?
-    end
-
-    def validate
-      @md = REGEX.match(@raw_input)
-
-      if @md.nil?
-        @errors[:format] ||= []
-        @errors[:format] << 'Invalid format'
-        return false
-      end
-
-      validate_state
-      validate_name_initials
-      validate_birth_date
-      validate_date_exists
-    end
-
-    private
-
-    def validate_state
-      return if STATES_RENAPO.include? @md[:state]
-
-      @errors[:state] << "Invalid state: '#{@md[:state]}'"
-    end
-
-    def validate_name_initials
-      return unless NAME_ISSUES.include?(name_initials)
-
-      @errors[:problematic_name] << "Problematic name initials: '#{name_initials}'"
-    end
-
-    def validate_birth_date
-      validate_birth_day
-      validate_birth_month
-    end
-
-    def validate_birth_day
-      birth_day = @md[:birth_day].to_i
-      return unless birth_day <= 0 || birth_day > 31
-
-      @errors[:birth_day] ||= []
-      @errors[:birth_day] << "Invalid birth day: '#{@md[:birth_day]}'"
-    end
-
-    def validate_birth_month
-      birth_month = @md[:birth_month].to_i
-      return unless birth_month <= 0 || birth_month > 12
-
-      @errors[:birth_month] ||= []
-      @errors[:birth_month] << "Invalid birth month: '#{@md[:birth_month]}'"
-    end
-
-    def validate_date_exists
-      date_str = "#{@md[:birth_year]}-#{@md[:birth_month]}-#{@md[:birth_day]}"
-      return if valid_date?(date_str)
-
-      @errors[:birth_date] ||= []
-      @errors[:birth_date] << "Invalid birth date (YYYY-mm-dd): #{date_str}"
-    end
-
-    def name_initials
-      [@md[:father_initial], @md[:mother_initial], @md[:name_initial]].join
-    end
-
-    def valid_date?(date_str)
-      # Inner works: Date.valid_date? 2020, 7, 21
-      Date.valid_date?(*date_str.split('-').map(&:to_i))
-    end
-  end
+  class Error < StandardError; end
 end

data/sig/curp_mx.rbs

@@ -0,0 +1,4 @@
+module CurpMx
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -1,28 +1,36 @@
 --- !ruby/object:Gem::Specification
 name: CurpMX
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Salazar
-autorequire:
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2022-10-18 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: A simple validator for CURPs. Fast, easy, descriptive.
-email:
-- contacto@capisalazar.com
+description: Parse and validate CURP (Clave Única de Registro de Población) from Mexico.
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- curp_mx.gemspec
 - lib/curp_mx.rb
-homepage:
-licenses:
-- MIT
-metadata: {}
-post_install_message:
+- lib/curp_mx/validator.rb
+- lib/curp_mx/version.rb
+- sig/curp_mx.rbs
+homepage: https://github.com/hslzr/curp_mx
+licenses: []
+metadata:
+  homepage_uri: https://github.com/hslzr/curp_mx
+  source_code_uri: https://github.com/hslzr/curp_mx
+  changelog_uri: https://github.com/hslzr/curp_mx/blob/master/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -30,15 +38,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
-summary: Mexican CURP validation library
+summary: Parse and validate CURP (Clave Única de Registro de Población) from Mexico.
 test_files: []