tin_valid 0.1.1 → 1.1.0

data/lib/tin_valid/ireland_tin.rb

@@ -1,7 +1,13 @@
 # frozen_string_literal: true
 
 module TinValid
-  class IrelandTin < Data.define(:tin)
+  class IrelandTin
+    def initialize(tin:)
+      @tin = tin
+    end
+
+    attr_reader :tin
+
     def valid?
       /\A[0-9]{7}[A-W][A-IW]?\z/.match?(tin) &&
         tin.chars[7] == check

data/lib/tin_valid/italy_tin.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module TinValid
+  # rubocop:disable Metrics/ClassLength
+  class ItalyTin
+    include TinValid::Helpers
+
+    def initialize(tin:, birth_date: nil)
+      @tin = tin
+      @birth_date = birth_date
+    end
+
+    attr_reader :tin, :birth_date
+
+    def valid?
+      match = MATCHER.match(tin)
+      return false unless match
+      return false unless valid_date?(match)
+
+      tin[-1] == check
+    end
+
+    private
+
+    def valid_date?(match)
+      # C7,C8: Two last digits of a year.
+      year = replacement_to_i(match[:year])
+
+      # C9: A letter representing a month;
+      month = MONTH_LETTERS.fetch(match[:month])
+
+      # C10,C11: Day of month (in the range 1...31 for men)
+      # or day of month + 40 (in the range 41...71 for women).
+      day = replacement_to_i(match[:day])
+      day -= 40 if day > 40
+
+      if birth_date
+        birth_date == date("#{birth_century}#{year}", month, day)
+      else
+        date("19#{year}", month, day) || date("20#{year}", month, day)
+      end
+    end
+
+    def check
+      # 1. Each of the first fifteen characters,depending on its relevant
+      # position (even or odd), is converted into a numeric value,according to
+      # correspondence shown in the tables below:
+      sum = tin[..14].chars.each.with_index(1).sum do |char, index|
+        index.even? ? even_number(char) : odd_number(char)
+      end
+
+      # 2. The numerical values thus determined are added together and their sum
+      # is divided by 26. The check character (C16) is obtained by converting
+      # the remainder of the division in the corresponding alphabetic character
+      # according to the table below:
+      ((sum % 26) + 65).chr
+    end
+
+    def birth_century = birth_date.strftime("%Y")[..1]
+
+    def replacement_to_i(string)
+      string.chars.map { NUMERICAL_REPLACEMENTS.fetch(_1, _1) }.join.to_i
+    end
+
+    MATCHER = %r{
+      \A
+      [A-Z]{6}
+      (?<year>[0-9LMNPQRSTUV]{2})
+      (?<month>[ABCDEHLMPRST])
+      (?<day>[0-7LMNPQRST][0-9LMNPQRSTUV])
+      [A-Z]
+      [0-9LMNPQRSTUV]{3}
+      [A-Z]
+      \z
+    }x
+    private_constant :MATCHER
+
+    # C9: A letter representing a month; the letter can only take the values:
+    MONTH_LETTERS = {
+      "A" => 1,
+      "B" => 2,
+      "C" => 3,
+      "D" => 4,
+      "E" => 5,
+      "H" => 6,
+      "L" => 7,
+      "M" => 8,
+      "P" => 9,
+      "R" => 10,
+      "S" => 11,
+      "T" => 12
+    }.freeze
+    private_constant :MONTH_LETTERS
+
+    NUMERICAL_REPLACEMENTS = {
+      "L" => 0,
+      "M" => 1,
+      "N" => 2,
+      "P" => 3,
+      "Q" => 4,
+      "R" => 5,
+      "S" => 6,
+      "T" => 7,
+      "U" => 8,
+      "V" => 9
+    }.freeze
+    private_constant :NUMERICAL_REPLACEMENTS
+
+    def even_number(character)
+      case character
+      in "0".."9" then character.to_i
+      in "A".."Z" then character.ord - 65
+      end
+    end
+
+    def odd_number(character)
+      ODD_NUMBER_TABLE.fetch(character)
+    end
+
+    ODD_NUMBER_TABLE = {
+      "A" => 1,
+      "0" => 1,
+      "B" => 0,
+      "1" => 0,
+      "C" => 5,
+      "2" => 5,
+      "D" => 7,
+      "3" => 7,
+      "E" => 9,
+      "4" => 9,
+      "F" => 13,
+      "5" => 13,
+      "G" => 15,
+      "6" => 15,
+      "H" => 17,
+      "7" => 17,
+      "I" => 19,
+      "8" => 19,
+      "J" => 21,
+      "9" => 21,
+      "K" => 2,
+      "L" => 4,
+      "M" => 18,
+      "N" => 20,
+      "O" => 11,
+      "P" => 3,
+      "Q" => 6,
+      "R" => 8,
+      "S" => 12,
+      "T" => 14,
+      "U" => 16,
+      "V" => 10,
+      "W" => 22,
+      "X" => 25,
+      "Y" => 24,
+      "Z" => 23
+    }.freeze
+    private_constant :ODD_NUMBER_TABLE
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/tin_valid/latvia_tin.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module TinValid
+  class LatviaTin
+    def initialize(tin:, birth_date: nil)
+      @tin = tin
+      @birth_date = birth_date
+    end
+
+    attr_reader :tin, :birth_date
+
+    def valid? = valid_v1? || valid_v2?
+
+    private
+
+    MATCHER_V1 = %r{
+      \A
+      (?<day>[0-3][0-9])
+      (?<month>[0-1][0-9])
+      (?<year>[0-9]{2})
+      (?<century>[0-2])
+      -?
+      [0-9]{4}
+      \z
+    }x
+    private_constant :MATCHER_V1
+
+    MATCHER_V2 = %r{
+      \A
+      32
+      [0-9]{4}
+      -?
+      [0-9]{5}
+      \z
+    }x
+    private_constant :MATCHER_V2
+
+    def valid_v1?
+      match = MATCHER_V1.match(tin)
+      return false unless match
+      return false if tin == "00000000000"
+
+      if birth_date
+        tin[..5] == birth_date.strftime("%d%m%y") &&
+          tin[6] == birth_century_digit
+      else
+        true
+      end
+    end
+
+    def valid_v2?
+      MATCHER_V2.match?(tin)
+    end
+
+    def birth_century_digit
+      case birth_date.year
+      when 1800..1899 then "0"
+      when 1900..1999 then "1"
+      when 2000.. then "2"
+      end
+    end
+  end
+end

