israeli 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 775d9b34a1173bd2bbab00ca4a86f13d8fb340c13ee84d15f5893cdc7d1d6dab
+  data.tar.gz: 6b872c2ebbd7bd5573854e20f79e5bbd1ae5de265a879f370af625a0a2a00d8a
+SHA512:
+  metadata.gz: d5d9bc4d5d2b1e874221c84612307533dfc252a077c2fe5c388cfb55ca4283f39e180656353697ac38e65285a1f700bc1786f37791ff8b401f09e1252255852e
+  data.tar.gz: de83f4a136c0f53111ba505cd9165c02fac56e044a2e3d9d2819a9d459e91b4a792c50fd6b8090dc2365cc1b12de0f98d3a45225fb3685b0a2088198205c211f

data/CHANGELOG.md

@@ -0,0 +1,48 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2025-12-03
+
+### Added
+
+- **Israeli ID Validator (Mispar Zehut)**
+  - 9-digit validation with Luhn algorithm checksum
+  - Automatic left-padding for shorter inputs
+  - Format stripping (spaces, hyphens)
+  - `Israeli.valid_id?` and `Israeli.format_id` methods
+  - `IsraeliIdValidator` for ActiveModel/Rails
+
+- **Phone Number Validator**
+  - Mobile numbers (05X prefix, 10 digits)
+  - Landline numbers (02-09 area codes, 9 digits)
+  - VoIP numbers (07X prefix, 10 digits)
+  - International format support (+972 prefix)
+  - `Israeli.valid_phone?` with `:type` option
+  - `IsraeliPhoneValidator` for ActiveModel/Rails with `:type` option
+
+- **Postal Code Validator (Mikud)**
+  - 7-digit format validation
+  - Space separator support
+  - `Israeli.valid_postal_code?` method
+  - `IsraeliPostalCodeValidator` for ActiveModel/Rails
+
+- **Bank Account Validator**
+  - Domestic format (13 digits: 2-3-8 structure)
+  - IBAN format with mod 97 checksum validation
+  - `Israeli.valid_bank_account?` with `:format` option
+  - `IsraeliBankAccountValidator` for ActiveModel/Rails with `:format` option
+
+- **Core Utilities**
+  - `Israeli::Luhn` - Luhn mod 10 checksum algorithm
+  - `Israeli::Sanitizer` - Input normalization utilities
+  - `Israeli::Railtie` - Automatic Rails integration
+
+- **Rails Integration**
+  - All validators support `allow_nil`, `allow_blank`, and `message` options
+  - Automatic loading via Railtie in Rails applications

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 dpaluy
+
+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,187 @@
+# Israeli
+
+[![Gem Version](https://img.shields.io/gem/v/israeli.svg)](https://rubygems.org/gems/israeli)
+[![CI](https://github.com/dpaluy/israeli/actions/workflows/ci.yml/badge.svg)](https://github.com/dpaluy/israeli/actions/workflows/ci.yml)
+
+Validation utilities for Israeli identifiers including ID numbers (Mispar Zehut), phone numbers, postal codes, and bank accounts.
+
+## Features
+
+- **Israeli ID (Mispar Zehut)** - 9-digit validation with Luhn checksum
+- **Phone Numbers** - Mobile (05X), landline (02-09), and VoIP (07X)
+- **Postal Codes** - 7-digit Israeli postal codes (Mikud)
+- **Bank Accounts** - Domestic (13-digit) and IBAN formats with mod 97 validation
+- **Rails Integration** - ActiveModel validators with standard options
+- **Zero Dependencies** - Pure Ruby, no external runtime dependencies
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "israeli"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or install directly:
+
+```bash
+gem install israeli
+```
+
+## Usage
+
+### Standalone Validation
+
+```ruby
+require "israeli"
+
+# Israeli ID (Mispar Zehut)
+Israeli.valid_id?("123456782")     # => true
+Israeli.valid_id?("12345678-2")    # => true (formatted input OK)
+Israeli.valid_id?("123456789")     # => false (invalid checksum)
+
+# Phone Numbers
+Israeli.valid_phone?("0501234567")                    # => true (any type)
+Israeli.valid_phone?("0501234567", type: :mobile)     # => true
+Israeli.valid_phone?("+972501234567", type: :mobile)  # => true (international format)
+Israeli.valid_phone?("021234567", type: :landline)    # => true (Jerusalem)
+Israeli.valid_phone?("0721234567", type: :voip)       # => true
+
+# Postal Codes
+Israeli.valid_postal_code?("2610101")    # => true
+Israeli.valid_postal_code?("26101 01")   # => true (with space)
+
+# Bank Accounts
+Israeli.valid_bank_account?("4985622815429")              # => true (domestic)
+Israeli.valid_bank_account?("49-856-22815429")            # => true (formatted)
+Israeli.valid_bank_account?("IL620108000000099999999")    # => true (IBAN)
+Israeli.valid_bank_account?("IL62 0108 0000 0009 9999 999") # => true (spaced IBAN)
+```
+
+### Formatting
+
+```ruby
+# Format ID to 9 digits
+Israeli.format_id("12345678-2")  # => "123456782"
+Israeli.format_id("12345678")    # => "012345678" (pads with zero)
+
+# Format phone numbers
+Israeli.format_phone("0501234567")                      # => "050-123-4567"
+Israeli.format_phone("0501234567", style: :international) # => "+972-501234567"
+Israeli.format_phone("021234567")                       # => "02-123-4567"
+```
+
+### Rails / ActiveModel Integration
+
+When used in a Rails application, validators are automatically loaded via Railtie.
+
+```ruby
+class Person < ApplicationRecord
+  validates :id_number, israeli_id: true
+  validates :mobile_phone, israeli_phone: { type: :mobile }
+  validates :postal_code, israeli_postal_code: { allow_blank: true }
+  validates :bank_account, israeli_bank_account: { format: :iban }
+end
+```
+
+#### Validator Options
+
+All validators support standard ActiveModel options:
+
+```ruby
+# Allow nil/blank values
+validates :id_number, israeli_id: { allow_nil: true }
+validates :postal_code, israeli_postal_code: { allow_blank: true }
+
+# Custom error messages
+validates :id_number, israeli_id: { message: "is not a valid Mispar Zehut" }
+
+# Phone type restriction
+validates :mobile, israeli_phone: { type: :mobile }    # Mobile only (05X)
+validates :office, israeli_phone: { type: :landline }  # Landline only (02-09)
+validates :voip,   israeli_phone: { type: :voip }      # VoIP only (072-079)
+
+# Bank account format restriction
+validates :account, israeli_bank_account: { format: :domestic }  # 13-digit only
+validates :iban,    israeli_bank_account: { format: :iban }      # IBAN only
+```
+
+### Direct Validator Access
+
+For more control, you can use the validator classes directly:
+
+```ruby
+# ID Validator
+Israeli::Validators::Id.valid?("123456782")  # => true
+Israeli::Validators::Id.format("12345678-2") # => "123456782"
+
+# Phone Validator
+Israeli::Validators::Phone.valid?("0501234567", type: :mobile) # => true
+Israeli::Validators::Phone.mobile?("0501234567")               # => true
+Israeli::Validators::Phone.landline?("021234567")              # => true
+
+# Postal Code Validator
+Israeli::Validators::PostalCode.valid?("2610101")                    # => true
+Israeli::Validators::PostalCode.format("2610101", style: :spaced)    # => "26101 01"
+
+# Bank Account Validator
+Israeli::Validators::BankAccount.valid?("4985622815429", format: :domestic) # => true
+Israeli::Validators::BankAccount.valid_iban?("IL620108000000099999999")     # => true
+```
+
+## Validation Rules
+
+### Israeli ID (Mispar Zehut)
+- Exactly 9 digits (shorter inputs are left-padded with zeros)
+- Validated using Luhn algorithm (mod 10 checksum)
+- Accepts formatted input (spaces, hyphens are stripped)
+
+### Phone Numbers
+
+| Type | Format | Example |
+|------|--------|---------|
+| Mobile | 05X-XXX-XXXX (10 digits) | 050-123-4567 |
+| Landline | 0X-XXX-XXXX (9 digits) | 02-123-4567 |
+| VoIP | 07X-XXX-XXXX (10 digits) | 072-123-4567 |
+
+- International format (+972) is automatically converted to domestic format
+- Area codes: 02 (Jerusalem), 03 (Tel Aviv), 04 (Haifa), 08 (South), 09 (Sharon)
+
+### Postal Codes
+- Exactly 7 digits
+- Format validation only (no geographic range checking)
+- Accepts with or without space separator
+
+### Bank Accounts
+
+| Format | Structure | Example |
+|--------|-----------|---------|
+| Domestic | XX-XXX-XXXXXXXX (13 digits) | 49-856-22815429 |
+| IBAN | IL + 2 check + 19 digits (23 chars) | IL62 0108 0000 0009 9999 999 |
+
+- IBAN validated with mod 97 checksum
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests.
+
+```bash
+bundle install
+bundle exec rake test      # Run tests
+bundle exec rubocop        # Run linter
+bundle exec rake           # Run both
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dpaluy/israeli.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/israeli/active_model/israeli_bank_account_validator.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+# Validates that an attribute is a valid Israeli bank account number.
+#
+# @example Basic usage (accepts domestic or IBAN)
+#   class BankAccount < ApplicationRecord
+#     validates :account_number, israeli_bank_account: true
+#   end
+#
+# @example Domestic format only
+#   class BankAccount < ApplicationRecord
+#     validates :domestic_account, israeli_bank_account: { format: :domestic }
+#   end
+#
+# @example IBAN format only
+#   class BankAccount < ApplicationRecord
+#     validates :iban, israeli_bank_account: { format: :iban }
+#   end
+class IsraeliBankAccountValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    return if value.blank? && options[:allow_blank]
+    return if value.nil? && options[:allow_nil]
+
+    account_format = options[:format] || :any
+    return if Israeli::Validators::BankAccount.valid?(value, format: account_format)
+
+    record.errors.add(
+      attribute,
+      options[:message] || :invalid
+    )
+  end
+end

data/lib/israeli/active_model/israeli_id_validator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+# Validates that an attribute is a valid Israeli ID number (Mispar Zehut).
+#
+# @example Basic usage
+#   class Person < ApplicationRecord
+#     validates :id_number, israeli_id: true
+#   end
+#
+# @example With options
+#   class Person < ApplicationRecord
+#     validates :id_number, israeli_id: { allow_blank: true, message: "is not a valid Israeli ID" }
+#   end
+class IsraeliIdValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    return if value.blank? && options[:allow_blank]
+    return if value.nil? && options[:allow_nil]
+
+    return if Israeli::Validators::Id.valid?(value)
+
+    record.errors.add(
+      attribute,
+      options[:message] || :invalid
+    )
+  end
+end

data/lib/israeli/active_model/israeli_phone_validator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+# Validates that an attribute is a valid Israeli phone number.
+#
+# @example Basic usage (accepts mobile, landline, or VoIP)
+#   class Contact < ApplicationRecord
+#     validates :phone, israeli_phone: true
+#   end
+#
+# @example Mobile only
+#   class Contact < ApplicationRecord
+#     validates :mobile_phone, israeli_phone: { type: :mobile }
+#   end
+#
+# @example Landline only
+#   class Contact < ApplicationRecord
+#     validates :office_phone, israeli_phone: { type: :landline }
+#   end
+#
+# @example VoIP only
+#   class Contact < ApplicationRecord
+#     validates :voip_number, israeli_phone: { type: :voip }
+#   end
+class IsraeliPhoneValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    return if value.blank? && options[:allow_blank]
+    return if value.nil? && options[:allow_nil]
+
+    phone_type = options[:type] || :any
+    return if Israeli::Validators::Phone.valid?(value, type: phone_type)
+
+    record.errors.add(
+      attribute,
+      options[:message] || :invalid
+    )
+  end
+end

data/lib/israeli/active_model/israeli_postal_code_validator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+# Validates that an attribute is a valid Israeli postal code (Mikud).
+#
+# @example Basic usage
+#   class Address < ApplicationRecord
+#     validates :postal_code, israeli_postal_code: true
+#   end
+#
+# @example With options
+#   class Address < ApplicationRecord
+#     validates :postal_code, israeli_postal_code: { allow_blank: true }
+#   end
+class IsraeliPostalCodeValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    return if value.blank? && options[:allow_blank]
+    return if value.nil? && options[:allow_nil]
+
+    return if Israeli::Validators::PostalCode.valid?(value)
+
+    record.errors.add(
+      attribute,
+      options[:message] || :invalid
+    )
+  end
+end

data/lib/israeli/errors.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Israeli
+  # Base error class for all Israeli validation errors.
+  #
+  # All validation-related exceptions inherit from this class.
+  #
+  # @example Handling errors
+  #   begin
+  #     Israeli.format_id!("invalid")
+  #   rescue Israeli::Error => e
+  #     puts "Validation failed: #{e.message}"
+  #   end
+  class Error < StandardError; end
+
+  # Raised when input format is invalid for the requested validation type.
+  #
+  # @example
+  #   Israeli.format_id!("abc")
+  #   # => Israeli::InvalidFormatError: ID must contain only digits
+  class InvalidFormatError < Error; end
+end

data/lib/israeli/luhn.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Israeli
+  # Luhn algorithm (mod 10) implementation for checksum validation.
+  #
+  # Used by Israeli ID numbers (Mispar Zehut) and potentially business
+  # registration numbers. The Israeli variant uses a left-to-right
+  # processing order (index 0 = multiplier 1, index 1 = multiplier 2, etc.).
+  #
+  # @see https://en.wikipedia.org/wiki/Luhn_algorithm
+  # @see https://en.wikipedia.org/wiki/Israeli_identity_card
+  module Luhn
+    # Validates a string of digits using the Luhn algorithm.
+    #
+    # @param digits [String] A string containing only digits (0-9)
+    # @return [Boolean] true if the checksum is valid, false otherwise
+    #
+    # @example Valid ID
+    #   Israeli::Luhn.valid?("123456782") # => true
+    #
+    # @example Invalid ID
+    #   Israeli::Luhn.valid?("123456789") # => false
+    def self.valid?(digits)
+      return false if digits.nil? || digits.empty?
+      return false unless digits.match?(/\A\d+\z/)
+
+      sum = digits.chars.each_with_index.sum do |char, index|
+        digit = char.to_i * (index.even? ? 1 : 2)
+        digit > 9 ? digit - 9 : digit
+      end
+
+      (sum % 10).zero?
+    end
+  end
+end

data/lib/israeli/railtie.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Israeli
+  # Rails integration for Israeli validators.
+  #
+  # Automatically loads ActiveModel validators when used in a Rails application.
+  # The validators are loaded via ActiveSupport's lazy load hooks to ensure
+  # proper initialization timing.
+  #
+  # @example Usage in a Rails model
+  #   class Person < ApplicationRecord
+  #     validates :id_number, israeli_id: true
+  #     validates :phone, israeli_phone: { type: :mobile }
+  #     validates :postal_code, israeli_postal_code: { allow_blank: true }
+  #     validates :bank_account, israeli_bank_account: { format: :iban }
+  #   end
+  class Railtie < Rails::Railtie
+    initializer "israeli.active_model" do
+      ActiveSupport.on_load(:active_model) do
+        require "israeli/active_model/israeli_id_validator"
+        require "israeli/active_model/israeli_postal_code_validator"
+        require "israeli/active_model/israeli_phone_validator"
+        require "israeli/active_model/israeli_bank_account_validator"
+      end
+    end
+  end
+end

data/lib/israeli/sanitizer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Israeli
+  # Input sanitization utilities for Israeli validators.
+  #
+  # Provides consistent normalization of user input across all validators,
+  # handling common formatting variations like spaces, hyphens, and
+  # international phone prefixes.
+  module Sanitizer
+    # Common separator characters to strip from input
+    STRIP_CHARS = /[\s\-.+]/
+
+    # Extracts only digit characters from input.
+    #
+    # Strips common formatting characters (spaces, hyphens, dots) and
+    # converts the input to a string. Returns nil for nil input.
+    #
+    # @param value [String, Integer, nil] The value to sanitize
+    # @return [String, nil] String containing only digits, or nil
+    #
+    # @example Basic usage
+    #   Sanitizer.digits_only("123-456-789") # => "123456789"
+    #   Sanitizer.digits_only("12 34 56")    # => "123456"
+    #   Sanitizer.digits_only(123456)        # => "123456"
+    #   Sanitizer.digits_only(nil)           # => nil
+    def self.digits_only(value)
+      return nil if value.nil?
+
+      value.to_s.gsub(STRIP_CHARS, "")
+    end
+
+    # Normalizes phone numbers by stripping international prefixes.
+    #
+    # Handles common Israeli international dialing formats:
+    # - +972 (standard international)
+    # - 972 (without plus)
+    # - 00972 (international access code)
+    #
+    # @param value [String, nil] The phone number to normalize
+    # @return [String, nil] Normalized domestic phone number, or nil
+    #
+    # @example International formats
+    #   Sanitizer.normalize_phone("+972501234567")   # => "0501234567"
+    #   Sanitizer.normalize_phone("972-50-123-4567") # => "0501234567"
+    #   Sanitizer.normalize_phone("00972501234567")  # => "0501234567"
+    #
+    # @example Domestic formats (unchanged)
+    #   Sanitizer.normalize_phone("050-123-4567")    # => "0501234567"
+    #   Sanitizer.normalize_phone("0501234567")      # => "0501234567"
+    def self.normalize_phone(value)
+      cleaned = digits_only(value)
+      return nil if cleaned.nil?
+
+      # Strip international prefixes and add leading zero
+      cleaned.sub(/\A(00972|972)/, "0")
+    end
+  end
+end

data/lib/israeli/validators/bank_account.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Israeli
+  module Validators
+    # Validates Israeli bank account numbers.
+    #
+    # Supports two formats:
+    # - Domestic: 13 digits (2-digit bank + 3-digit branch + 8-digit account)
+    # - IBAN: 23 characters (IL + 2 check digits + 19 BBAN digits)
+    #
+    # @example Domestic validation
+    #   Israeli::Validators::BankAccount.valid?("4985622815429")    # => true
+    #   Israeli::Validators::BankAccount.valid?("49-856-22815429")  # => true
+    #
+    # @example IBAN validation
+    #   Israeli::Validators::BankAccount.valid?("IL620108000000099999999") # => true
+    #
+    # @see https://www.ecbs.org/iban/israel-bank-account-number.html
+    class BankAccount
+      # Domestic format: 2 (bank) + 3 (branch) + 8 (account) = 13 digits
+      DOMESTIC_PATTERN = /\A\d{13}\z/
+
+      # IBAN format: IL + 2 check digits + 19 BBAN digits = 23 characters
+      IBAN_PATTERN = /\AIL\d{21}\z/
+
+      # Validates an Israeli bank account number.
+      #
+      # @param value [String, nil] The bank account to validate
+      # @param format [Symbol] Format to validate: :domestic, :iban, or :any
+      # @return [Boolean] true if valid, false otherwise
+      def self.valid?(value, format: :any)
+        return false if value.nil?
+
+        case format
+        when :domestic
+          valid_domestic?(Sanitizer.digits_only(value))
+        when :iban
+          valid_iban?(normalize_iban(value))
+        when :any
+          valid_domestic?(Sanitizer.digits_only(value)) ||
+            valid_iban?(normalize_iban(value))
+        else
+          false
+        end
+      end
+
+      # Validates a domestic Israeli bank account (13 digits).
+      #
+      # @param digits [String, nil] Digits-only bank account
+      # @return [Boolean]
+      def self.valid_domestic?(digits)
+        return false if digits.nil?
+
+        digits.match?(DOMESTIC_PATTERN)
+      end
+
+      # Validates an Israeli IBAN with mod 97 checksum.
+      #
+      # @param iban [String, nil] Normalized IBAN (uppercase, no spaces)
+      # @return [Boolean]
+      def self.valid_iban?(iban)
+        return false if iban.nil?
+        return false unless iban.match?(IBAN_PATTERN)
+
+        # IBAN mod 97 validation
+        # 1. Move first 4 chars to end
+        # 2. Convert letters to numbers (A=10, B=11, ..., Z=35)
+        # 3. Calculate mod 97, must equal 1
+        rearranged = iban[4..] + iban[0..3]
+        numeric = rearranged.gsub(/[A-Z]/) { |c| (c.ord - 55).to_s }
+        numeric.to_i % 97 == 1
+      end
+
+      # Formats a bank account to a specified style.
+      #
+      # @param value [String, nil] The bank account to format
+      # @param style [Symbol] :domestic (XX-XXX-XXXXXXXX) or :iban
+      # @return [String, nil] Formatted bank account, or nil if invalid
+      #
+      # @example
+      #   BankAccount.format("4985622815429")              # => "49-856-22815429"
+      #   BankAccount.format("4985622815429", style: :compact) # => "4985622815429"
+      def self.format(value, style: :domestic)
+        digits = Sanitizer.digits_only(value)
+
+        if valid_domestic?(digits)
+          case style
+          when :domestic
+            "#{digits[0..1]}-#{digits[2..4]}-#{digits[5..12]}"
+          else
+            digits
+          end
+        elsif valid_iban?(normalize_iban(value))
+          normalize_iban(value)
+        end
+      end
+
+      # @private
+      def self.normalize_iban(value)
+        value.to_s.gsub(/\s/, "").upcase
+      end
+      private_class_method :normalize_iban
+    end
+  end
+end

data/lib/israeli/validators/id.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Israeli
+  module Validators
+    # Validates Israeli ID numbers (Mispar Zehut / Teudat Zehut).
+    #
+    # Israeli ID numbers are 9-digit numbers where the last digit is a
+    # check digit calculated using the Luhn algorithm (mod 10).
+    #
+    # @example Basic validation
+    #   Israeli::Validators::Id.valid?("123456782") # => true
+    #   Israeli::Validators::Id.valid?("123456789") # => false
+    #
+    # @example With formatting
+    #   Israeli::Validators::Id.valid?("12345678-2") # => true
+    #   Israeli::Validators::Id.valid?("012345678")  # => true (leading zero)
+    #
+    # @see https://en.wikipedia.org/wiki/Israeli_identity_card
+    class Id
+      # Validates an Israeli ID number.
+      #
+      # Accepts formatted input (with hyphens/spaces) and handles leading zeros.
+      # IDs shorter than 9 digits are automatically left-padded with zeros.
+      #
+      # @param value [String, Integer, nil] The ID number to validate
+      # @return [Boolean] true if valid, false otherwise
+      def self.valid?(value)
+        digits = Sanitizer.digits_only(value)
+        return false if digits.nil? || digits.empty?
+
+        # Left-pad to 9 digits if shorter (handles IDs like "12345678")
+        padded = digits.rjust(9, "0")
+
+        # Must be exactly 9 digits after padding
+        return false unless padded.match?(/\A\d{9}\z/)
+
+        Luhn.valid?(padded)
+      end
+
+      # Formats an Israeli ID to standard 9-digit format.
+      #
+      # @param value [String, Integer, nil] The ID number to format
+      # @return [String, nil] 9-digit formatted ID, or nil if invalid
+      #
+      # @example
+      #   Israeli::Validators::Id.format("12345678-2") # => "123456782"
+      #   Israeli::Validators::Id.format(12345678)     # => "012345678"
+      def self.format(value)
+        digits = Sanitizer.digits_only(value)
+        return nil if digits.nil? || digits.empty?
+
+        padded = digits.rjust(9, "0")
+        return nil unless valid?(padded)
+
+        padded
+      end
+    end
+  end
+end

data/lib/israeli/validators/phone.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Israeli
+  module Validators
+    # Validates Israeli phone numbers.
+    #
+    # Supports three types of Israeli phone numbers:
+    # - Mobile: 10 digits starting with 05X (050, 052, 053, 054, 055, 058)
+    # - Landline: 9 digits starting with 0X (02, 03, 04, 08, 09)
+    # - VoIP: 10 digits starting with 07X (072-079)
+    #
+    # Automatically handles international format (+972) conversion.
+    #
+    # @example Mobile validation
+    #   Israeli::Validators::Phone.valid?("0501234567")              # => true
+    #   Israeli::Validators::Phone.valid?("+972501234567")           # => true
+    #   Israeli::Validators::Phone.valid?("050-123-4567")            # => true
+    #
+    # @example Landline validation
+    #   Israeli::Validators::Phone.valid?("021234567", type: :landline) # => true
+    #   Israeli::Validators::Phone.valid?("03-123-4567")                # => true
+    #
+    # @see https://en.wikipedia.org/wiki/Telephone_numbers_in_Israel
+    class Phone
+      # Mobile phone pattern: 05X followed by 7 more digits (10 total)
+      MOBILE_PATTERN = /\A05\d{8}\z/
+
+      # Landline pattern: 0X followed by 7 digits (9 total)
+      # Valid area codes: 02 (Jerusalem), 03 (Tel Aviv), 04 (Haifa), 08 (South), 09 (Sharon)
+      LANDLINE_PATTERN = /\A0[2-489]\d{7}\z/
+
+      # VoIP pattern: 07X (X=2-9) followed by 7 digits (10 total)
+      VOIP_PATTERN = /\A07[2-9]\d{7}\z/
+
+      # Validates an Israeli phone number.
+      #
+      # @param value [String, nil] The phone number to validate
+      # @param type [Symbol] Type to validate: :mobile, :landline, :voip, or :any
+      # @return [Boolean] true if valid, false otherwise
+      def self.valid?(value, type: :any)
+        normalized = Sanitizer.normalize_phone(value)
+        return false if normalized.nil? || normalized.empty?
+
+        case type
+        when :mobile then mobile?(normalized)
+        when :landline then landline?(normalized)
+        when :voip then voip?(normalized)
+        when :any then mobile?(normalized) || landline?(normalized) || voip?(normalized)
+        else false
+        end
+      end
+
+      # Checks if the number is a valid mobile number.
+      #
+      # @param value [String] Normalized phone number
+      # @return [Boolean]
+      def self.mobile?(value)
+        value.match?(MOBILE_PATTERN)
+      end
+
+      # Checks if the number is a valid landline number.
+      #
+      # @param value [String] Normalized phone number
+      # @return [Boolean]
+      def self.landline?(value)
+        value.match?(LANDLINE_PATTERN)
+      end
+
+      # Checks if the number is a valid VoIP number.
+      #
+      # @param value [String] Normalized phone number
+      # @return [Boolean]
+      def self.voip?(value)
+        value.match?(VOIP_PATTERN)
+      end
+
+      # Formats a phone number.
+      #
+      # @param value [String, nil] The phone number to format
+      # @param style [Symbol] :dashed, :international, or :compact
+      # @return [String, nil] Formatted phone number, or nil if invalid
+      #
+      # @example
+      #   Phone.format("0501234567")                      # => "050-123-4567"
+      #   Phone.format("0501234567", style: :international) # => "+972-50-123-4567"
+      #   Phone.format("021234567")                       # => "02-123-4567"
+      def self.format(value, style: :dashed)
+        normalized = Sanitizer.normalize_phone(value)
+        return nil unless valid?(normalized)
+
+        case style
+        when :dashed
+          format_dashed(normalized)
+        when :international
+          "+972-#{normalized[1..]}"
+        else
+          normalized
+        end
+      end
+
+      # @private
+      def self.format_dashed(normalized)
+        if mobile?(normalized) || voip?(normalized)
+          # 10-digit format: XXX-XXX-XXXX
+          "#{normalized[0..2]}-#{normalized[3..5]}-#{normalized[6..9]}"
+        else
+          # 9-digit landline format: XX-XXX-XXXX
+          "#{normalized[0..1]}-#{normalized[2..4]}-#{normalized[5..8]}"
+        end
+      end
+      private_class_method :format_dashed
+    end
+  end
+end

data/lib/israeli/validators/postal_code.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Israeli
+  module Validators
+    # Validates Israeli postal codes (Mikud).
+    #
+    # Israeli postal codes consist of exactly 7 digits. They are organized
+    # geographically from north to south, with the first 2 digits indicating
+    # the postal area. Jerusalem postal codes start with 9 despite its
+    # central location.
+    #
+    # @example Basic validation
+    #   Israeli::Validators::PostalCode.valid?("2610101") # => true
+    #   Israeli::Validators::PostalCode.valid?("26101 01") # => true (with space)
+    #
+    # @example Regional examples
+    #   Israeli::Validators::PostalCode.valid?("1029200") # => true (Metula, north)
+    #   Israeli::Validators::PostalCode.valid?("8800000") # => true (Eilat, south)
+    #   Israeli::Validators::PostalCode.valid?("9100000") # => true (Jerusalem)
+    #
+    # @see https://globepostalcodes.com/israel
+    class PostalCode
+      # Validates an Israeli postal code.
+      #
+      # @param value [String, nil] The postal code to validate
+      # @return [Boolean] true if valid 7-digit format, false otherwise
+      def self.valid?(value)
+        digits = Sanitizer.digits_only(value)
+        return false if digits.nil?
+
+        digits.match?(/\A\d{7}\z/)
+      end
+
+      # Formats a postal code to standard representation.
+      #
+      # @param value [String, nil] The postal code to format
+      # @param style [Symbol] :compact (7 digits) or :spaced (5+2 format)
+      # @return [String, nil] Formatted postal code, or nil if invalid
+      #
+      # @example
+      #   Israeli::Validators::PostalCode.format("26101 01")             # => "2610101"
+      #   Israeli::Validators::PostalCode.format("2610101", style: :spaced) # => "26101 01"
+      def self.format(value, style: :compact)
+        digits = Sanitizer.digits_only(value)
+        return nil unless valid?(digits)
+
+        case style
+        when :spaced then "#{digits[0..4]} #{digits[5..6]}"
+        else digits
+        end
+      end
+    end
+  end
+end

data/lib/israeli/version.rb

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

data/lib/israeli.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "israeli/version"
+require_relative "israeli/errors"
+require_relative "israeli/luhn"
+require_relative "israeli/sanitizer"
+
+# Main namespace for the Israeli validators gem.
+#
+# Provides validation utilities for Israeli identifiers including ID numbers
+# (Mispar Zehut), postal codes, phone numbers, and bank accounts.
+#
+# @example Validate an Israeli ID
+#   Israeli.valid_id?("123456782") # => true
+#
+# @example Validate a phone number
+#   Israeli.valid_phone?("0501234567", type: :mobile) # => true
+#
+# @see Israeli::Validators::Id
+# @see Israeli::Validators::Phone
+# @see Israeli::Validators::PostalCode
+# @see Israeli::Validators::BankAccount
+module Israeli
+  class << self
+    # Validates an Israeli ID number (Mispar Zehut).
+    #
+    # @param value [String, Integer] The ID number to validate
+    # @return [Boolean] true if valid, false otherwise
+    #
+    # @example
+    #   Israeli.valid_id?("123456782")     # => true
+    #   Israeli.valid_id?("12345678-2")    # => true (formatted)
+    #   Israeli.valid_id?("123456789")     # => false (bad checksum)
+    def valid_id?(value)
+      Validators::Id.valid?(value)
+    end
+
+    # Validates an Israeli postal code (Mikud).
+    #
+    # @param value [String] The postal code to validate
+    # @return [Boolean] true if valid, false otherwise
+    #
+    # @example
+    #   Israeli.valid_postal_code?("2610101")   # => true
+    #   Israeli.valid_postal_code?("26101 01")  # => true (with space)
+    def valid_postal_code?(value)
+      Validators::PostalCode.valid?(value)
+    end
+
+    # Validates an Israeli phone number.
+    #
+    # @param value [String] The phone number to validate
+    # @param type [Symbol] Type of phone: :mobile, :landline, :voip, or :any
+    # @return [Boolean] true if valid, false otherwise
+    #
+    # @example
+    #   Israeli.valid_phone?("0501234567")                    # => true
+    #   Israeli.valid_phone?("0501234567", type: :mobile)     # => true
+    #   Israeli.valid_phone?("+972501234567", type: :mobile)  # => true
+    def valid_phone?(value, type: :any)
+      Validators::Phone.valid?(value, type: type)
+    end
+
+    # Validates an Israeli bank account number.
+    #
+    # @param value [String] The bank account to validate
+    # @param format [Symbol] Format: :domestic, :iban, or :any
+    # @return [Boolean] true if valid, false otherwise
+    #
+    # @example
+    #   Israeli.valid_bank_account?("4985622815429")           # => true (domestic)
+    #   Israeli.valid_bank_account?("IL620108000000099999999") # => true (IBAN)
+    def valid_bank_account?(value, format: :any)
+      Validators::BankAccount.valid?(value, format: format)
+    end
+
+    # Formats an Israeli ID number to standard 9-digit format.
+    #
+    # @param value [String, Integer] The ID number to format
+    # @return [String, nil] Formatted ID or nil if invalid
+    def format_id(value)
+      Validators::Id.format(value)
+    end
+
+    # Formats an Israeli phone number.
+    #
+    # @param value [String] The phone number to format
+    # @param style [Symbol] Format style: :dashed, :international, or :compact
+    # @return [String, nil] Formatted phone or nil if invalid
+    def format_phone(value, style: :dashed)
+      Validators::Phone.format(value, style: style)
+    end
+  end
+end
+
+# Require validators after module definition to avoid circular dependency
+require_relative "israeli/validators/id"
+require_relative "israeli/validators/postal_code"
+require_relative "israeli/validators/phone"
+require_relative "israeli/validators/bank_account"
+
+# Load Rails integration if Rails is available
+require_relative "israeli/railtie" if defined?(Rails::Railtie)

data/sig/israeli.rbs

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

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: israeli
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- dpaluy
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Israeli provides validators for Israeli identifiers including Mispar
+  Zehut (ID numbers), phone numbers (mobile, landline, VoIP), postal codes, and bank
+  accounts (domestic and IBAN). Includes both standalone validators and ActiveModel/Rails
+  integration.
+email:
+- dpaluy@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/israeli.rb
+- lib/israeli/active_model/israeli_bank_account_validator.rb
+- lib/israeli/active_model/israeli_id_validator.rb
+- lib/israeli/active_model/israeli_phone_validator.rb
+- lib/israeli/active_model/israeli_postal_code_validator.rb
+- lib/israeli/errors.rb
+- lib/israeli/luhn.rb
+- lib/israeli/railtie.rb
+- lib/israeli/sanitizer.rb
+- lib/israeli/validators/bank_account.rb
+- lib/israeli/validators/id.rb
+- lib/israeli/validators/phone.rb
+- lib/israeli/validators/postal_code.rb
+- lib/israeli/version.rb
+- sig/israeli.rbs
+homepage: https://github.com/dpaluy/israeli
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/dpaluy/israeli
+  documentation_uri: https://rubydoc.info/gems/israeli
+  source_code_uri: https://github.com/dpaluy/israeli
+  changelog_uri: https://github.com/dpaluy/israeli/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/dpaluy/israeli/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.0
+specification_version: 4
+summary: Validation utilities for Israeli identifiers (ID, phone, postal code, bank
+  account).
+test_files: []