ibanchecker 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5959a043f0fe0044a65aa74d7203b57aeeafd050934efa28b7776dd938f3026b
+  data.tar.gz: 891de691976d13de1c3e5a3a9bb50f4a79ffdbae62f3f2d4f45b445ca03ea125
+SHA512:
+  metadata.gz: bce4770bafedfb4fc03437f602200ecc469d8bc7ed2c85615797ad8a743ef98d4ce14510035b55785ab72f79514bdacca6b951772e1fa68715d6ced637188384
+  data.tar.gz: 6b6186281e8edb97df2a3fb7b7ea6677df6a7850262265a518a0e06ac1f199d2d1798bf93184e146b66b313b11f20f5f4d91b13c5f649c8fc934d501ff3d7114

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## 0.1.0
+
+First release.
+
+- `validate`, `validate_bulk`, `extract`, `country_format` and `lookup_bic`
+- Typed models for every response, with the raw body kept on `#raw`
+- Typed errors for 400, 401, 404, 429, other statuses and transport failures;
+  a malformed IBAN is a result with `valid?` false, never an error
+- No runtime dependencies; ships a `net/http` transport and accepts anything
+  responding to `call(method, url, headers, body)` instead

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ibanchecker.cash
+
+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,197 @@
+# ibanchecker
+
+Official Ruby client for the [ibanchecker.cash](https://ibanchecker.cash) IBAN validation API.
+
+Validate IBANs across 92 countries, validate up to 100 IBANs per request, extract IBANs from free text, look up country format specifications, and resolve SWIFT/BIC codes. No IBAN data is stored or logged; all validation runs in memory at the edge.
+
+## Install
+
+```bash
+gem install ibanchecker
+```
+
+Or in a Gemfile:
+
+```ruby
+gem "ibanchecker"
+```
+
+Requires Ruby 2.7 or newer. There are no runtime dependencies: the client is built on `net/http` and `json` from the standard library.
+
+## Quick start
+
+```ruby
+require "ibanchecker"
+
+client = IbanChecker::Client.new   # no API key needed for light use (100 requests/hour per IP)
+
+result = client.validate("DE89 3704 0044 0532 0130 00")
+
+if result.valid?
+  result.country_name   # => "Germany"
+  result.bank_name      # => "Commerzbank AG Cologne"
+  result.bic            # => "COBADEFFXXX"
+else
+  result.error          # human-readable reason
+  result.error_code     # e.g. "INVALID_COUNTRY"
+end
+```
+
+## Authentication
+
+An API key is optional. Without one, requests are limited to 100 per hour per IP. With a key, requests count against your plan quota. Get a free key at [ibanchecker.cash/api-docs](https://ibanchecker.cash/api-docs).
+
+```ruby
+client = IbanChecker::Client.new("iban_your_api_key")
+client = IbanChecker::Client.new(ENV["IBANCHECKER_API_KEY"])
+```
+
+## Methods
+
+| Method | Description |
+| --- | --- |
+| `validate(iban)` | Validate a single IBAN. Returns a `ValidationResult`. |
+| `validate_bulk(ibans)` | Validate up to 100 IBANs. Returns a `BatchResult`. |
+| `extract(text)` | Find and validate IBANs in free text (up to 50,000 chars). Returns a `BatchResult`. |
+| `country_format(country)` | IBAN format spec for an ISO country code. Returns a `FormatSpec`. |
+| `lookup_bic(bic)` | Resolve an 8 or 11 character BIC. Returns a `BankRecord`. |
+
+`country_format` is the one name that differs from the other ibanchecker clients, where it is `getFormat`. `format` is `Kernel#format`, Ruby's `sprintf`, so a method by that name on this class would shadow it for every line inside the class.
+
+### Bulk validation
+
+```ruby
+batch = client.validate_bulk([
+  "DE89370400440532013000",
+  "GB29NWBK60161331926819",
+  "XX00"
+])
+
+batch.count         # => 3
+batch.valid_count   # => 2
+batch.invalid_count # => 1
+
+batch.each do |result|             # results come back in input order
+  puts "#{result.iban} #{result.valid? ? 'ok' : result.error_code}"
+end
+```
+
+`BatchResult` is `Enumerable`, so `map`, `select` and `find` work on it directly. `count` is the API's own count rather than `Enumerable#count`, so reach for `batch.results.count { |r| ... }` when you want the block form.
+
+### Extract from text
+
+```ruby
+batch = client.extract("Please wire to DE89 3704 0044 0532 0130 00 by Friday.")
+
+batch.map { |r| [r.iban, r.bank_name] }
+# => [["DE89370400440532013000", "Commerzbank AG Cologne"]]
+```
+
+### Country format and BIC lookup
+
+```ruby
+format = client.country_format("DE")
+format.length    # => 22
+format.example   # => "DE89370400440532013000"
+
+format.bban_fields.map { |f| "#{f.label} (#{f.length})" }
+# => ["BLZ (8)", "Account No. (10)"]
+
+bank = client.lookup_bic("DEUTDEFF")
+bank.bank_name   # => "Deutsche Bank AG Frankfurt"
+bank.city        # => "FRANKFURT AM MAIN"
+bank.sepa        # => true
+```
+
+### The national check digit
+
+For a number of countries the API also runs the national account check digit on top of the ISO 13616 check, and reports it on `national_check_valid`. It is advisory: an IBAN with `valid?` true is a valid IBAN whatever this says. A `false` usually means a transcription error in the account number. It is `nil` where the country has no such scheme.
+
+```ruby
+result = client.validate("DE84100100100532013000")
+
+if result.valid? && result.national_check_valid == false
+  puts "Valid IBAN, but the account number looks mistyped."
+end
+```
+
+`valid?` is the only predicate method on the models, because it is the only field that is always a boolean. `national_check_valid` and `sepa` can each be `nil`, and `nil` there means "not known for this IBAN" rather than "no", so they are plain readers and you compare them explicitly.
+
+## Error handling
+
+A malformed IBAN is **not** an error: `validate` returns a `ValidationResult` with `valid?` false. Errors are raised only for transport, authentication, quota and server-side problems.
+
+```ruby
+begin
+  bank = client.lookup_bic("ZZZZZZZZ")
+rescue IbanChecker::NotFoundError
+  puts "No bank for that BIC"
+rescue IbanChecker::RateLimitError => e
+  puts "Slow down: #{e.message}"
+rescue IbanChecker::AuthenticationError
+  puts "Check your API key"
+end
+```
+
+| Class | Raised when |
+| --- | --- |
+| `IbanChecker::BadRequestError` | HTTP 400, the request was malformed |
+| `IbanChecker::AuthenticationError` | HTTP 401, the API key is missing, invalid or inactive |
+| `IbanChecker::NotFoundError` | HTTP 404, no such country code or BIC |
+| `IbanChecker::RateLimitError` | HTTP 429, hourly limit or monthly quota exceeded |
+| `IbanChecker::APIError` | any other error status, or a body that could not be read |
+| `IbanChecker::TransportError` | the request never reached the API: DNS, TLS, connection, timeout |
+
+All of them inherit from `IbanChecker::Error`, so one `rescue IbanChecker::Error` catches everything this gem raises. Each carries `#status`, `#error_code` and `#response`.
+
+## Timeouts
+
+```ruby
+client = IbanChecker::Client.new(timeout: 3.0)   # seconds, applied to connect and read
+```
+
+## Using your own HTTP stack
+
+The client ships a `net/http` transport and needs nothing installed. If your application already has an HTTP layer, pass anything that responds to `call(method, url, headers, body)` and returns an object with `#status` and `#body`. This is also how the test suite runs without a network.
+
+```ruby
+class MyTransport
+  def call(method, url, headers, body)
+    # ... your HTTP stack here
+    IbanChecker::Transport::Response.new(status, response_body)
+  end
+end
+
+client = IbanChecker::Client.new("iban_your_api_key", transport: MyTransport.new)
+```
+
+The bundled transport follows a redirect only when it stays on the same host, so an `http` base URL upgrading to `https` works, and a redirect elsewhere raises `TransportError` instead of forwarding your API key to another host.
+
+## Raw responses
+
+Every model keeps the untouched response body on `#raw`, so a field added to the API later is reachable without waiting for a client release.
+
+```ruby
+result = client.validate("DE89370400440532013000")
+result.raw["transfer_type"]   # => "SEPA+SWIFT"
+```
+
+## Tests
+
+```bash
+bundle install
+bundle exec rake test
+```
+
+## Links
+
+- Website: https://ibanchecker.cash
+- API documentation: https://ibanchecker.cash/api-docs
+- OpenAPI spec: https://ibanchecker.cash/openapi.json
+- Free online tools: https://ibanchecker.cash/tools
+
+Clients for other languages: [Python](https://pypi.org/project/ibanchecker/), [PHP](https://packagist.org/packages/ibanchecker/client), [JavaScript](https://www.npmjs.com/package/@ibanchecker/client), and an [MCP server](https://www.npmjs.com/package/@ibanchecker/mcp).
+
+## License
+
+MIT

data/lib/ibanchecker/client.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "json"
+
+module IbanChecker
+  # Client for the ibanchecker.cash IBAN validation API.
+  #
+  # Validate IBANs across 92 countries, validate up to 100 IBANs per request,
+  # extract IBANs from free text, look up country format specifications and
+  # resolve SWIFT/BIC codes.
+  #
+  # An API key is optional. Without one, requests are limited to 100 per hour
+  # per IP. Get a free key at https://ibanchecker.cash/api-docs.
+  #
+  #   client = IbanChecker::Client.new          # or .new("iban_your_key")
+  #   result = client.validate("DE89 3704 0044 0532 0130 00")
+  #   puts "#{result.bank_name} #{result.bic}" if result.valid?
+  class Client
+    DEFAULT_BASE_URL = "https://ibanchecker.cash/api/v1"
+
+    ERRORS_BY_STATUS = {
+      400 => BadRequestError,
+      401 => AuthenticationError,
+      404 => NotFoundError,
+      429 => RateLimitError
+    }.freeze
+
+    # Everything outside the unreserved set of RFC 3986 is percent-encoded
+    # before it goes into a path segment.
+    RESERVED = /[^A-Za-z0-9\-._~]/.freeze
+
+    attr_reader :base_url
+
+    def initialize(api_key = nil, base_url: DEFAULT_BASE_URL, timeout: 10.0, transport: nil)
+      key = api_key.to_s
+      @api_key = key.empty? ? nil : key
+      @base_url = base_url.to_s.sub(%r{/+\z}, "")
+      @transport = transport || Transport::NetHttp.new(timeout: timeout)
+    end
+
+    # Validate a single IBAN.
+    #
+    # A malformed IBAN is not an error: the result comes back with +valid?+
+    # false and an +error+ plus +error_code+ explaining why.
+    def validate(iban)
+      ValidationResult.from_api(request("POST", "/validate", "iban" => iban.to_s))
+    end
+
+    # Validate up to 100 IBANs in one request. Results come back in the same
+    # order as the input.
+    def validate_bulk(ibans)
+      BatchResult.from_api(
+        request("POST", "/validate/bulk", "ibans" => Array(ibans).map(&:to_s))
+      )
+    end
+
+    # Scan free text (emails, invoices) for IBAN-shaped strings and validate
+    # each candidate. Up to 50,000 characters per request.
+    def extract(text)
+      BatchResult.from_api(request("POST", "/extract", "text" => text.to_s))
+    end
+
+    # The IBAN format specification for an ISO 3166-1 alpha-2 country code,
+    # for example "DE".
+    #
+    # Named country_format rather than format because Kernel#format is
+    # sprintf, and shadowing it inside this class would be a trap.
+    def country_format(country)
+      FormatSpec.from_api(request("GET", "/formats/#{escape(country.to_s.downcase)}"))
+    end
+
+    # Resolve an 8 or 11 character ISO 9362 BIC to a bank record.
+    def lookup_bic(bic)
+      BankRecord.from_api(request("GET", "/swift/#{escape(bic.to_s.upcase)}"))
+    end
+
+    private
+
+    def request(method, path, payload = nil)
+      headers = {
+        "Accept" => "application/json",
+        "User-Agent" => "ibanchecker-ruby/#{VERSION}"
+      }
+      headers["Authorization"] = "Bearer #{@api_key}" if @api_key
+
+      body = nil
+      if payload
+        body = JSON.generate(payload)
+        headers["Content-Type"] = "application/json"
+      end
+
+      response = @transport.call(method, @base_url + path, headers, body)
+      status = response.status.to_i
+      raw = response.body.to_s
+      data = parse(raw)
+
+      raise error_for(status, data) if status >= 400
+      return data if data
+
+      raise APIError.new(
+        raw.strip.empty? ? "The API returned an empty body" : "The API returned a body that is not a JSON object",
+        status: status
+      )
+    end
+
+    # Returns the decoded object, or nil when the body was empty, unparseable
+    # or not a JSON object. The caller decides what that means: on an error
+    # status it just means there is no message to quote.
+    def parse(raw)
+      return nil if raw.strip.empty?
+
+      decoded = JSON.parse(raw)
+      decoded.is_a?(Hash) ? decoded : nil
+    rescue JSON::ParserError
+      nil
+    end
+
+    def error_for(status, data)
+      message = data && data["error"].is_a?(String) ? data["error"] : "HTTP #{status}"
+      code = data && data["error_code"].is_a?(String) ? data["error_code"] : nil
+
+      ERRORS_BY_STATUS.fetch(status, APIError).new(
+        message, status: status, error_code: code, response: data
+      )
+    end
+
+    def escape(value)
+      value.gsub(RESERVED) { |char| char.each_byte.map { |byte| format("%%%02X", byte) }.join }
+    end
+  end
+end

data/lib/ibanchecker/errors.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module IbanChecker
+  # Base class for every error this client raises.
+  #
+  # A malformed IBAN is not an error: Client#validate returns a
+  # ValidationResult with +valid?+ false. These are raised for transport,
+  # authentication, quota and server-side problems only.
+  class Error < StandardError
+    # HTTP status that produced this error, when there was one.
+    attr_reader :status
+
+    # Machine-readable code from the API body, for example "BIC_NOT_FOUND".
+    attr_reader :error_code
+
+    # The decoded response body, when the API sent one.
+    attr_reader :response
+
+    def initialize(message, status: nil, error_code: nil, response: nil)
+      super(message)
+      @status = status
+      @error_code = error_code
+      @response = response
+    end
+  end
+
+  # The request was malformed (HTTP 400).
+  class BadRequestError < Error; end
+
+  # The API key is missing, invalid or inactive (HTTP 401).
+  class AuthenticationError < Error; end
+
+  # The requested country code or BIC was not found (HTTP 404).
+  class NotFoundError < Error; end
+
+  # The hourly rate limit or the monthly quota was exceeded (HTTP 429).
+  class RateLimitError < Error; end
+
+  # An unexpected server-side error, or a body that could not be read.
+  class APIError < Error; end
+
+  # The request never reached the API: DNS, TLS, connection or timeout.
+  class TransportError < Error; end
+end

data/lib/ibanchecker/models.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module IbanChecker
+  # One segment of a country's BBAN, in the order it appears in the IBAN.
+  class BbanField
+    attr_reader :label, :length, :type, :description
+
+    # The untouched field object from the API response.
+    attr_reader :raw
+
+    def initialize(label: nil, length: nil, type: nil, description: nil, raw: {})
+      @label = label
+      @length = length
+      @type = type
+      @description = description
+      @raw = raw
+    end
+
+    def self.from_api(data)
+      new(
+        label: data["label"],
+        length: data["length"],
+        type: data["type"],
+        description: data["description"],
+        raw: data
+      )
+    end
+  end
+
+  # The result of validating one IBAN.
+  #
+  # +valid?+ is the primary flag. When it is false only +iban+, +formatted+,
+  # +country+, +country_name+, +error+ and +error_code+ are populated.
+  #
+  # +valid?+ is the only predicate method here because it is the only field
+  # that is always a boolean. +sepa+ and +national_check_valid+ can each be
+  # nil, so they are plain readers and nil means "not known for this IBAN".
+  class ValidationResult
+    ATTRIBUTES = %i[
+      iban formatted check_digits bban country country_name
+      bank_name bank_type bic bank_city bank_code branch_code account_number
+      national_check_valid currency currency_name transfer_type sepa flag
+      error error_code
+    ].freeze
+
+    attr_reader(*ATTRIBUTES)
+
+    # The untouched response body.
+    attr_reader :raw
+
+    def initialize(valid:, iban:, raw: {}, **rest)
+      @valid = valid
+      @iban = iban
+      @raw = raw
+      ATTRIBUTES.each do |name|
+        next if name == :iban
+
+        instance_variable_set("@#{name}", rest[name])
+      end
+    end
+
+    # True when the IBAN passes the ISO 13616 check digit, the country's
+    # length and the country's BBAN structure.
+    def valid?
+      @valid
+    end
+
+    def self.from_api(data)
+      new(
+        valid: data["valid"] == true,
+        iban: data["iban"].to_s,
+        formatted: data["formatted"],
+        check_digits: data["check_digits"],
+        bban: data["bban"],
+        country: data["country"],
+        country_name: data["country_name"],
+        bank_name: data["bank_name"],
+        bank_type: data["bank_type"],
+        bic: data["bic"],
+        bank_city: data["bank_city"],
+        bank_code: data["bank_code"],
+        branch_code: data["branch_code"],
+        account_number: data["account_number"],
+        national_check_valid: data["national_check_valid"],
+        currency: data["currency"],
+        currency_name: data["currency_name"],
+        transfer_type: data["transfer_type"],
+        sepa: data["sepa"],
+        flag: data["flag"],
+        error: data["error"],
+        error_code: data["error_code"],
+        raw: data
+      )
+    end
+
+    # Kept short on purpose: the default would print the whole raw body, which
+    # makes an irb session unreadable.
+    def inspect
+      detail = valid? ? "valid #{bank_name || 'bank not in directory'}" : "invalid #{error_code}"
+      "#<#{self.class} #{iban} #{detail}>"
+    end
+  end
+
+  # The result of a bulk validation or a text extraction.
+  #
+  # The object is enumerable: iterating it walks the per-IBAN results in input
+  # order. +count+ is the API's own count rather than Enumerable#count, so use
+  # +results.count { ... }+ if you want the block form.
+  class BatchResult
+    include Enumerable
+
+    attr_reader :count, :valid_count, :invalid_count, :results
+
+    # The untouched response body.
+    attr_reader :raw
+
+    def initialize(count: 0, valid_count: 0, invalid_count: 0, results: [], raw: {})
+      @count = count
+      @valid_count = valid_count
+      @invalid_count = invalid_count
+      @results = results
+      @raw = raw
+    end
+
+    def each(&block)
+      @results.each(&block)
+    end
+
+    def size
+      @results.size
+    end
+
+    def self.from_api(data)
+      rows = data["results"]
+      results = rows.is_a?(Array) ? rows.select { |row| row.is_a?(Hash) }.map { |row| ValidationResult.from_api(row) } : []
+
+      new(
+        count: data["count"] || 0,
+        valid_count: data["valid_count"] || 0,
+        invalid_count: data["invalid_count"] || 0,
+        results: results,
+        raw: data
+      )
+    end
+  end
+
+  # The IBAN format specification for one country.
+  class FormatSpec
+    attr_reader :country_code, :country_name, :length, :currency, :currency_name,
+                :sepa, :swift, :format_string, :example, :bban_fields
+
+    # The untouched response body.
+    attr_reader :raw
+
+    def initialize(bban_fields: [], raw: {}, **rest)
+      @bban_fields = bban_fields
+      @raw = raw
+      %i[country_code country_name length currency currency_name sepa swift
+         format_string example].each do |name|
+        instance_variable_set("@#{name}", rest[name])
+      end
+    end
+
+    def self.from_api(data)
+      fields = data["bban_fields"]
+      bban_fields = fields.is_a?(Array) ? fields.select { |f| f.is_a?(Hash) }.map { |f| BbanField.from_api(f) } : []
+
+      new(
+        country_code: data["country_code"],
+        country_name: data["country_name"],
+        length: data["length"],
+        currency: data["currency"],
+        currency_name: data["currency_name"],
+        sepa: data["sepa"],
+        swift: data["swift"],
+        format_string: data["format_string"],
+        example: data["example"],
+        bban_fields: bban_fields,
+        raw: data
+      )
+    end
+  end
+
+  # The institution behind a SWIFT/BIC code.
+  class BankRecord
+    ATTRIBUTES = %i[
+      bic bic8 bank_code country_code location_code branch_code
+      bank_name city country_name sepa type status
+    ].freeze
+
+    attr_reader(*ATTRIBUTES)
+
+    # The untouched response body.
+    attr_reader :raw
+
+    def initialize(raw: {}, **rest)
+      @raw = raw
+      ATTRIBUTES.each { |name| instance_variable_set("@#{name}", rest[name]) }
+    end
+
+    def self.from_api(data)
+      new(
+        bic: data["bic"],
+        bic8: data["bic8"],
+        bank_code: data["bank_code"],
+        country_code: data["country_code"],
+        location_code: data["location_code"],
+        branch_code: data["branch_code"],
+        bank_name: data["bank_name"],
+        city: data["city"],
+        country_name: data["country_name"],
+        sepa: data["sepa"],
+        type: data["type"],
+        status: data["status"],
+        raw: data
+      )
+    end
+  end
+end

data/lib/ibanchecker/transport.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module IbanChecker
+  # The HTTP seam.
+  #
+  # The client ships NetHttp, built entirely on the standard library, so the
+  # gem has no runtime dependencies. Anything that responds to
+  # #call(method, url, headers, body) and returns something with #status and
+  # #body can be passed in instead. That is how the test suite runs without a
+  # network, and how a host application can route calls through its own HTTP
+  # stack.
+  module Transport
+    # What a transport returns.
+    Response = Struct.new(:status, :body)
+
+    # Default transport, built on net/http.
+    class NetHttp
+      METHODS = {
+        "GET" => Net::HTTP::Get,
+        "POST" => Net::HTTP::Post
+      }.freeze
+
+      def initialize(timeout: 10.0, max_redirects: 3)
+        @timeout = timeout
+        @max_redirects = max_redirects
+      end
+
+      def call(method, url, headers, body)
+        request_class = METHODS.fetch(method) do
+          raise ArgumentError, "Unsupported HTTP method: #{method}"
+        end
+
+        uri = URI.parse(url)
+        redirects = 0
+
+        loop do
+          response = perform(request_class, uri, headers, body)
+          location = response.is_a?(Net::HTTPRedirection) ? response["location"] : nil
+
+          return Response.new(response.code.to_i, response.body.to_s) if location.nil? || redirects >= @max_redirects
+
+          target = URI.join(uri.to_s, location)
+          # Following a redirect to another host would send the Authorization
+          # header there, which is how an API key leaks. An upgrade from http
+          # to https on the same host is the case worth following.
+          unless target.host == uri.host
+            raise TransportError,
+                  "Refusing to follow a redirect from #{uri.host} to #{target.host}: " \
+                  "that would send the API key to another host"
+          end
+
+          uri = target
+          redirects += 1
+        end
+      end
+
+      private
+
+      def perform(request_class, uri, headers, body)
+        request = request_class.new(uri)
+        headers.each { |name, value| request[name] = value }
+        request.body = body if body
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = @timeout
+        http.read_timeout = @timeout
+        http.write_timeout = @timeout if http.respond_to?(:write_timeout=)
+
+        begin
+          http.start { |connection| connection.request(request) }
+        rescue StandardError => e
+          raise TransportError, "Request to #{uri} failed: #{e.class}: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/ibanchecker/version.rb

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

data/lib/ibanchecker.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "ibanchecker/version"
+require_relative "ibanchecker/errors"
+require_relative "ibanchecker/models"
+require_relative "ibanchecker/transport"
+require_relative "ibanchecker/client"
+
+# Official Ruby client for the ibanchecker.cash IBAN validation API.
+#
+#   require "ibanchecker"
+#
+#   client = IbanChecker::Client.new
+#   result = client.validate("DE89370400440532013000")
+#   result.valid?      # => true
+#   result.bank_name   # => "Commerzbank AG Cologne"
+module IbanChecker
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: ibanchecker
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- ibanchecker.cash
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Validate IBANs across 92 countries, validate up to 100 IBANs per request,
+  extract IBANs from free text, look up country format specifications and resolve
+  SWIFT/BIC codes. No runtime dependencies.
+email:
+- api@ibanchecker.cash
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/ibanchecker.rb
+- lib/ibanchecker/client.rb
+- lib/ibanchecker/errors.rb
+- lib/ibanchecker/models.rb
+- lib/ibanchecker/transport.rb
+- lib/ibanchecker/version.rb
+homepage: https://ibanchecker.cash
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://ibanchecker.cash
+  documentation_uri: https://ibanchecker.cash/api-docs
+  source_code_uri: https://github.com/koraykoylu/ibanchecker-ruby
+  changelog_uri: https://github.com/koraykoylu/ibanchecker-ruby/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/koraykoylu/ibanchecker-ruby/issues
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Official Ruby client for the ibanchecker.cash IBAN validation API
+test_files: []