data/lib/tin_valid/lithuania_tin.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module TinValid
+  class LithuaniaTin
+    def initialize(tin:, birth_date: nil)
+      @tin = tin
+      @birth_date = birth_date
+    end
+
+    attr_reader :tin, :birth_date
+
+    def valid?
+      matcher = MATCHER.match(tin)
+      return false unless matcher
+
+      if birth_date && (matcher[:birth_date] != birth_date.strftime("%y%m%d"))
+        return false
+      end
+
+      tin[-1].to_i == check
+    end
+
+    private
+
+    MATCHER = %r{
+      [1-6]
+      (?<birth_date>
+        [0-9]{2}
+        [0-1][0-9]
+        [0-3][0-9]
+      )
+      [0-9]{4}
+    }x
+    private_constant :MATCHER
+
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    def check
+      # 1. Multiply the values of each position by the corresponding weight:
+      weights =
+        [1, 2, 3, 4, 5, 6, 7, 8, 9, 1]
+          .each_with_index
+          .map { |weight, index| weight * tin[index].to_i }
+
+      # 2. Add up the results of the above multiplications;
+      sum = weights.sum
+
+      # 3. Get modulo 11 of the result of the previous addition;
+      remainder = sum % 11
+
+      # 4. C11 = remainder if remainder is not 10;
+      return remainder if remainder != 10
+
+      # 5. If remainder is 10, calculate a new check digit with over
+      # corresponding weight:
+      weights =
+        [3, 4, 5, 6, 7, 8, 9, 1, 2, 3]
+          .each_with_index
+          .map { |weight, index| weight * tin[index].to_i }
+
+      # 6. Add up the results of the above multiplications;
+      sum = weights.sum
+
+      # 7. Get modulo 11 of the result of the previous addition;
+      remainder = sum % 11
+
+      # 8. C11 = remainder if remainder is not 10; if remainder is 10, C11 = 0.
+      return remainder if remainder != 10
+
+      0
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
+  end
+end

