rfc_facil 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e4beff53f9889d87b462d70ef89626a465c47fd
-  data.tar.gz: 2c3a42b7c21b0799d0d88581917476c86a054cc9
+  metadata.gz: 13be1b95f84eeda13a0db0fef85d61561db1f8cd
+  data.tar.gz: a0927464ec27e36164f7a2f81b168dc6da322690
 SHA512:
-  metadata.gz: ef619a13b09e212df01f75df492fc5d616de7c546d647fc7fbc01f752a1f656baa624c6e304f94c904e22c74f7b1a2bc7c4769d6b21901fd6865716cb010bc91
-  data.tar.gz: 21b4428b04a98f0f5acf266a8984ea0201f85e62b53ed4f80e43601b3b9167efda69b7ab3be5f95cfbbcdc66416ef9da5eb2c34fddc4c04dc500d8304bc46f07
+  metadata.gz: 8f8e93171358b4cc72b4082235fbf2d562595caf7b7c4781319e1b43edc42b62182a4b6de36d124dc69f3de6d7d1685792ecc962b72a987bd5f23dbfaf694170
+  data.tar.gz: bd7f631ffce63eafde81dac49bb1c1c4b214c8cb33b3ea1121a638de7e762f168146576f9da55e33e4f7cb6270b785ddbf92addd6d8e34910cabce2b7be22b3f

data/README.md

@@ -1,4 +1,7 @@
 # Rfc Fácil
