tin_valid 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b248c0be6699ce56b48b082c320833ff8cb5594a62762d298ea66315d8d7555b
-  data.tar.gz: a04549a7599fbadd881f1f905e2c13235d83a3e1d4b7bd8d79dc16393cd18465
+  metadata.gz: c64b5917083db71c567a2b80c3edf35d58d32b07da94b9e0ced0e189a3bb4f13
+  data.tar.gz: 9785af41b29fc7c335d1f7f062ed8ae217a421e145005a783bd56eeb43d75c5a
 SHA512:
-  metadata.gz: 608e79cfe16d11cd236c02a4b5dffa9062a4b26b0f8816c2e9a9da350471917a5cc7ac6802202223ec6936f82cc0f91f9b820118a9c56868b2c6c4a9eaa8f67f
-  data.tar.gz: a17c2624d59049524fbeb5b8adec5263dd6c4009d7bb90c594ad01c499c990a6784515a195bbd3a16148278c32f524b71067b6f0095020dccd24ae5a65987da4
+  metadata.gz: '097ef7fcbdeb7f95b0456fdcd930501f9da4eb85ddb9bc0a5a8e9996d58aa03939fe409d2a0ed7f0c25ae1bee786bcce19a3c079e91969b62839337d581f5d3a'
+  data.tar.gz: e4bb19d3238b04228390f78e505375af8e695f2cb3060c518f6aa6e41b2b61db2f065fc483ade6a84f45213e05c90f55f76b4a18f36f54b1a0615f505bf08e05

data/.rspec

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

data/.rubocop.yml

@@ -8,6 +8,11 @@ AllCops:
 
 # Layout
 
+Layout/LineLength:
+  Max: 80
+  Exclude:
+    - bin/rspec
+
 Layout/MultilineMethodCallIndentation:
   # On multiline calls, indent starting from the receiver.
   # E.g.:

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [1.0.0] - 2025-04-17
+
+Features:
+- Add Italy 🇮🇹
+- Add Latvia 🇱🇻
+- Add Luxembourg 🇱🇺
+- Add Lithuania 🇱🇹
+- Add Malta 🇲🇹
+- Add Netherlands 🇳🇱
+- Add Poland 🇵🇱
+- Add Portugal 🇵🇹
+- Add Romania 🇷🇴
+- Add Slovakia 🇸🇰
+- Add Slovenia 🇸🇮
+- Add Spain 🇪🇸
+- Add United Kingdom 🇬🇧
+
 ## [0.1.1] - 2025-04-15
 
 Features:
@@ -7,7 +24,6 @@ Features:
 - Add Greece 🇬🇷
 - Add Hungary 🇭🇺
 - Add Ireland 🇮🇪
-- Add #normalized to Austria 🇦🇹
 
 ## [0.1.0] - 2025-04-14
 

data/README.md

@@ -14,7 +14,20 @@ Validate Tax Identification Numbers (TINs) for the following European countries:
 - Greece 🇬🇷
 - Hungary 🇭🇺
 - Ireland 🇮🇪
+- Italy 🇮🇹
+- Latvia 🇱🇻
+- Lithuania 🇱🇹
+- Luxembourg 🇱🇺
+- Malta 🇲🇹
+- Netherlands 🇳🇱
+- Poland 🇵🇱
+- Portugal 🇵🇹
+- Romania 🇷🇴
+- Slovakia 🇸🇰
+- Slovenia 🇸🇮
+- Spain 🇪🇸
 - Sweden 🇸🇪
