tin_valid 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f5b010dba783fef5da5341515542f830f73ac1baeca9fd8334fee16867d07a5a
+  data.tar.gz: 42d87f203dd942dc281636c0f3ff6b21e4104d9ae22904974cc81d7f503ead3a
+SHA512:
+  metadata.gz: 886d2bfe8eb377af5fed28166a3a97f2a56f0c5dddea52c06f5e844d0a6d7194e73750a601422ce9e2a90ed93fe5f7ee99f323c6af56c375d53b5b4a83bb1b30
+  data.tar.gz: '09cd02962705707d397f82dba292263a5414ecf1993bb67c5d87645f6f782a50a74cfe75c97e3cddba494767a8442de2ad6515872b0b5a60d16e4ad22d6f5875'

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,63 @@
+plugins:
+  - rubocop-rspec
+  - rubocop-rake
+
+AllCops:
+  TargetRubyVersion: 3.1
+  NewCops: enable
+
+# Layout
+
+Layout/MultilineMethodCallIndentation:
+  # On multiline calls, indent starting from the receiver.
+  # E.g.:
+  #   while apples_and_oranges
+  #           .sorted_by_color
+  #           .ripe
+  #           .pick
+  #     # …
+  #   end
+  EnforcedStyle: indented_relative_to_receiver
+  Exclude:
+    - spec/**/*
+
+# Metrics
+
+Metrics/BlockLength:
+  # Limit the number of lines in a block.
+  Exclude:
+    - spec/**/*
+
+# Style
+
+Style/Documentation:
+  # Do not require a comment for every class.
+  Enabled: false
+
+Style/NumericPredicate:
+  # Prefer `== 0` over `.zero?`.
+  EnforcedStyle: comparison
+
+Style/RegexpLiteral:
+  # Allow using %r{…} or /…/ for regular expressions.
+  EnforcedStyle: mixed
+
+Style/StringLiterals:
+  # Prefer "double quotes" over 'single quotes'.
+  EnforcedStyle: double_quotes
+
+Style/TrailingCommaInArguments:
+  # Prefer trailing commas in multiline arguments:
+  #   call(
+  #     a: 1,
+  #     b: 2,
+  #   )
+  EnforcedStyleForMultiline: consistent_comma
+
+Style/TrailingCommaInArrayLiteral:
+  # Prefer trailing commas in arrays:
+  #   [
+  #     1,
+  #     2,
+  #   ]
+  EnforcedStyleForMultiline: diff_comma

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-04-14
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Sunny Ripert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,97 @@
+# TinValid
+
+Validate Tax Identification Numbers (TINs) for the following European countries:
+
+- Austria
+- Belgium
+- Bulgaria
+- Croatia
+- Cyprus
+- Czechia
+- Denmark
+- Estonia
+- Sweden
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add tin_valid
+```
+
+If bundler is not being used to manage dependencies, install the gem by
+executing:
+
+```bash
+gem install tin_valid
+```
+
+## Usage
+
+```rb
+# Austria
+TinValid::AustriaTin.new(tin: "…").valid?
+
+# Belgium
+# Optional birth_date
+TinValid::BelgiumTin.new(tin: "…", birth_date: Date.new(…)).valid?
+
+# Bulgaria
+# Optional birth_date
+TinValid::BulgariaTin.new(tin: "…", birth_date: Date.new(…)).valid?
+
+# Croatia
+TinValid::CroatiaTin.new(tin: "…").valid?
+
+# Cyprus
+# Optional kind ("individual" or "company")
+TinValid::CyprusTin.new(tin: "…", kind: "individual").valid?
+
+# Czechia
+# Optional birth_date
+TinValid::CzechiaTin.new(tin: "…", birth_date: Date.new(…)).valid?
+
+# Denmark
+# Optional birth_date
+TinValid::DenmarkTin.new(tin: "…", birth_date: Date.new(…)).valid?
+
+# Estonia
+# Optional birth_date
+TinValid::EstoniaTin.new(tin: "…", birth_date: Date.new(…)).valid?
+
+# Sweden
+# Optional birth_date
+TinValid::SwedenTin.new(tin: "…", birth_date: Date.new(…)).valid?
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake spec` to run the tests. You can also run `bin/console` for an interactive
+prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and the created tag, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+## 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,
+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).
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+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).

data/Rakefile

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

data/lib/tin_valid/austria_tin.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module TinValid
+  class AustriaTin < Data.define(:tin)
+    def valid?
+      return false unless /\A[0-9]{9}\z/.match?(tin)
+
+      tin[-1] == check
+    end
+
+    private
+
+    # rubocop:disable Metrics/AbcSize
+    def check
+      # 1. Multiply the values of each position by the corresponding weight:
+      # - C1: 1
+      # - C2: 2
+      # - C3: 1
+      # - C4: 2
+      # - C5: 1
+      # - C6: 2
+      # - C7: 1
+      # - C8: 2
+      values_by_weight =
+        tin
+          .chars
+          .each_with_index
+          .map { |n, i| n.to_i * (i.even? ? 2 : 1) }
+
+      # 2. If the product of a doubling operation is > 9, sum the digits of the
+      # product;
+      values_by_weight =
+        values_by_weight.map { |n| n > 9 ? n.to_s.chars.sum(&:to_i) : n }
+
+      # 3. Add up the results of the above multiplications;
+      sum = values_by_weight.sum
+
+      # 4. The result of the sum of the digits is subtracted from 100 and the
+      # unit digit of this operation is the check digit.
+      (100 - sum).to_s[-1]
+    end
+    # rubocop:enable Metrics/AbcSize
+  end
+end

data/lib/tin_valid/belgium_tin.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module TinValid
+  class BelgiumTin
+    def initialize(tin:, birth_date: nil)
+      @tin = tin
+      @birth_date = birth_date
+    end
+
+    def valid?
+      return false unless match
+
+      number = tin[..-3]
+      valid_check?("19#{year}", month, day, number) ||
+        valid_check?("20#{year}", month, day, "2#{number}")
+    end
+
+    private
+
+    attr_reader :tin, :birth_date
+
+    MATCHER = %r{
+      \A
+      (?<year>[0-9]{2})
+      (?<month>[0-1][0-9])
+      (?<day>[0-3][0-9])
+      [0-9]{3}
+      (?<check>[0-9]{2})
+      \z
+    }x
+    private_constant :MATCHER
+
+    def match = @match ||= MATCHER.match(tin)
+    def year = match[:year]
+    def month = match[:month]
+    def day = match[:day]
+    def check = match[:check].to_i
+
+    def valid_check?(year, month, day, number)
+      tin_date = date(year, month, day)
+      return false if tin_date.nil?
+      return false if birth_date && birth_date != tin_date
+
+      check == digit_check(number)
+    end
+
+    # 1. Get the remainder of the division by 97 of the number composed by
+    # C1, C2, C3, C4, C5, C6, C7, C8 and C9;
+    #
+    # Also, alternatively:
+    #
+    # 1. Get the remainder of the division by 97 of the number composed by
+    # number 2 and C1, C2, C3, C4, C5, C6, C7, C8 and C9;
+    #
+    # 2. 97 - remainder of the previous division is the check number
+    def digit_check(number) = 97 - (number.to_i % 97)
+
+    def date(year, month, day)
+      # A month (in the range 00...12, 00 is acceptable for person not born in
+      # Belgium and with an uncertain date of birth).
+      month = 1 if month == "00"
+
+      # A day of month (in the range 00...31 depending on month and year, 00 is
+      # acceptable for person not born in Belgium and with an uncertain date of
+      # birth).
+      day = 1 if day == "00"
+
+      Date.new(year.to_i, month.to_i, day.to_i)
+    rescue Date::Error
+      nil
+    end
+  end
+end

data/lib/tin_valid/bulgaria_tin.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module TinValid
+  class BulgariaTin < Data.define(:tin, :birth_date)
+    def initialize(tin:, birth_date: nil)
+      super
+    end
+
+    def valid?
+      match = MATCHER.match(tin)
+      return false unless match
+
+      year = match[:year]
+      month = match[:month]
+      day = match[:day]
+      return false unless accepted_date?(year, month, day)
+
+      tin[-1].to_i == check
+    end
+
+    private
+
+    MATCHER = %r{
+      \A
+      (?<year>[0-9]{2})
+      (?<month>[0-5][0-9])
+      (?<day>[0-3][0-9])
+      [0-9]{4}
+      \z
+    }x
+    private_constant :MATCHER
+
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    def accepted_date?(year, month, day)
+      month = month.to_i
+      day = day.to_i
+
+      if birth_date.nil?
+        past_date?("18#{year}", month - 20, day) ||
+          past_date?("19#{year}", month, day) ||
+          past_date?("20#{year}", month - 40, day)
+      elsif birth_year < 1900
+        birth_date == date("18#{year}", month - 20, day)
+      elsif birth_year < 2000
+        birth_date == date("19#{year}", month, day)
+      else
+        birth_date == date("20#{year}", month - 40, day)
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
+
+    def birth_year = birth_date.year
+
+    def past_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
+
+    def check
+      weights = [2, 4, 8, 5, 10, 9, 7, 3, 6]
+
+      # 1. Multiply the values of each position by the corresponding weight
+      values_by_weight =
+        tin[..-2]
+          .chars
+          .zip(weights)
+          .map { |char, weight| char.to_i * weight }
+
+      # 2. Add up the results of the above multiplications
+      sum = values_by_weight.sum
+
+      # 3. Get modulo 11 of the result of the previous addition
+      remainder = sum % 11
+
+      # 4. Check digit = remainder if remainder < 10
+      # Check digit = 0 if remainder = 10
+      remainder < 10 ? remainder : 0
+    end
+  end
+end

data/lib/tin_valid/croatia_tin.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module TinValid
+  class CroatiaTin < Data.define(:tin)
+    def valid?
+      return false unless /\A[0-9]{11}\z/.match?(tin)
+
+      tin[-1].to_i == check
+    end
+
+    private
+
+    # Check digit by the international standard ISO 7064 (MOD 11, 10).
+    def check
+      last_rest = tin[..-2].chars.inject(10) do |rest, digit|
+        # 1. C1 is summed with 10
+        sum = digit.to_i + rest
+
+        # 2. The sum integer is divided by 10, and the rest is kept;
+        # if that number is 0 it gets replaced by number 10 (this latter number
+        # is called subtotal);
+        subtotal = sum % 10 == 0 ? 10 : sum % 10
+
+        # 3. The obtained subtotal is multiplied by 2
+        subtotal *= 2
+
+        # 4. The obtained number is divided by 11, and the rest is kept; this
+        # number mathematically cannot be 0 because the result of the previous
+        # step is always an even number
+        #
+        # 5. The next digit is summed with the rest from the previous step;
+        # 6. Steps 2, 3, 4 and 5 are repeated until all digits are expanded
+        subtotal % 11
+      end
+
+      # 7. If the rest of the final step is equal to 1, the check digit is 0.
+      # Otherwise, the check digit is a difference between 11 and the rest in
+      # the last step
+      last_rest == 1 ? 0 : 11 - last_rest
+    end
+  end
+end

data/lib/tin_valid/cyprus_tin.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module TinValid
+  class CyprusTin < Data.define(:tin, :kind)
+    def initialize(tin:, kind: nil)
+      super
+    end
+
+    def valid?
+      matcher.match?(tin) && check == tin[-1]
+    end
+
+    private
+
+    def matcher
+      if kind == "individual"
+        /\A[069][0-9]{7}[A-Z]\z/
+      elsif kind == "company"
+        /\A[1234578][0-9]{7}[A-Z]\z/
+      else
+        /\A[0-9]{8}[A-Z]\z/
+      end
+    end
+
+    def check
+      # 1. Add up the numbers in the even positions;
+      even_sum = numbers.each_with_index.sum do |number, index|
+        index.odd? ? number : 0
+      end
+
+      # 2. Consider all the numbers at the odd positions of the field and for
+      # each number find the corresponding value from the table below, and add
+      # them up:
+      odd_number_values = [1, 0, 5, 7, 9, 13, 15, 17, 19, 21]
+      odd_sum = numbers.each_with_index.sum do |number, index|
+        index.even? ? odd_number_values[number] : 0
+      end
+
+      # 3. Add the two sums obtained;
+      addition = even_sum + odd_sum
+
+      # 4. Get modulo 26 of the result of the previous addition;
+      remainder = addition % 26
+
+      # 5. Remainder + 65 gives the American Standard Code for Information
+      # Interchange (ASCII) code of a character (A to Z) which is the check
+      # character.
+      (remainder + 65).chr
+    end
+
+    def numbers = tin[..-2].chars.map(&:to_i)
+  end
+end

data/lib/tin_valid/czechia_tin.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module TinValid
+  class CzechiaTin < Data.define(:tin, :birth_date)
+    def initialize(tin:, birth_date: nil)
+      super
+    end
+
+    def valid? = valid_v1? || valid_v2?
+
+    private
+
+    MATCHER_V1 = %r{
+      \A
+      (?<year>[0-9]{2})
+      (?<month>[0156][0-9])
+      (?<day>[0-3][0-9])
+      [0-9]{3}
+      \z
+    }x
+    private_constant :MATCHER_V1
+
+    MATCHER_V2 = %r{
+      \A
+      (?<year>[0-9]{2})
+      (?<month>[0-8][0-9])
+      (?<day>[0-3][0-9])
+      [0-9]{4}
+      \z
+    }x
+    private_constant :MATCHER_V2
+
+    def valid_v1?
+      match = MATCHER_V1.match(tin)
+      return false unless match
+      return true if birth_date.nil?
+      return false if year_of_birth >= 1954
+
+      year = "#{birth_century}#{match[:year]}"
+
+      # Month (in the range 1...12 for men) or month + 50 (in the range 51…62
+      # for women).
+      month = match[:month].to_i
+      month -= 50 if month > 50
+
+      birth_date == date(year, month, match[:day])
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    def valid_v2?
+      match = MATCHER_V2.match(tin)
+      return false unless match
+      return true if birth_date.nil?
+      return false if year_of_birth < 1954
+
+      # Two last digits of a year: Must be within the range:
+      # 00 - last two digits of current year for people born in 2000 and later;
+      # 54 - 99 for people born between 1954 and 1999.
+      year = "#{birth_century}#{match[:year]}"
+
+      # Month (in the range 1...12 only for men) or month + 20 (in the range
+      # 21…32 only for men) or month + 50 (in the range 51...62 only for women)
+      # or month + 70 (in the range 71…82 only for women).
+      month = match[:month].to_i
+      if month > 70
+        month -= 70
+      elsif month > 50
+        month -= 50
+      elsif month > 20
+        month -= 20
+      end
+
+      birth_date == date(year, month, match[:day])
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
+
+    def year_of_birth = birth_date&.year
+    def birth_century = birth_date.strftime("%Y")[..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/denmark_tin.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module TinValid
+  class DenmarkTin < Data.define(:tin, :birth_date)
+    def initialize(tin:, birth_date: nil)
+      super
+    end
+
+    def valid?
+      match = MATCHER.match(tin)
+      return false unless match
+
+      if birth_date
+        year = "#{birth_century}#{match[:year]}"
+        return false if birth_date != date(year, match[:month], match[:day])
+
+        return false unless check_serial(match[:serial], match[:year])
+      end
+
+      match[:check].to_i == checksum
+    end
+
+    private
+
+    MATCHER = %r{
+      \A
+      (?<day>[0-3][0-9])
+      (?<month>[0-1][0-9])
+      (?<year>[0-9]{2})
+      (?<serial>
+        [0-9]{3}
+        (?<check>[0-9])
+      )
+      \z
+    }x
+    private_constant :MATCHER
+
+    def birth_century = birth_date.strftime("%Y")[..1]
+    def birth_year = birth_date.year
+
+    def date(year, month, day)
+      Date.new(year.to_i, month.to_i, day.to_i)
+    rescue Date::Error
+      nil
+    end
+
+    def checksum
+      # 1. Multiply the values of each position by the corresponding weight:
+      weights =
+        [4, 3, 2, 7, 6, 5, 4, 3, 2]
+          .each_with_index
+          .map { |char, index| char.to_i * 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. The remainder
+      # must not be 1;
+      remainder = sum % 11
+
+      return if remainder == 1
+
+      # 4. Check digit = 11 – remainder, or check digit = 0 if the result of the
+      # modulo operation of the third step is 0.
+      remainder == 0 ? 0 : 11 - remainder
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/PerceivedComplexity
+    def check_serial(serial, year)
+      case serial.to_i
+      in 1..3999
+        (1900..1999).cover?(birth_year)
+      in 4000..4999, 9000..9999
+        case year.to_i
+        in 0..36 then (2000..2036).cover?(birth_year)
+        in 36..99 then (1937..1999).cover?(birth_year)
+        end
+      in 5000..8999
+        case year.to_i
+        in 0..36 then (2000..2036).cover?(birth_year)
+        in 37..57 then false
+        in 58..99 then (1858..1899).cover?(birth_year)
+        end
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/PerceivedComplexity
+  end
+end

data/lib/tin_valid/estonia_tin.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module TinValid
+  class EstoniaTin < Data.define(:tin, :birth_date)
+    def initialize(tin:, birth_date: nil)
+      super
+    end
+
+    def valid?
+      match = MATCHER.match(tin)
+      return false unless match
+      return false unless (1..710).cover?(match[:id].to_i)
+
+      if birth_date
+        year = "#{birth_century}#{match[:year]}"
+        return false if birth_date != date(year, match[:month], match[:day])
+      end
+
+      match[:check].to_i == checksum
+    end
+
+    private
+
+    MATCHER = %r{
+      \A
+      [1-6]
+      (?<year>[0-9]{2})
+      (?<month>[0-1][0-9])
+      (?<day>[0-3][0-9])
+      (?<id>[0-7][0-9]{2})
+      (?<check>[0-9])
+      \z
+    }x
+    private_constant :MATCHER
+
+    def birth_century = birth_date.strftime("%Y")[..1]
+    def birth_year = birth_date.year
+
+    def date(year, month, day)
+      Date.new(year.to_i, month.to_i, day.to_i)
+    rescue Date::Error
+      nil
+    end
+
+    def checksum
+      # 1. Multiply the values of each position by the corresponding weight:
+      # 2. Add up the results of the above multiplications;
+      sum = sum_weights([1, 2, 3, 4, 5, 6, 7, 8, 9, 1])
+
+      # 3. Get modulo 11 of the result of the previous addition.
+      remainder = sum % 11
+
+      # 4. Check digit
+      # a. If remainder is less than 10, the remainder is the check digit;
+      return remainder if remainder < 10
+
+      # b. If remainder is 10, use the following table instead of the previous
+      # one:
+      sum = sum_weights([3, 4, 5, 6, 7, 8, 9, 1, 2, 3])
+
+      # If remainder is less than 10, the remainder is the check digit;
+      remainder = sum % 11
+      return remainder if remainder < 10
+
+      # If remainder is 10, the check digit is 0.
+      0
+    end
+
+    def sum_weights(weights)
+      weights.each_with_index.sum do |char, index|
+        char.to_i * tin[index].to_i
+      end
+    end
+  end
+end

data/lib/tin_valid/sweden_tin.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module TinValid
+  class SwedenTin < Data.define(:tin, :birth_date)
+    def initialize(tin:, birth_date: nil)
+      super
+    end
+
+    def valid?
+      VERSIONS.any? do |matcher|
+        match = matcher.match(tin)
+        next false unless match
+
+        year = match[:year]
+        month = match[:month]
+        day = match[:day]
+        next false unless date_valid?(year, month, day)
+
+        id = match[:id]
+        match[:check].to_i == checksum("#{year[..2]}#{month}#{day}#{id}")
+      end
+    end
+
+    private
+
+    VERSIONS = [
+      %r{
+        \A
+        (?<year>[0-9]{2})
+        (?<month>[0-1][0-9])
+        (?<day>[0-3][0-9])
+        -
+        (?<id>[0-9]{3})
+        (?<check>[0-9])
+        \z
+      }x,
+      %r{
+        \A
+        (?<year>[0-9]{2})
+        (?<month>[0-1][0-9])
+        (?<day>[6-9][0-9])
+        -
+        (?<id>[0-9]{3})
+        (?<check>[0-9])
+        \z
+      }x,
+      %r{
+        \A
+        (?<year>1[89][0-9]{2})
+        (?<month>[0-1][0-9])
+        (?<day>[0-3][0-9])
+        (?<id>[0-9]{3})
+        (?<check>[0-9])
+        \z
+      }x,
+      %r{
+        \A
+        (?<year>(?:18|19|20)[0-9]{2})
+        (?<month>[0-1][0-9])
+        (?<day>[6-9][0-9])
+        (?<id>[0-9]{3})
+        (?<check>[0-9])
+        \z
+      }x,
+    ].freeze
+    private_constant :VERSIONS
+
+    def checksum(numbers)
+      # 1. Multiply the values of each position by the corresponding weight:
+      # - C1: 2
+      # - C2: 1
+      # - C3: 2
+      # - C4: 1
+      # - C5: 2
+      # - C6: 1
+      # - C7: 2
+      # - C8: 1
+      # - C9: 2
+      values_by_weight =
+        numbers
+          .chars
+          .each_with_index
+          .map { |n, i| n.to_i * (i.even? ? 2 : 1) }
+
+      # 2. Add up the results of the above multiplications. NB: 12 is regarded
+      # as 1 + 2;
+      sum = values_by_weight.join.chars.sum(&:to_i)
+
+      # 3. The unit digit in the sum of the digits is subtracted from 10 and the
+      # result is the check digit. If the resulting number is 10, the check
+      # digit is 0.
+      last_digit = sum % 10
+      last_digit == 0 ? 0 : 10 - last_digit
+    end
+
+    def date_valid?(year, month, day)
+      day = day.to_i
+      day -= 60 if day > 60
+
+      if birth_date
+        year = "#{birth_date.strftime('%Y')[..1]}#{year}" if year.size == 2
+        birth_date == date(year, month, day)
+      else
+        date(year, month, day) ||
+          date("19#{year}", month, day) ||
+          date("20#{year}", month, day)
+      end
+    end
+
+    def date(year, month, day)
+      found_date = Date.new(year.to_i, month.to_i, day.to_i)
+      found_date if found_date < Date.today
+    rescue Date::Error
+      nil
+    end
+  end
+end

data/lib/tin_valid/version.rb

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

data/lib/tin_valid.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "date"
+require_relative "tin_valid/version"
+require_relative "tin_valid/austria_tin"
+require_relative "tin_valid/belgium_tin"
+require_relative "tin_valid/bulgaria_tin"
+require_relative "tin_valid/croatia_tin"
+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/sweden_tin"
+
+module TinValid
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/tin_valid.rbs

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

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: tin_valid
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sunny Ripert
+bindir: exe
+cert_chain: []
+date: 2025-04-14 00:00:00.000000000 Z
+dependencies: []
+email:
+- sunny@sunfox.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/tin_valid.rb
+- lib/tin_valid/austria_tin.rb
+- lib/tin_valid/belgium_tin.rb
+- lib/tin_valid/bulgaria_tin.rb
+- lib/tin_valid/croatia_tin.rb
+- lib/tin_valid/cyprus_tin.rb
+- lib/tin_valid/czechia_tin.rb
+- lib/tin_valid/denmark_tin.rb
+- lib/tin_valid/estonia_tin.rb
+- lib/tin_valid/sweden_tin.rb
+- lib/tin_valid/version.rb
+- sig/tin_valid.rbs
+homepage: https://github.com/cults/tin_valid
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/cults/tin_valid
+  source_code_uri: https://github.com/cults/tin_valid
+  changelog_uri: https://github.com/cults/tin_valid/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.5
+specification_version: 4
+summary: Validate Tax Identification Numbers (TINs) in Europe
+test_files: []