+[![Code Climate](https://codeclimate.com/github/Munett/rfc_facil/badges/gpa.svg)](https://codeclimate.com/github/Munett/rfc_facil)
+[![Test Coverage](https://codeclimate.com/github/Munett/rfc_facil/badges/coverage.svg)](https://codeclimate.com/github/Munett/rfc_facil/coverage)
+
 ![](https://github.com/acrogenesis/rfc_facil/raw/master/logo.png)
 
 Libreria para calcular el Registro Federal de Contribuyentes en México (RFC) en Ruby.
@@ -12,7 +15,7 @@ gem 'rfc_facil'
 ```
 Calcular el rfc de una persona física es muy sencillo:
 ```ruby
-rfc = Rfc.new(name: 'Adrián Marcelo', first_last_name: 'Rangel', second_last_name: 'Araujo', day: 27, month: 11, year: 1992)
+rfc = RfcFacil::Rfc.new(name: 'Adrián Marcelo', first_last_name: 'Rangel', second_last_name: 'Araujo', day: 27, month: 11, year: 1992)
 rfc.to_s # => 'RAAA921127RI6'
 ```
 

data/lib/rfc_facil.rb

@@ -1,8 +1,10 @@
 require 'rfc_facil/version'
 require 'rfc_facil/homoclave_calculator'
-require 'rfc_facil/person'
+require 'rfc_facil/natural_person'
+require 'rfc_facil/juristic_person'
 require 'rfc_facil/rfc'
-require 'rfc_facil/ten_digits_code_calculator'
+require 'rfc_facil/natural_ten_digits_code_calculator'
+require 'rfc_facil/juristic_ten_digits_code_calculator'
 require 'rfc_facil/verification_digit_calculator'
 require 'i18n'
 require 'unicode_utils/upcase'

data/lib/rfc_facil/homoclave_calculator.rb

@@ -1,72 +1,74 @@
-class HomoclaveCalculator
-  HOMOCLAVE_DIGITS = '123456789ABCDEFGHIJKLMNPQRSTUVWXYZ'
-  FULL_NAME_MAPPING  = {
-    ' ' => '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'
-  }
-  attr_accessor :person, :full_name, :mapped_full_name, :pairs_of_digits_sum, :homoclave
+module RfcFacil
+  class HomoclaveCalculator
+    HOMOCLAVE_DIGITS = '123456789ABCDEFGHIJKLMNPQRSTUVWXYZ'.freeze
+    FULL_NAME_MAPPING  = {
+      ' ' => '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
+    attr_accessor :person, :full_name, :mapped_full_name, :pairs_of_digits_sum, :homoclave
 
-  def initialize(person)
-    @person = person
-  end
+    def initialize(person)
+      @person = person
+    end
 
-  def calculate
-    normalize_full_name
-    map_full_name_to_digits_code
-    sum_pairs_of_digits
-    build_homoclave
+    def calculate
+      normalize_full_name
+      map_full_name_to_digits_code
+      sum_pairs_of_digits
+      build_homoclave
 
-    @homoclave
-  end
+      @homoclave
+    end
 
-  private
+    private
 
-  def build_homoclave
-    last_three_digits = (@pairs_of_digits_sum % 1000)
-    quo = (last_three_digits / 34)
-    reminder = (last_three_digits % 34)
-    @homoclave = "#{HOMOCLAVE_DIGITS[quo]}#{HOMOCLAVE_DIGITS[reminder]}"
-  end
+    def build_homoclave
+      last_three_digits = (@pairs_of_digits_sum % 1000)
+      quo = (last_three_digits / 34)
+      reminder = (last_three_digits % 34)
+      @homoclave = "#{HOMOCLAVE_DIGITS[quo]}#{HOMOCLAVE_DIGITS[reminder]}"
+    end
 
-  def sum_pairs_of_digits
-    @pairs_of_digits_sum = 0
-    (0..@mapped_full_name.length - 2).each do |i|
-      num1 = @mapped_full_name[i..i + 1].to_i
-      num2 = @mapped_full_name[i + 1..i + 1].to_i
+    def sum_pairs_of_digits
+      @pairs_of_digits_sum = 0
+      (0..@mapped_full_name.length - 2).each do |i|
+        num1 = @mapped_full_name[i..i + 1].to_i
+        num2 = @mapped_full_name[i + 1..i + 1].to_i
 
-      @pairs_of_digits_sum += num1 * num2
+        @pairs_of_digits_sum += num1 * num2
+      end
     end
-  end
 
-  def map_full_name_to_digits_code
-    @mapped_full_name = '0'
-    @full_name.each_char do |c|
-      @mapped_full_name << map_character_to_two_digit_code(c)
+    def map_full_name_to_digits_code
+      @mapped_full_name = '0'
+      @full_name.each_char do |c|
+        @mapped_full_name << map_character_to_two_digit_code(c)
+      end
     end
-  end
 
-  def map_character_to_two_digit_code(c)
-    return FULL_NAME_MAPPING[c] if FULL_NAME_MAPPING.key?(c)
-    fail ArgumentError, "No two-digit-code mapping for char: #{c}"
-  end
+    def map_character_to_two_digit_code(c)
+      return FULL_NAME_MAPPING[c] if FULL_NAME_MAPPING.key?(c)
+      raise ArgumentError, "No two-digit-code mapping for char: #{c}"
+    end
 
-  def normalize_full_name
-    raw_full_name = UnicodeUtils.upcase("#{@person}")
-    @full_name = I18n.transliterate(raw_full_name)
-    @full_name.gsub!(/[-.']/, '') # remove .'-
-    add_missing_char_to_full_name(raw_full_name, 'Ñ')
-  end
+    def normalize_full_name
+      raw_full_name = UnicodeUtils.upcase(@person.to_s)
+      @full_name = I18n.transliterate(raw_full_name)
+      @full_name.gsub!(/[-.']/, '') # remove .'-
+      add_missing_char_to_full_name(raw_full_name, 'Ñ')
+    end
 
-  def add_missing_char_to_full_name(raw_full_name, missing_char)
-    index = raw_full_name.index(missing_char)
-    until index.nil?
-      @full_name[index] = missing_char
-      index = raw_full_name.index(missing_char, index + 1)
+    def add_missing_char_to_full_name(raw_full_name, missing_char)
+      index = raw_full_name.index(missing_char)
+      until index.nil?
+        @full_name[index] = missing_char
+        index = raw_full_name.index(missing_char, index + 1)
+      end
     end
   end
 end

data/lib/rfc_facil/juristic_person.rb

@@ -0,0 +1,12 @@
+module RfcFacil
+  class JuristicPerson
+    attr_accessor :legal_name, :day, :month, :year
+
+    def initialize(legal_name, day, month, year)
+      @legal_name = legal_name
+      @day = day
+      @month = month
+      @year = year
+    end
+  end
+end

data/lib/rfc_facil/juristic_ten_digits_code_calculator.rb

@@ -0,0 +1,26 @@
+module RfcFacil
+  class JuristicTenDigitsCodeCalculator
+    attr_accessor :person
+
+    def initialize(person)
+      @person = person
+    end
+
+    def calculate
+      words = person.legal_name.split('\\s')
+      "#{words[0][0]}#{words[1][0]}#{words[2][0]}-#{birthday_code}"
+    end
+
+    def birthday_code
+      "#{last_two_digits_of(person.year)}#{formatted_in_two_digits(person.month)}#{formatted_in_two_digits(person.day)}"
+    end
+
+    def formatted_in_two_digits(number)
+      format('%02d', number)
+    end
+
+    def last_two_digits_of(number)
+      formatted_in_two_digits(number % 100)
+    end
+  end
+end

data/lib/rfc_facil/natural_person.rb

@@ -0,0 +1,18 @@
+module RfcFacil
+  class NaturalPerson
+    attr_accessor :name, :first_last_name, :second_last_name, :day, :month, :year
+
+    def initialize(name, first_last_name, second_last_name, day, month, year)
+      @name = name
+      @first_last_name = first_last_name
+      @second_last_name = second_last_name
+      @day = day
+      @month = month
+      @year = year
+    end
+
+    def to_s
+      "#{@first_last_name} #{@second_last_name} #{@name}"
+    end
+  end
+end

data/lib/rfc_facil/natural_ten_digits_code_calculator.rb

@@ -0,0 +1,124 @@
+module RfcFacil
+  class NaturalTenDigitsCodeCalculator
+    VOWEL_PATTERN = /[AEIOU]+/
+    attr_accessor :person
+    SPECIAL_PARTICLES = %w(DE LA LAS MC VON DEL LOS Y MAC VAN MI).freeze
+    FORBIDDEN_WORDS = %w(
+      BUEI BUEY CACA CACO CAGA KOGE KAKA MAME KOJO KULO
+      CAGO COGE COJE COJO FETO JOTO KACO KAGO MAMO MEAR MEON
+      MION MOCO MULA PEDA PEDO PENE PUTA PUTO QULO RATA RUIN
+    ).freeze
+
+    def initialize(person)
+      @person = person
+    end
+
+    def calculate
+      "#{obfuscate_forbidden_words(name_code)}#{birthday_code}"
+    end
+
+    def obfuscate_forbidden_words(name_code)
+      FORBIDDEN_WORDS.each do |forbidden|
+        return "#{name_code[0..2]}X" if forbidden == name_code
+      end
+      name_code
+    end
+
+    def name_code
+      return first_last_name_empty_form if first_last_name_empty?
+      return second_last_name_empty_form if second_last_name_empty?
+      return first_last_name_too_short_form if first_last_name_is_too_short?
+      normal_form
+    end
+
+    def second_last_name_empty_form
+      first_two_letters_of(@person.first_last_name) <<
+        first_two_letters_of(filter_name(@person.name))
+    end
+
+    def birthday_code
+      "#{@person.year.to_s[-2, 2]}#{format('%02d', @person.month)}#{format('%02d', @person.day)}"
+    end
+
+    def second_last_name_empty?
+      normalize(@person.second_last_name).nil? || normalize(@person.second_last_name).empty?
+    end
+
+    def first_last_name_empty_form
+      first_two_letters_of(@person.second_last_name) <<
+        first_two_letters_of(filter_name(@person.name))
+    end
+
+    def first_last_name_empty?
+      normalize(@person.first_last_name).nil? || normalize(@person.first_last_name).empty?
+    end
+
+    def first_last_name_too_short_form
+      first_letter_of(@person.first_last_name) <<
+        first_letter_of(@person.second_last_name) <<
+        first_two_letters_of(filter_name(@person.name))
+    end
+
+    def first_two_letters_of(word)
+      normalized_word = normalize(word)
+      normalized_word[0..1]
+    end
+
+    def first_last_name_is_too_short?
+      normalize(@person.first_last_name).length <= 2
+    end
+
+    def normal_form
+      first_letter_of(@person.first_last_name) <<
+        first_vowel_excluding_first_character_of(@person.first_last_name) <<
+        first_letter_of(@person.second_last_name) <<
+        first_letter_of(filter_name(@person.name))
+    end
+
+    def filter_name(name)
+      raw_name = normalize(name).strip
+      if raw_name.include?(' ') && (raw_name.start_with?('MARIA', 'JOSE'))
+        return raw_name.split(' ')[1]
+      end
+      name
+    end
+
+    def formatted_in_two_digits(number)
+      format('%02d', number)
+    end
+
+    def last_two_digits_of(number)
+      formatted_in_two_digits(number % 100)
+    end
+
+    def first_letter_of(word)
+      normalized_word = normalize(word)
+      normalized_word[0]
+    end
+
+    def normalize(word)
+      return word if word.nil? || word.empty?
+      normalized_word = UnicodeUtils.upcase(I18n.transliterate(word))
+      remove_special_particles(normalized_word, SPECIAL_PARTICLES)
+    end
+
+    def remove_special_particles(word, special_particles)
+      new_word = word
+      special_particles.each do |particle|
+        pp = "#{particle} "
+        while new_word.include?(pp)
+          i = new_word.to_s.index(pp).to_i
+          new_word.slice!(i..i + pp.length - 1)
+        end
+      end
+      new_word.to_s
+    end
+
+    def first_vowel_excluding_first_character_of(word)
+      normalized_word = normalize(word)[1..-1]
+      m = VOWEL_PATTERN.match(normalized_word)
+      raise ArgumentError, "Word doesn't contain a vowel: #{normalized_word}" if m.nil?
+      normalized_word[m.to_s[0]]
+    end
+  end
+end

data/lib/rfc_facil/rfc.rb

@@ -1,22 +1,36 @@
-class Rfc
-  attr_accessor :name, :first_last_name, :second_last_name, :day, :month, :year,
-                :ten_digits_code, :homoclave, :verification_digit
+module RfcFacil
+  class Rfc
+    attr_accessor :name, :first_last_name, :second_last_name, :day, :month, :year,
+                  :ten_digits_code, :homoclave, :verification_digit, :legal_name
 
-  def initialize(args)
-    @name = args[:name]
-    @first_last_name = args[:first_last_name]
-    @second_last_name = args[:second_last_name]
-    @day = args[:day]
-    @month = args[:month]
-    @year = args[:year]
+    def initialize(args)
+      @name = args[:name]
+      @first_last_name = args[:first_last_name]
+      @second_last_name = args[:second_last_name]
+      @day = args[:day]
+      @month = args[:month]
+      @year = args[:year]
+      @legal_name = args[:legal_name]
+      if @legal_name.nil?
+        build_natural_person
+      else
+        build_juristic_person
+      end
+    end
 
-    @person = Person.new(@name, @first_last_name, @second_last_name, @day, @month, @year)
-    @ten_digits_code = TenDigitsCodeCalculator.new(@person).calculate
-    @homoclave = HomoclaveCalculator.new(@person).calculate
-    @verification_digit = VerificationDigitCalculator.new("#{@ten_digits_code}#{@homoclave}").calculate
-  end
+    def build_juristic_person
+
+    end
+
+    def build_natural_person
+      @person = NaturalPerson.new(@name, @first_last_name, @second_last_name, @day, @month, @year)
+      @ten_digits_code = NaturalTenDigitsCodeCalculator.new(@person).calculate
+      @homoclave = HomoclaveCalculator.new(@person).calculate
+      @verification_digit = VerificationDigitCalculator.new("#{@ten_digits_code}#{@homoclave}").calculate
+    end
 
-  def to_s
-    "#{@ten_digits_code}#{@homoclave}#{@verification_digit}"
+    def to_s
+      "#{@ten_digits_code}#{@homoclave}#{@verification_digit}"
+    end
   end
 end

data/lib/rfc_facil/verification_digit_calculator.rb

@@ -1,32 +1,34 @@
-class VerificationDigitCalculator
-  attr_accessor :rfc12_digits
-  MAPPING = {
-    '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
-  }
+module RfcFacil
+  class VerificationDigitCalculator
+    attr_accessor :rfc12_digits
+    MAPPING = {
+      '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
 
-  def initialize(rfc12_digits)
-    @rfc12_digits = rfc12_digits
-  end
-
-  def calculate
-    sum = 0
-    (0..11).each do |i|
-      sum += map_digit(@rfc12_digits[i]) * (13 - i)
+    def initialize(rfc12_digits)
+      @rfc12_digits = rfc12_digits
     end
-    reminder = sum % 11
 
-    return '0' if (reminder == 0)
-    return 'A' if (reminder == 10)
-    (11 - reminder).to_s
-  end
+    def calculate
+      sum = 0
+      (0..11).each do |i|
+        sum += map_digit(@rfc12_digits[i]) * (13 - i)
+      end
+      reminder = sum % 11
 
-  def map_digit(c)
-    return MAPPING[c] if MAPPING.key?(c)
-    0
+      return '0' if reminder == 0
+      return 'A' if reminder == 10
+      (11 - reminder).to_s
+    end
+
+    def map_digit(c)
+      return MAPPING[c] if MAPPING.key?(c)
+      0
+    end
   end
 end

data/lib/rfc_facil/version.rb

@@ -1,3 +1,3 @@
 module RfcFacil
-  VERSION = '0.1.1'
+  VERSION = '1.0.0'
 end

data/rfc_facil.gemspec

@@ -8,6 +8,7 @@ Gem::Specification.new do |spec|
   spec.version       = RfcFacil::VERSION
   spec.authors       = ['Adrian Rangel']
   spec.email         = ['adrian.rangel@gmail.com']
+  spec.licenses      = ['MIT']
 
   spec.summary       = 'Libreria para calcular el Registro Federal de Contribuyentes en México (RFC).'
   spec.homepage      = 'https://acrogenesis.com/rfc_facil/'
@@ -23,4 +24,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1.10'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'minitest', '~> 5.8'
+  spec.add_development_dependency 'codeclimate-test-reporter', '~> 0.4'
 end

data/tests/rfc_facil/test_homoclave_calculator.rb

@@ -50,12 +50,12 @@ class TestHomoclaveCalculator < Minitest::Test
 
   def test_calculate_same_homoclave_for_different_birthdays
     assert_equal(
-      HomoclaveCalculator.new(Person.new('Juan', 'Perez', 'Garcia', 5, 8, 1987)).calculate,
-      HomoclaveCalculator.new(Person.new('Juan', 'Perez', 'Garcia', 1, 1, 1901)).calculate
+      RfcFacil::HomoclaveCalculator.new(RfcFacil::NaturalPerson.new('Juan', 'Perez', 'Garcia', 5, 8, 1987)).calculate,
+      RfcFacil::HomoclaveCalculator.new(RfcFacil::NaturalPerson.new('Juan', 'Perez', 'Garcia', 1, 1, 1901)).calculate
     )
   end
 
   def homoclave(name, firstLastName, secondLastName)
-    HomoclaveCalculator.new(Person.new(name, firstLastName, secondLastName, 1, 1, 1901)).calculate
+    RfcFacil::HomoclaveCalculator.new(RfcFacil::NaturalPerson.new(name, firstLastName, secondLastName, 1, 1, 1901)).calculate
   end
 end

data/tests/rfc_facil/test_juristic_ten_digits_code_calculator.rb

@@ -0,0 +1,17 @@
+class TestJurisitcTenDigitsCodeCalculator < Minitest::Test
+  def should_take_first_letters_from_the_first_three_words_from_legal_name
+    assert_equal('MNE', ten_digits_code('Mu Networks S.A.P.I. de C.V.', 10, 07, 2014)[0, 3])
+  end
+
+  def should_take_creation_date_in_format_yy_mm_dd
+    assert_equal('MNE1407107', ten_digits_code('Mu Networks S.A.P.I. de C.V.', 10, 07, 2014))
+  end
+
+  private
+
+  def ten_digits_code(legal_name, day, month, year)
+    RfcFacil::JuristicTenDigitsCodeCalculator.new(
+      RfcFacil::JuristicPerson.new(legal_name, day, month, year)
+    ).calculate
+  end
+end

data/tests/rfc_facil/{test_ten_digits_code_calculator.rb → test_natural_ten_digits_code_calculator.rb}

@@ -1,4 +1,4 @@
-class TestTenDigitsCodeCalculator < Minitest::Test
+class TestNaturalTenDigitsCodeCalculator < Minitest::Test
   def test_calculate_ten_digits_code_for_simple_test_case
     assert_equal('BAFJ701213', ten_digits_code('Juan', 'Barrios', 'Fernandez', 13, 12, 1970))
   end
@@ -72,8 +72,8 @@ class TestTenDigitsCodeCalculator < Minitest::Test
   private
 
   def ten_digits_code(name, first_last_name, second_last_name, day, month, year)
-    TenDigitsCodeCalculator.new(
-      Person.new(name, first_last_name, second_last_name, day, month, year)
+    RfcFacil::NaturalTenDigitsCodeCalculator.new(
+      RfcFacil::NaturalPerson.new(name, first_last_name, second_last_name, day, month, year)
     ).calculate
   end
 end

data/tests/rfc_facil/test_rfc.rb

@@ -1,6 +1,6 @@
 class TestRfc < Minitest::Test
-  def test_rfc
-    rfc = Rfc.new(name: 'Adrian Marcelo', first_last_name: 'Rangel',
+  def test_rfc_for_a_natural_person
+    rfc = RfcFacil::Rfc.new(name: 'Adrian Marcelo', first_last_name: 'Rangel',
                   second_last_name: 'Araujo', day: 27, month: 11, year: 1992)
 
     assert_equal('RAAA921127', rfc.ten_digits_code)
@@ -8,4 +8,13 @@ class TestRfc < Minitest::Test
     assert_equal('6', rfc.verification_digit)
     assert_equal('RAAA921127RI6', rfc.to_s)
   end
+
+  def test_rfc_for_a_juristic_person
+    _rfc = RfcFacil::Rfc.new(legal_name: 'Mu Networks S.A.P.I de C.V.', day: 10, month: 07, year: 2014)
+
+    # assertThat(rfc.tenDigitsCode, equalTo("SIA-821129"));
+    # assertThat(rfc.homoclave, equalTo("CK"));
+    # assertThat(rfc.verificationDigit, equalTo("6"));
+    # assertThat(rfc.toString(), equalTo("ZATJ870805CK6"));
+  end
 end

data/tests/rfc_facil/test_verification_digit_calculator.rb

@@ -4,6 +4,6 @@ class VerificationDigitCalculatorTest < Minitest::Test
   end
 
   def verification_digit(rfc12Digit)
-    VerificationDigitCalculator.new(rfc12Digit).calculate
+    RfcFacil::VerificationDigitCalculator.new(rfc12Digit).calculate
   end
 end

data/tests/tests_helper.rb

@@ -1,6 +1,9 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
 require 'minitest/autorun'
 require_relative '../lib/rfc_facil'
 require 'rfc_facil/test_homoclave_calculator'
 require 'rfc_facil/test_rfc'
-require 'rfc_facil/test_ten_digits_code_calculator'
+require 'rfc_facil/test_natural_ten_digits_code_calculator'
+require 'rfc_facil/test_juristic_ten_digits_code_calculator'
 require 'rfc_facil/test_verification_digit_calculator'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rfc_facil
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Adrian Rangel
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-12 00:00:00.000000000 Z
+date: 2016-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.8'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
 description: 
 email:
 - adrian.rangel@gmail.com
@@ -96,20 +110,24 @@ files:
 - bin/setup
 - lib/rfc_facil.rb
 - lib/rfc_facil/homoclave_calculator.rb
-- lib/rfc_facil/person.rb
+- lib/rfc_facil/juristic_person.rb
+- lib/rfc_facil/juristic_ten_digits_code_calculator.rb
+- lib/rfc_facil/natural_person.rb
+- lib/rfc_facil/natural_ten_digits_code_calculator.rb
 - lib/rfc_facil/rfc.rb
-- lib/rfc_facil/ten_digits_code_calculator.rb
 - lib/rfc_facil/verification_digit_calculator.rb
 - lib/rfc_facil/version.rb
 - logo.png
 - rfc_facil.gemspec
 - tests/rfc_facil/test_homoclave_calculator.rb
+- tests/rfc_facil/test_juristic_ten_digits_code_calculator.rb
+- tests/rfc_facil/test_natural_ten_digits_code_calculator.rb
 - tests/rfc_facil/test_rfc.rb
-- tests/rfc_facil/test_ten_digits_code_calculator.rb
 - tests/rfc_facil/test_verification_digit_calculator.rb
 - tests/tests_helper.rb
 homepage: https://acrogenesis.com/rfc_facil/
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -127,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Libreria para calcular el Registro Federal de Contribuyentes en México (RFC).

data/lib/rfc_facil/person.rb

@@ -1,16 +0,0 @@
-class Person
-  attr_accessor :name, :first_last_name, :second_last_name, :day, :month, :year
-
-  def initialize(name, first_last_name, second_last_name, day, month, year)
-    @name = name
-    @first_last_name = first_last_name
-    @second_last_name = second_last_name
-    @day = day
-    @month = month
-    @year = year
-  end
-
-  def to_s
-    "#{@first_last_name} #{@second_last_name} #{@name}"
-  end
-end

data/lib/rfc_facil/ten_digits_code_calculator.rb

@@ -1,122 +0,0 @@
-class TenDigitsCodeCalculator
-  VOWEL_PATTERN = /[AEIOU]+/
-  attr_accessor :person
-  SPECIAL_PARTICLES = %w(DE LA LAS MC VON DEL LOS Y MAC VAN MI)
-  FORBIDDEN_WORDS = %w(
-    BUEI BUEY CACA CACO CAGA KOGE KAKA MAME KOJO KULO
-    CAGO COGE COJE COJO FETO JOTO KACO KAGO MAMO MEAR MEON
-    MION MOCO MULA PEDA PEDO PENE PUTA PUTO QULO RATA RUIN
-  )
-
-  def initialize(person)
-    @person = person
-  end
-
-  def calculate
-    "#{obfuscate_forbidden_words(name_code)}#{birthday_code}"
-  end
-
-  def obfuscate_forbidden_words(name_code)
-    FORBIDDEN_WORDS.each do |forbidden|
-      return "#{name_code[0..2]}X" if forbidden == name_code
-    end
-    name_code
-  end
-
-  def name_code
-    return first_last_name_empty_form if first_last_name_empty?
-    return second_last_name_empty_form if second_last_name_empty?
-    return first_last_name_too_short_form if first_last_name_is_too_short?
-    normal_form
-  end
-
-  def second_last_name_empty_form
-    first_two_letters_of(@person.first_last_name) <<
-      first_two_letters_of(filter_name(@person.name))
-  end
-
-  def birthday_code
-    "#{@person.year.to_s[-2, 2]}#{format('%02d', @person.month)}#{format('%02d', @person.day)}"
-  end
-
-  def second_last_name_empty?
-    normalize(@person.second_last_name).nil? || normalize(@person.second_last_name).empty?
-  end
-
-  def first_last_name_empty_form
-    first_two_letters_of(@person.second_last_name) <<
-      first_two_letters_of(filter_name(@person.name))
-  end
-
-  def first_last_name_empty?
-    normalize(@person.first_last_name).nil? || normalize(@person.first_last_name).empty?
-  end
-
-  def first_last_name_too_short_form
-    first_letter_of(@person.first_last_name) <<
-      first_letter_of(@person.second_last_name) <<
-      first_two_letters_of(filter_name(@person.name))
-  end
-
-  def first_two_letters_of(word)
-    normalized_word = normalize(word)
-    normalized_word[0..1]
-  end
-
-  def first_last_name_is_too_short?
-    normalize(@person.first_last_name).length <= 2
-  end
-
-  def normal_form
-    first_letter_of(@person.first_last_name) <<
-      first_vowel_excluding_first_character_of(@person.first_last_name) <<
-      first_letter_of(@person.second_last_name) <<
-      first_letter_of(filter_name(@person.name))
-  end
-
-  def filter_name(name)
-    raw_name = normalize(name).strip
-    if raw_name.include?(' ') && (raw_name.start_with?('MARIA') || raw_name.start_with?('JOSE'))
-      return raw_name.split(' ')[1]
-    end
-    name
-  end
-
-  def formatted_in_two_digits(number)
-    format('%02d', number)
-  end
-
-  def last_two_digits_of(number)
-    formatted_in_two_digits(number % 100)
-  end
-
-  def first_letter_of(word)
-    normalized_word = normalize(word)
-    normalized_word[0]
-  end
-
-  def normalize(word)
-    return word if word.nil? || word.empty?
-    normalized_word = UnicodeUtils.upcase(I18n.transliterate(word))
-    remove_special_particles(normalized_word, SPECIAL_PARTICLES)
-  end
-
-  def remove_special_particles(word, special_particles)
-    new_word = word
-    special_particles.each do |particle|
-      pp = "#{particle} "
-      while new_word.include?(pp)
-        i = new_word.to_s.index(pp).to_i
-        new_word.slice!(i..i + pp.length - 1)
-      end
-    end
-    new_word.to_s
-  end
-
-  def first_vowel_excluding_first_character_of(word)
-    normalized_word = normalize(word)[1..-1]
-    m = VOWEL_PATTERN.match(normalized_word)
-    fail ArgumentError, "Word doesn't contain a vowel: #{normalized_word}" if m.nil?
-    normalized_word[m.to_s[0]]
-  end
-end