tin_valid 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5b010dba783fef5da5341515542f830f73ac1baeca9fd8334fee16867d07a5a
-  data.tar.gz: 42d87f203dd942dc281636c0f3ff6b21e4104d9ae22904974cc81d7f503ead3a
+  metadata.gz: c64b5917083db71c567a2b80c3edf35d58d32b07da94b9e0ced0e189a3bb4f13
+  data.tar.gz: 9785af41b29fc7c335d1f7f062ed8ae217a421e145005a783bd56eeb43d75c5a
 SHA512:
-  metadata.gz: 886d2bfe8eb377af5fed28166a3a97f2a56f0c5dddea52c06f5e844d0a6d7194e73750a601422ce9e2a90ed93fe5f7ee99f323c6af56c375d53b5b4a83bb1b30
-  data.tar.gz: '09cd02962705707d397f82dba292263a5414ecf1993bb67c5d87645f6f782a50a74cfe75c97e3cddba494767a8442de2ad6515872b0b5a60d16e4ad22d6f5875'
+  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,41 @@
 ## [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:
+- Add Germany 🇩🇪
+- Add Greece 🇬🇷
+- Add Hungary 🇭🇺
+- Add Ireland 🇮🇪
+
 ## [0.1.0] - 2025-04-14
 
-- Initial release
+- Initial release with:
+  - Austria 🇦🇹
+  - Belgium 🇧🇪
+  - Bulgaria 🇧🇬
+  - Croatia 🇭🇷
+  - Cyprus 🇨🇾
+  - Czechia 🇨🇿
+  - Denmark 🇩🇰
+  - Estonia 🇪🇪
+  - Germany 🇩🇪
+  - Greece 🇬🇷
+  - Sweden 🇸🇪

data/README.md

@@ -1,20 +1,40 @@
-# TinValid
+# TinValid 🇪🇺
 
 Validate Tax Identification Numbers (TINs) for the following European countries:
 
-- Austria
-- Belgium
-- Bulgaria
-- Croatia
-- Cyprus
-- Czechia
-- Denmark
-- Estonia
-- Sweden
+- Austria 🇦🇹
+- Belgium 🇧🇪
+- Bulgaria 🇧🇬
+- Croatia 🇭🇷
+- Cyprus 🇨🇾
+- Czechia 🇨🇿
+- Denmark 🇩🇰
+- Estonia 🇪🇪
+- Germany 🇩🇪
+- 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).
 
 ## Installation
 
-Install the gem and add to the application's Gemfile by executing:
+Add the gem to your application’s Gemfile by executing:
 
 ```bash
 bundle add tin_valid
@@ -31,7 +51,7 @@ gem install tin_valid
 
 ```rb
 # Austria
-TinValid::AustriaTin.new(tin: "…").valid?
+TinValid::AustriaTin.new(tin: "…").valid? # => true
 
 # Belgium
 # Optional birth_date
@@ -60,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
@@ -80,10 +158,10 @@ git commits and the created tag, and push the `.gem` file to
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at
-https://github.com/sunny/tin_valid. This project is intended to be a safe,
+https://github.com/cults/tin_valid. This project is intended to be a safe,
 welcoming space for collaboration, and contributors are expected to adhere to
 the