data/lib/tin_valid/luxembourg_tin.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module TinValid
+  class LuxembourgTin
+    include TinValid::Helpers
+
+    def initialize(tin:, birth_date: nil)
+      @tin = tin
+      @birth_date = birth_date
+    end
+
+    attr_reader :tin, :birth_date
+
+    def valid?
+      match = MATCHER.match(tin)
+      return false unless match
+
+      tin_date = date(match[:year], match[:month], match[:day])
+      return false unless tin_date
+
+      return false if birth_date && birth_date != tin_date
+
+      check1? && check2?
+    end
+
+    private
+
+    MATCHER = %r{
+      \A
+      (?<year>[0-9]{4})
+      (?<month>[0-1][0-9])
+      (?<day>[0-3][0-9])
+      [0-9]{5}
+      \z
+    }x
+    private_constant :MATCHER
+
+    def check1?
+      # 1. Multiply the values of each position by the corresponding weight:
+      weights =
+        [2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1]
+          .each_with_index
+          .map { |weight, index| weight * tin[index].to_i }
+
+      # 2. If the product of a doubling operation is > 9, sum the digits of the
+      # product;
+      weights = weights.map { _1 > 9 ? _1.to_s.chars.sum(&:to_i) : _1 }
+
+      # 3. Add up the results of the above multiplications;
+      sum = weights.sum
+
+      # 4. Get modulo 10 of the result of the previous addition;
+      remainder = sum % 10
+
+      # 5. If remainder = 0, C12 is valid. Otherwise the TIN is not valid.
+      remainder == 0
+    end
+
+    def check2?
+      # 1. Create an array n containing the individual C1 to C11 and C13 of the
+      # TIN (where ni = the value of the corresponding C), taken from right to
+      # left:
+      array = [*tin[..10].chars, tin[12]].map(&:to_i).reverse
+
+      # 2. Initialize the checksum c to 0;
+      # 3. For each index i of the array n, starting at 0, replace c by
+      # d(c,p(i mod 8, ni)), according to the following tables:
+      checksum = array.each_with_index.inject(0) do |c, (ni, index)|
+        table_d(c, table_p(index % 8, ni))
+      end
+
+      # 4. Check digit c if c = 0, C13 is valid. Otherwise, the TIN is not
+      # valid.
+      checksum == 0
+    end
+
+    def table_d(number_i, number_j) = TABLE_D.dig(number_i, number_j)
+    def table_p(number_m, number_n) = TABLE_P.dig(number_m, number_n)
+
+    TABLE_D = [
+      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+      [1, 2, 3, 4, 0, 6, 7, 8, 9, 5],
+      [2, 3, 4, 0, 1, 7, 8, 9, 5, 6],
+      [3, 4, 0, 1, 2, 8, 9, 5, 6, 7],
+      [4, 0, 1, 2, 3, 9, 5, 6, 7, 8],
+      [5, 9, 8, 7, 6, 0, 4, 3, 2, 1],
+      [6, 5, 9, 8, 7, 1, 0, 4, 3, 2],
+      [7, 6, 5, 9, 8, 2, 1, 0, 4, 3],
+      [8, 7, 6, 5, 9, 3, 2, 1, 0, 4],
+      [9, 8, 7, 6, 5, 4, 3, 2, 1, 0],
+    ].freeze
+    private_constant :TABLE_D
+
+    TABLE_P = [
+      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+      [1, 5, 7, 6, 2, 8, 3, 0, 9, 4],
+      [5, 8, 0, 3, 7, 9, 6, 1, 4, 2],
+      [8, 9, 1, 6, 0, 5, 3, 5, 2, 7],
+      [9, 4, 5, 3, 1, 2, 6, 8, 7, 0],
+      [4, 2, 8, 6, 5, 7, 3, 9, 0, 1],
+      [2, 7, 9, 3, 8, 0, 6, 4, 1, 5],
+      [7, 0, 4, 6, 9, 1, 3, 2, 5, 8],
+    ].freeze
+    private_constant :TABLE_P
+  end
+end

data/lib/tin_valid/malta_tin.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module TinValid
+  class MaltaTin
+    def initialize(tin:)
+      @tin = tin
+    end
+
+    attr_reader :tin
+
+    def valid? = valid_format_1? || valid_format_2?
+
+    private
+
+    MATCHER_V1 = %r{
+      \A
+      (?<number>
+        (?<part1>[0-9]{0,5})
+        [0-9]{1,2}
+      )
+      (?<letter>[MGAPLHBZ])
+      \z
+    }x
+    private_constant :MATCHER_V1
+
+    MATCHER_V2 = %r{
+      \A
+      (11|22|33|44|55|66|77|88)
+      [0-9]{7}
+      \z
+    }x
+    private_constant :MATCHER_V2
+
+    def valid_format_1?
+      match = MATCHER_V1.match(tin)
+      return false unless match
+
+      case match[:letter]
+      when "A", "P"
+        true
+      when "M", "G", "L", "H", "B", "Z"
+        (0..32_000).cover?(match[:part1].to_i) &&
+          match[:number].to_i != 0
+      end
+    end
+
+    def valid_format_2?
+      MATCHER_V2.match?(tin)
+    end
+  end
+end