+- United Kingdom 🇬🇧
 
 See also the [descriptions of the structure provided by the European
 Union](https://taxation-customs.ec.europa.eu/online-services/online-services-and-databases-taxation/taxpayer-identification-number-tin_en).
@@ -38,8 +51,7 @@ gem install tin_valid
 
 ```rb
 # Austria
-TinValid::AustriaTin.new(tin: "93-173/6581").valid? # => true
-TinValid::AustriaTin.new(tin: "93-173/6581").normalized # => "931736581"
+TinValid::AustriaTin.new(tin: "…").valid? # => true
 
 # Belgium
 # Optional birth_date
@@ -68,9 +80,67 @@ TinValid::DenmarkTin.new(tin: "…", birth_date: Date.new(…)).valid?
 # Optional birth_date
 TinValid::EstoniaTin.new(tin: "…", birth_date: Date.new(…)).valid?
 
+# Germany
+TinValid::GermanyTin.new(tin: "…").valid?
+
+# Greece
+TinValid::GreeceTin.new(tin: "…").valid?
+
+# Hungary
+TinValid::HungaryTin.new(tin: "…").valid?
+
+# Ireland
+TinValid::IrelandTin.new(tin: "…").valid?
+
+# Italy
+# Optional birth_date
+TinValid::ItalyTin.new(tin: "…", birth_date: Date.new(…)).valid?
+
+# Latvia
+# Optional birth_date
+TinValid::LatviaTin.new(tin: "…", birth_date: Date.new(…)).valid?
+
+# Lithuania
+# Optional birth_date
+TinValid::LithuaniaTin.new(tin: "…", birth_date: Date.new(…)).valid?
+
+# Luxembourg
+# Optional birth_date
+TinValid::LuxembourgTin.new(tin: "…", birth_date: Date.new(…)).valid?
+
+# Malta
+TinValid::MaltaTin.new(tin: "…").valid?
+
+# Netherlands
+TinValid::NetherlandsTin.new(tin: "…").valid?
+
+# Poland
+# Optional birth_date
+TinValid::PolandTin.new(tin: "…", birth_date: Date.new(…)).valid?
+
+# Portugal
+TinValid::PortugalTin.new(tin: "…").valid?
+
+# Romania
+# Optional birth_date
+TinValid::RomaniaTin.new(tin: "…", birth_date: Date.new(…)).valid?
+
+# Slovakia
+# Optional birth_date
+TinValid::SlovakiaTin.new(tin: "…", birth_date: Date.new(…)).valid?
+
+# Slovenia
+TinValid::SloveniaTin.new(tin: "…").valid?
+
+# Spain
+TinValid::SpainTin.new(tin: "…").valid?
+
 # Sweden
 # Optional birth_date
 TinValid::SwedenTin.new(tin: "…", birth_date: Date.new(…)).valid?
+
+# United Kingdom
+TinValid::UnitedKingdomTin.new(tin: "…").valid?
 ```
 
 ## Development

data/lib/tin_valid/germany_tin.rb

@@ -48,13 +48,16 @@ module TinValid
         # 3. Multiply the result by 2;
         result *= 2
 
-        # 4. Take modulo 11 of the result. Update the value of variable X with the result of this operation;
+        # 4. Take modulo 11 of the result. Update the value of variable X with
+        # the result of this operation;
         x = result % 11
 
         # 5. Take C2 + X modulo 10. If result is 0, result is 10;
         # 6. Multiply the result by 2;
-        # 7. Take modulo 11 of the result. Update the value of variable X with the result of this operation;
-        # 8. Apply steps 5, 6 and 7 in an analogue way for digits C3 to C10. Consider that last value called Y;
+        # 7. Take modulo 11 of the result. Update the value of variable X with
+        # the result of this operation;
+        # 8. Apply steps 5, 6 and 7 in an analogue way for digits C3 to C10.
+        # Consider that last value called Y;
         x
       end
 

data/lib/tin_valid/hungary_tin.rb

@@ -11,8 +11,6 @@ module TinValid
     private
 
     def check
-      tin[..-2].chars
-
       # 1. Multiply the values of each position by the corresponding weight:
       # 2. Add up the results of the above multiplications;
       result = (1..9).each_with_index.sum { |num, i| num * tin[i].to_i }

data/lib/tin_valid/italy_tin.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module TinValid
+  # rubocop:disable Metrics/ClassLength
+  class ItalyTin
+    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
+
+    def date?(year, month, day)
+      found_date = date(year, month, day)
+      found_date && found_date < Date.today
+    end
+
+    def date(year, month, day)
+      Date.new(year.to_i, month.to_i, day.to_i)
+    rescue Date::Error
+      nil
+    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,59 @@
+# frozen_string_literal: true
+
+module TinValid
+  class LatviaTin < Data.define(:tin, :birth_date)
+    def initialize(tin:, birth_date: nil)
+      super
+    end
+
+    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
+
+      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,72 @@
+# frozen_string_literal: true
+
+module TinValid
+  class LithuaniaTin < Data.define(:tin, :birth_date)
+    def initialize(tin:, birth_date: nil)
+      super
+    end
+
+    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,107 @@
+# frozen_string_literal: true
+
+module TinValid
+  class LuxembourgTin < Data.define(:tin, :birth_date)
+    def initialize(tin:, birth_date: nil)
+      super
+    end
+
+    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 date(year, month, day)
+      Date.new(year.to_i, month.to_i, day.to_i)
+    rescue Date::Error
+      nil
+    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,45 @@
+# frozen_string_literal: true
+
+module TinValid
+  class MaltaTin < Data.define(: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,29 @@
+# frozen_string_literal: true
+
+module TinValid
+  class NetherlandsTin < Data.define(:tin)
+    def valid?
+      return false unless /\A[0-9]{9}\z/.match?(tin)
+
+      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,78 @@
+# frozen_string_literal: true
+
+module TinValid
+  class PolandTin < Data.define(:tin, :birth_date)
+    def initialize(tin:, birth_date: nil)
+      super
+    end
+
+    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)
+
+      tin[-1].to_i == check
+    end
+
+    def valid_v2?
+      match = MATCHER_V2.match(tin)
+      return false unless match
+      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
+
+    def date(year, month, day)
+      Date.new(year.to_i, month.to_i, day.to_i)
+    rescue Date::Error
+      nil
+    end
+  end
+end

data/lib/tin_valid/portugal_tin.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module TinValid
+  class PortugalTin < Data.define(:tin)
+    def valid?
+      return false unless /\A[0-9]{9}\z/.match?(tin)
+
+      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

data/lib/tin_valid/romania_tin.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module TinValid
+  class RomaniaTin < Data.define(:tin, :birth_date)
+    def initialize(tin:, birth_date: nil)
+      super
+    end
+
+    def valid? = valid_v1? || valid_v2?
+
+    private
+
+    MATCHER_V1 = %r{
+      \A
+      (?<century_code>[1-9])
+      (?<year>[0-9]{2})
+      (?<month>[0-1][0-9])
+      (?<day>[0-3][0-9])
+      (?<district>[0-5][0-9])
+      [0-9]{4}
+      \z
+    }x
+    private_constant :MATCHER_V1
+
+    MATCHER_V2 = %r{
+      \A
+      9
+      000
+      [0-9]{8,9}
+      \z
+    }x
+    private_constant :MATCHER_V2
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength
+    def valid_v1?
+      match = MATCHER_V1.match(tin)
+      return false unless match
+      return false unless valid_district?(match[:district])
+
+      century = tin_century_from_code(match[:century_code]) || birth_century
+      if century
+        tin_date = date(
+          "#{century}#{match[:year]}",
+          match[:month],
+          match[:day],
+        )
+        return false if tin_date.nil?
+        return false if birth_date && tin_date != birth_date
+      end
+
+      true
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/MethodLength
+
+    def valid_v2? = MATCHER_V2.match?(tin)
+
+    def valid_district?(district)
+      case district.to_i
+      when 1..47, 51..52 then true
+      else false
+      end
+    end
+
+    def birth_century
+      birth_date.year.to_s[..1] if birth_date
+    end
+
+    def tin_century_from_code(code)
+      case code.to_i
+      when 1..2 then 19
+      when 3..4 then 18
+      when 5..6 then 20
+      end
+    end
+
+    def date(year, month, day)
+      Date.new(year.to_i, month.to_i, day.to_i)
+    rescue Date::Error
+      nil
+    end
+  end
+end

data/lib/tin_valid/slovakia_tin.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module TinValid
+  class SlovakiaTin < Data.define(:tin, :birth_date)
+    def initialize(tin:, birth_date: nil)
+      super
+    end
+
+    def valid? = valid_v2? || valid_v1?
+
+    def normalized = tin.tr("/", "")
+
+    private
+
+    MATCHER_V1 = %r{
+      \A
+      (?<year>[0-9]{2})
+      (?<month>[0-6][0-9])
+      (?<day>[0-3][0-9])
+      /?
+      [0-9]{3}
+      (?<check>[0-9])?
+      \z
+    }x
+    private_constant :MATCHER_V1
+
+    MATCHER_V2 = %r{
+      \A
+      [0-9]{10}
+      \z
+    }x
+    private_constant :MATCHER_V2
+
+    # rubocop:disable Metrics/MethodLength
+    def valid_v1?
+      match = MATCHER_V1.match(tin)
+      return false unless match
+
+      year = match[:year].to_i
+      return false if year >= 54 && match[:check].nil?
+
+      if birth_date
+        month = match[:month].to_i
+        month -= 50 if month > 50
+
+        tin_date = date("#{birth_century}#{year}", month, match[:day])
+        return false if tin_date != birth_date
+      end
+
+      true
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def valid_v2? = MATCHER_V2.match?(tin)
+
+    def birth_century = birth_date.year.to_s[..1]
+
+    def date(year, month, day)
+      Date.new(year.to_i, month.to_i, day.to_i)
+    rescue Date::Error
+      nil
+    end
+  end
+end

data/lib/tin_valid/slovenia_tin.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module TinValid
+  class SloveniaTin < Data.define(:tin)
+    def valid?
+      return false unless /\A[1-9][0-9]{7}\z/.match?(tin)
+
+      tin[-1].to_i == check
+    end
+
+    private
+
+    def check
+      # Multiply the values of each position by the corresponding weight:
+      weights =
+        8
+          .downto(2)
+          .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. Check digit = 11 - remainder. If result = 10, Check digit = 0.
+      digit = 11 - remainder
+      digit == 10 ? 0 : digit
+    end
+  end
+end

data/lib/tin_valid/spain_tin.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module TinValid
+  class SpainTin < Data.define(:tin)
+    def valid?
+      valid_v1? || valid_v2?
+    end
+
+    private
+
+    def valid_v1?
+      return false unless /\A[0-9]{1,8}[A-Z]\z/.match?(tin)
+
+      tin[-1] == check_letter(tin)
+    end
+
+    def valid_v2?
+      return false unless /\A[XYZKLM][0-9]{7}[A-Z]\z/.match?(tin)
+
+      tin[-1] == check_v2
+    end
+
+    def check_v2
+      # 0. Replace the leading letter by the corresponding digit and concatenate
+      # the result with the other characters:
+      digit =
+        case tin[0]
+        when "X", "K", "L", "M" then 0
+        when "Y" then 1
+        when "Z" then 2
+        end
+
+      check_letter("#{digit}#{tin[1..]}")
+    end
+
+    def check_letter(code)
+      # 1. Take the remainder of modulo 23 of the 8 first characters;
+      remainder = code[..-2].to_i % 23
+
+      # 2. Add 1 to the remainder of operation 1;
+      # 3. The check letter corresponds to this figure in the table below:
+      "TRWAGMYFPDXBNJZSQVHLCKE"[remainder]
+    end
+  end
+end

data/lib/tin_valid/united_kingdom_tin.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module TinValid
+  class UnitedKingdomTin < Data.define(:tin)
+    def valid?
+      valid_v1? || valid_v2?
+    end
+
+    private
+
+    def valid_v1? = /\A[0-9]{10}\z/.match?(tin)
+
+    def valid_v2?
+      return false unless /\A[A-Z]{2}[0-9]{6}[A-D]?\z/.match?(tin)
+      return false if %w[D F I Q U V].include?(tin[0])
+      return false if %w[D F I Q O U V].include?(tin[1])
+      return false if %w[GB NK TN ZZ].include?(tin[0..1])
+
+      true
+    end
+  end
+end

data/lib/tin_valid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TinValid
-  VERSION = "0.1.1"
+  VERSION = "1.0.0"
 end

data/lib/tin_valid.rb

@@ -14,6 +14,19 @@ require_relative "tin_valid/germany_tin"
 require_relative "tin_valid/greece_tin"
 require_relative "tin_valid/hungary_tin"
 require_relative "tin_valid/ireland_tin"
+require_relative "tin_valid/italy_tin"
+require_relative "tin_valid/latvia_tin"
+require_relative "tin_valid/lithuania_tin"
+require_relative "tin_valid/luxembourg_tin"
+require_relative "tin_valid/malta_tin"
+require_relative "tin_valid/netherlands_tin"
+require_relative "tin_valid/poland_tin"
+require_relative "tin_valid/portugal_tin"
+require_relative "tin_valid/romania_tin"
+require_relative "tin_valid/slovakia_tin"
+require_relative "tin_valid/slovenia_tin"
+require_relative "tin_valid/spain_tin"
+require_relative "tin_valid/united_kingdom_tin"
 require_relative "tin_valid/sweden_tin"
 
 module TinValid; end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: tin_valid
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Sunny Ripert
 bindir: exe
 cert_chain: []
-date: 2025-04-15 00:00:00.000000000 Z
+date: 2025-04-17 00:00:00.000000000 Z
 dependencies: []
 email:
 - sunny@sunfox.org
@@ -35,7 +35,20 @@ files:
 - lib/tin_valid/greece_tin.rb
 - lib/tin_valid/hungary_tin.rb
 - lib/tin_valid/ireland_tin.rb
+- lib/tin_valid/italy_tin.rb
+- lib/tin_valid/latvia_tin.rb
+- lib/tin_valid/lithuania_tin.rb
+- lib/tin_valid/luxembourg_tin.rb
+- lib/tin_valid/malta_tin.rb
+- lib/tin_valid/netherlands_tin.rb
+- lib/tin_valid/poland_tin.rb
+- lib/tin_valid/portugal_tin.rb
+- lib/tin_valid/romania_tin.rb
+- lib/tin_valid/slovakia_tin.rb
+- lib/tin_valid/slovenia_tin.rb
+- lib/tin_valid/spain_tin.rb
 - lib/tin_valid/sweden_tin.rb
+- lib/tin_valid/united_kingdom_tin.rb
 - lib/tin_valid/version.rb
 - sig/tin_valid.rbs
 homepage: https://github.com/cults/tin_valid