-[code of conduct](https://github.com/sunny/tin_valid/blob/main/CODE_OF_CONDUCT.md).
+[code of conduct](https://github.com/cults/tin_valid/blob/main/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -94,4 +172,4 @@ The gem is available as open source under the terms of the
 
 Everyone interacting in the TinValid project's codebases, issue trackers, chat
 rooms and mailing lists is expected to follow the
-[code of conduct](https://github.com/sunny/tin_valid/blob/main/CODE_OF_CONDUCT.md).
+[code of conduct](https://github.com/cults/tin_valid/blob/main/CODE_OF_CONDUCT.md).

data/lib/tin_valid/austria_tin.rb

@@ -1,15 +1,28 @@
 # frozen_string_literal: true
 
 module TinValid
-  class AustriaTin < Data.define(:tin)
+  class AustriaTin
+    def initialize(tin:)
+      @tin = tin
+    end
+
+    attr_reader :tin
+
     def valid?
-      return false unless /\A[0-9]{9}\z/.match?(tin)
+      return false unless MATCHER.match?(normalized)
 
-      tin[-1] == check
+      normalized[-1] == check
+    end
+
+    def normalized
+      @normalized ||= tin.to_s.strip.tr("-/", "")
     end
 
     private
 
+    MATCHER = %r{\A[0-9]{2}-?[0-9]{3}/?[0-9]{4}\z}
+    private_constant :MATCHER
+
     # rubocop:disable Metrics/AbcSize
     def check
       # 1. Multiply the values of each position by the corresponding weight:
@@ -22,10 +35,10 @@ module TinValid
       # - C7: 1
       # - C8: 2
       values_by_weight =
-        tin
-          .chars
+        normalized
+          .chars[..-2]
           .each_with_index
-          .map { |n, i| n.to_i * (i.even? ? 2 : 1) }
+          .map { |n, i| n.to_i * (i.even? ? 1 : 2) }
 
       # 2. If the product of a doubling operation is > 9, sum the digits of the
       # product;

data/lib/tin_valid/germany_tin.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module TinValid
+  class GermanyTin < Data.define(:tin)
+    def valid?
+      valid_v1? || valid_v2?
+    end
+
+    private
+
+    def valid_v1?
+      # 1. 13 characters
+      # 2. Only digits
+      # 3. C5 is a 0
+      /\A[0-9]{4}0[0-9]{8}\z/.match?(tin)
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def valid_v2?
+      # C1: Must never be 0.
+      return false unless /\A[1-9][0-9]{10}\z/.match?(tin)
+
+      # C1-C10: One and only one mandatory duplicate or triple value:
+      # - One of the first ten digits is used twice (the recurrent digits do
+      #   not have to be located at subsequent positions but they can be);
+      # - One of the first ten digits is used tree times (only two recurrent
+      #   digits are allowed to be one after another).
+      consecutive_chars =
+        tin[..-2]
+          .chars
+          .group_by(&:itself)
+          .select { |_, chars| chars.size > 1 }
+
+      return false if consecutive_chars.size != 1
+      return false if consecutive_chars.first.last.size > 3
+
+      tin[-1].to_i == check_v2
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def check_v2
+      # 1. Initialize the variable X to 10.
+      y = tin[..-2].chars.inject(10) do |x, char|
+        # 2. Take C1 + X modulo 10. If result is 0, result is 10;
+        result = (char.to_i + x) % 10
+        result = 10 if result == 0
+
+        # 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;
+        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;
+        x
+      end
+
+      # 9. 11 - Y = check digit. If check digit = 10, replace it by 0.
+      check = 11 - y
+      check == 10 ? 0 : check
+    end
+  end
+end

data/lib/tin_valid/greece_tin.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module TinValid
+  class GreeceTin < Data.define(:tin)
+    def valid?
+      /\A[0-9]{9}\z/.match?(tin)
+    end
+  end
+end

data/lib/tin_valid/hungary_tin.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module TinValid
+  class HungaryTin < Data.define(:tin)
+    def valid?
+      return false unless /\A8[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:
+      # 2. Add up the results of the above multiplications;
+      result = (1..9).each_with_index.sum { |num, i| num * tin[i].to_i }
+
+      # 3. Get modulo 11 of the result of the previous addition;
+      # 4. Check digit = remainder.
+      result % 11
+    end
+  end
+end

data/lib/tin_valid/ireland_tin.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module TinValid
+  class IrelandTin < Data.define(:tin)
+    def valid?
+      /\A[0-9]{7}[A-W][A-IW]?\z/.match?(tin) &&
+        tin.chars[7] == check
+    end
+
+    private
+
+    # rubocop:disable Metrics/AbcSize
+    def check
+      # 1. In reverse order, each digit is multiplied by a weight started at 2:
+      weights = 8.downto(2)
+      digits = weights.with_index.map { |weight, i| weight * tin.chars[i].to_i }
+
+      # 2. LetterToNumber(C9) is based on the following mapping:
+      # “A”=1, “B”=2, “C”=3, “D”=4, “E”=5, “F”=6, “G”=7, “H”=8, “I”=9
+      # A “W” or absence of character in position 9 is allocated a numeric
+      # value of 0.
+      digits.push letter_to_number(tin.chars[9 - 1]) * 9
+
+      # 3. Add up each result;
+      sum = digits.sum
+
+      # 4. The remainder of the modulo 23 indicates the character position on
+      # the alphabet according to the following mapping:
+      # 0=”W”, 1=”A”, 2=”B”, 3=”C”… 22=”V”
+      number_to_letter(sum % 23)
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def letter_to_number(letter)
+      return 0 if letter.nil?
+
+      case letter
+      in "W" then 0
+      in "A".."I" then letter.ord - 64
+      end
+    end
+
+    def number_to_letter(number)
+      case number
+      in 0 then "W"
+      in 1..22 then (number + 64).chr
+      end
+    end
+  end
+end

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.0"
+  VERSION = "1.0.0"
 end

data/lib/tin_valid.rb

@@ -10,9 +10,23 @@ require_relative "tin_valid/cyprus_tin"
 require_relative "tin_valid/czechia_tin"
 require_relative "tin_valid/denmark_tin"
 require_relative "tin_valid/estonia_tin"
+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
-  class Error < StandardError; end
-  # Your code goes here...
-end
+module TinValid; end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: tin_valid
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Sunny Ripert
 bindir: exe
 cert_chain: []
-date: 2025-04-14 00:00:00.000000000 Z
+date: 2025-04-17 00:00:00.000000000 Z
 dependencies: []
 email:
 - sunny@sunfox.org
@@ -31,7 +31,24 @@ files:
 - lib/tin_valid/czechia_tin.rb
 - lib/tin_valid/denmark_tin.rb
 - lib/tin_valid/estonia_tin.rb
+- lib/tin_valid/germany_tin.rb
+- 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