data/lib/tin_valid/netherlands_tin.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module TinValid
+  class NetherlandsTin
+    def initialize(tin:)
+      @tin = tin
+    end
+
+    attr_reader :tin
+
+    def valid?
+      return false unless /\A[0-9]{9}\z/.match?(tin)
+      return false if tin == "000000000"
+
+      tin[-1].to_i == check
+    end
+
+    private
+
+    def check
+      # 1. Multiply the values of each position by the corresponding weight:
+      multipliers =
+        9
+          .downto(2)
+          .each_with_index
+          .map { |multiplier, position| multiplier * tin[position].to_i }
+
+      # 2. Add up the results of the above multiplications;
+      sum = multipliers.sum
+
+      # 3. Get modulo 11 of the result of the previous addition;
+      # 4. Check digit = remainder (if remainder = 10, the TIN is not valid).
+      sum % 11
+    end
+  end
+end

data/lib/tin_valid/poland_tin.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module TinValid
+  class PolandTin
+    include TinValid::Helpers
+
+    def initialize(tin:, birth_date: nil)
+      @tin = tin
+      @birth_date = birth_date
+    end
+
+    attr_reader :tin, :birth_date
+
+    def valid? = valid_v1? || valid_v2?
+
+    private
+
+    MATCHER_V1 = /\A[0-9]{10}\z/
+    private_constant :MATCHER_V1
+
+    MATCHER_V2 = %r{
+      \A
+      (?<year>[0-9]{2})
+      (?<month>[0-9]{2})
+      (?<day>[0-3][0-9])
+      [0-9]{5}
+      \z
+    }x
+    private_constant :MATCHER_V2
+
+    def valid_v1?
+      return false unless MATCHER_V1.match?(tin)
+      return false if tin == "0000000000"
+
+      tin[-1].to_i == check
+    end
+
+    def valid_v2?
+      match = MATCHER_V2.match(tin)
+      return false unless match
+      return false if tin == "00000000000"
+      return true unless birth_date
+
+      tin_date = date(
+        "#{birth_century}#{match[:year]}",
+        match[:month].to_i - month_increase,
+        match[:day],
+      )
+      tin_date == birth_date
+    end
+
+    def check
+      # 1. Multiply the values of each position by the corresponding weight:
+      weights =
+        [6, 5, 7, 2, 3, 4, 5, 6, 7]
+          .each_with_index
+          .map { |weight, index| weight * tin[index].to_i }
+
+      # 2. Add up the results of the above multiplications;
+      sum = weights.sum
+
+      # 3. Get modulo 11 of the result of the previous addition;
+      # 4. Check digit = remainder (if remainder = 10, the TIN is not valid).
+      sum % 11
+    end
+
+    def birth_century = birth_date.year.to_s[..1].to_i
+
+    def month_increase
+      case birth_century
+      when 18 then 80
+      when 20 then 20
+      when 21 then 40
+      when 22 then 60
+      else 0
+      end
+    end
+  end
+end

data/lib/tin_valid/portugal_tin.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module TinValid
+  class PortugalTin
+    def initialize(tin:)
+      @tin = tin
+    end
+
+    attr_reader :tin
+
+    def valid?
+      return false unless /\A[0-9]{9}\z/.match?(tin)
+      return false if tin == "000000000"
+      return false if tin == "123456789"
+
+      tin[-1].to_i == check
+    end
+
+    private
+
+    def check
+      # 1. Multiply the values of each position by the corresponding weight:
+      multipliers =
+        9
+          .downto(2)
+          .with_index
+          .map { |multiplier, index| multiplier * tin[index].to_i }
+
+      # 2. Add up the results of the above multiplications;
+      sum = multipliers.sum
+
+      # 3. Get modulo 11 of the result of the previous addition;
+      remainder = sum % 11
+
+      # 4. Check digit = 11 - remainder:
+      digit = 11 - remainder
+
+      # If check digit < = 9 then check digit is OK (11 – remainder);
+      return digit if digit <= 9
+
+      # If check digit = 10 then check digit is 0 (zero);
+      # If check digit = 11 then check digit is 0 (zero).
+      0
+    end
+  end
+end