bban parse function

VErsion fix
Length checks added, validations added
2024-05-11 11:52:34 -04:00 · 2024-05-10 18:03:26 -04:00 · 2024-05-10 17:56:29 -04:00 · 2024-03-10 20:20:15 -04:00 · 2024-03-10 20:02:20 -04:00 · 2024-03-07 18:41:45 -05:00
50 changed files with 1036 additions and 502 deletions
--- a/README.md
+++ b/README.md
@@ -1,16 +1,77 @@
 # IbanEx

-Library for working with IBAN numbers (parsing, validating and checking and formatting)
+Elixir library for working with IBAN numbers (parsing, validating, checking and formatting)
+
+## What is an IBAN?
+
+IBAN (which stands for International Bank Account Number) is an internationally agreed code made up of up to 34 letters and numbers which helps banks make sure that international transfers are processed correctly.
+
+In just a few letters and numbers, the IBAN captures all of the country, bank, and account details you need to send or receive money internationally. This system is used throughout Europe, and also recognised in some areas of the Middle East, North Africa and the Caribbean. Find IBAN examples for every country where it's used.
+
+## HowTo Use
+
+### Successfull case to parse IBAN
+
+  ```elixir
+      iex>  "FI2112345600000785" |> IbanEx.Parser.parse()
+      {:ok, %IbanEx.Iban{
+        country_code: "FI",
+        check_digits: "21",
+        bank_code: "123456",
+        branch_code: nil,
+        national_check: "5",
+        account_number: "0000078"
+      }}
+  ```
+
+### Errors cases of IBAN parsing
+
+#### To check IBAN's country is supported
+
+  ```elixir
+      iex> {:error, unsupported_country_code} = IbanEx.Parser.parse("AZ21NABZ00000000137010001944")
+      {:error, :unsupported_country_code}
+      iex> IbanEx.Error.message(unsupported_country_code)
+      "Unsupported country code"
+  ```
+
+#### Validate and check IBAN length
+
+  ```elixir
+      iex> {:error, invalid_length} = IbanEx.Parser.parse("AT6119043002345732012")
+      {:error, :invalid_length}
+      iex> IbanEx.Error.message(invalid_length)
+      "IBAN violates the required length"
+  ```
+
+  ```elixir
+      iex> {:error, length_to_long} = IbanEx.Validator.check_iban_length("AT6119043002345732012")
+      {:error, :length_to_long}
+      iex> IbanEx.Error.message(length_to_long)
+      "IBAN longer then required length"
+      iex> {:error, length_to_short} = IbanEx.Validator.check_iban_length("AT61190430023457320")
+      {:error, :length_to_short}
+      iex> IbanEx.Error.message(length_to_short)
+      "IBAN shorter then required length"
+  ```
+
+#### Validate IBAN checksum
+
+  ```elixir
+      iex> {:error, invalid_checksum} = IbanEx.Parser.parse("AT621904300234573201")
+      {:error, :invalid_checksum}
+      iex> IbanEx.Error.message(invalid_checksum)
+      "IBAN's checksum is invalid"
+  ```

 ## Installation

-If [available in Hex](https://hex.pm/docs/publish), the package can be installed
-by adding `iban_ex` to your list of dependencies in `mix.exs`:
+The package can be installed by adding `iban_ex` to your list of dependencies in `mix.exs`:

 ```elixir
 def deps do
  [
-    {:iban_ex, "~> 0.1.0"}
+    {:iban_ex, "~> 0.1.5"}
  ]
 end
 ```
@@ -18,4 +79,3 @@ end
 Documentation can be generated with [ExDoc](https://github.com/elixir-lang/ex_doc)
 and published on [HexDocs](https://hexdocs.pm). Once published, the docs can
 be found at <https://hexdocs.pm/iban_ex>.
-
--- a/lib/iban_ex/commons/commons.ex
+++ b/lib/iban_ex/commons/commons.ex
@@ -1,4 +1,6 @@
 defmodule IbanEx.Commons do
+  @moduledoc false
+
  @spec normalize(binary()) :: binary()
  def normalize(string) do
    string
@@ -12,5 +14,9 @@ def normalize_and_slice(string, range) do
    string
    |> normalize()
    |> String.slice(range)
+    # |> case do
+    #   "" -> nil
+    #   result -> result
+    # end
  end
 end
--- a/lib/iban_ex/country.ex
+++ b/lib/iban_ex/country.ex
@@ -1,4 +1,6 @@
 defmodule IbanEx.Country do
+  @moduledoc false
+
  import IbanEx.Commons, only: [normalize: 1]

  @type country_code() :: <<_::16>> | atom()
@@ -13,23 +15,38 @@ defmodule IbanEx.Country do
    "CZ" => IbanEx.Country.CZ,
    "DE" => IbanEx.Country.DE,
    "DK" => IbanEx.Country.DK,
-    "ES" => IbanEx.Country.ES,
    "EE" => IbanEx.Country.EE,
-    "FR" => IbanEx.Country.FR,
+    "ES" => IbanEx.Country.ES,
    "FI" => IbanEx.Country.FI,
+    "FR" => IbanEx.Country.FR,
    "GB" => IbanEx.Country.GB,
+    "GI" => IbanEx.Country.GI,
+    "GR" => IbanEx.Country.GR,
    "HR" => IbanEx.Country.HR,
+    "HU" => IbanEx.Country.HU,
+    "IE" => IbanEx.Country.IE,
+    "IT" => IbanEx.Country.IT,
+    "LI" => IbanEx.Country.LI,
    "LT" => IbanEx.Country.LT,
    "LU" => IbanEx.Country.LU,
    "LV" => IbanEx.Country.LV,
+    "MC" => IbanEx.Country.MC,
    "MT" => IbanEx.Country.MT,
    "NL" => IbanEx.Country.NL,
+    "NO" => IbanEx.Country.NO,
    "PL" => IbanEx.Country.PL,
    "PT" => IbanEx.Country.PT,
-    "UA" => IbanEx.Country.UA
+    "RO" => IbanEx.Country.RO,
+    "SE" => IbanEx.Country.SE,
+    "SM" => IbanEx.Country.SM,
+    "SI" => IbanEx.Country.SI,
+    "SK" => IbanEx.Country.SK,
+    "UA" => IbanEx.Country.UA,
+    "VA" => IbanEx.Country.VA
  }

  @supported_country_codes Map.keys(@supported_countries)
+  @supported_country_modules Map.values(@supported_countries)

  @spec supported_countries() :: map()
  defp supported_countries(), do: @supported_countries
@@ -37,6 +54,9 @@ defp supported_countries(), do: @supported_countries
  @spec supported_country_codes() :: [country_code()] | []
  def supported_country_codes(), do: @supported_country_codes

+  @spec supported_country_modules() :: [module()] | []
+  def supported_country_modules(), do: @supported_country_modules
+
  @spec country_module(country_code) :: Module.t() | error_tuple()
  def country_module(country_code) when is_binary(country_code) or is_atom(country_code) do
    normalized_country_code = normalize(country_code)
--- a/lib/iban_ex/country/at.ex
+++ b/lib/iban_ex/country/at.ex
@@ -1,34 +1,25 @@
 defmodule IbanEx.Country.AT do
  @moduledoc """
  Austria IBAN parsing rules
+
+  ## Examples
+
+  ```elixir
+      iex>  %IbanEx.Iban{
+      ...>    country_code: "AT",
+      ...>    check_digits: "61",
+      ...>    bank_code: "19043",
+      ...>    branch_code: nil,
+      ...>    national_check: nil,
+      ...>    account_number: "00234573201"
+      ...>  }
+      ...>  |> IbanEx.Country.AT.to_string()
+      "AT 61 19043 00234573201"
+  ```
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 20
-
  @rule ~r/^(?<bank_code>[0-9]{5})(?<account_number>[0-9]{11})$/i

-  @spec size() :: 20
-  def size(), do: @size
-
-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
-        %Iban{
-          country_code: country_code,
-          check_digits: check_digits,
-          bank_code: bank_code,
-          account_number: account_number
-        } = _iban,
-        joiner \\ " "
-      ) do
-    [country_code, check_digits, bank_code, account_number]
-    |> Enum.join(joiner)
-  end
+  use IbanEx.Country.Template
 end
--- a/lib/iban_ex/country/be.ex
+++ b/lib/iban_ex/country/be.ex
@@ -1,25 +1,32 @@
 defmodule IbanEx.Country.BE do
  @moduledoc """
  Belgium IBAN parsing rules
+
+  ## Examples
+
+  ```elixir
+      iex>  %IbanEx.Iban{
+      ...>    country_code: "BE",
+      ...>    check_digits: "68",
+      ...>    bank_code: "539",
+      ...>    branch_code: nil,
+      ...>    national_check: "34",
+      ...>    account_number: "0075470"
+      ...>  }
+      ...>  |> IbanEx.Country.BE.to_string()
+      "BE 68 539 0075470 34"
+  ```
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 16
-
  @rule ~r/^(?<bank_code>[0-9]{3})(?<account_number>[0-9]{7})(?<national_check>[0-9]{2})$/i

-  @spec size() :: 16
-  def size(), do: @size
+  use IbanEx.Country.Template

-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
        %Iban{
          country_code: country_code,
          check_digits: check_digits,
--- a/lib/iban_ex/country/bg.ex
+++ b/lib/iban_ex/country/bg.ex
@@ -1,25 +1,34 @@
 defmodule IbanEx.Country.BG do
  @moduledoc """
  Bulgaria IBAN parsing rules
+
+  ## Examples
+
+  ```elixir
+      iex>  %IbanEx.Iban{
+      ...>    country_code: "BG",
+      ...>    check_digits: "80",
+      ...>    bank_code: "BNBG",
+      ...>    branch_code: "9661",
+      ...>    national_check: nil,
+      ...>    account_number: "1020345678"
+      ...>  }
+      ...>  |> IbanEx.Country.BG.to_string()
+      "BG 80 BNBG 9661 1020345678"
+  ```
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 22
-
  @rule ~r/^(?<bank_code>[A-Z]{4})(?<branch_code>[0-9]{4})(?<account_number>[0-9]{2}[0-9A-Z]{8})$/i

+  use IbanEx.Country.Template
+
  @spec size() :: 22
-  def size(), do: @size

-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
        %Iban{
          country_code: country_code,
          check_digits: check_digits,
--- a/lib/iban_ex/country/ch.ex
+++ b/lib/iban_ex/country/ch.ex
@@ -1,34 +1,17 @@
 defmodule IbanEx.Country.CH do
  @moduledoc """
  Switzerland IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "CH", check_digits: "93", bank_code: "00762", branch_code: nil, national_check: nil, account_number: "011623852957"}
+    iex> |> IbanEx.Country.CH.to_string()
+    "CH 93 00762 011623852957"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 21
-
  @rule ~r/^(?<bank_code>[0-9]{5})(?<account_number>[0-9A-Z]{12})$/i

-  @spec size() :: 21
-  def size(), do: @size
-
-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
-        %Iban{
-          country_code: country_code,
-          check_digits: check_digits,
-          bank_code: bank_code,
-          account_number: account_number
-        } = _iban,
-        joiner \\ " "
-      ) do
-    [country_code, check_digits, bank_code, account_number]
-    |> Enum.join(joiner)
-  end
+  use IbanEx.Country.Template
 end
--- a/lib/iban_ex/country/cy.ex
+++ b/lib/iban_ex/country/cy.ex
@@ -1,25 +1,24 @@
 defmodule IbanEx.Country.CY do
  @moduledoc """
  Cyprus IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "CY", check_digits: "17", bank_code: "002", branch_code: "00128", national_check: nil, account_number: "0000001200527600"}
+    iex> |> IbanEx.Country.CY.to_string()
+    "CY 17 002 00128 0000001200527600"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 28
-
  @rule ~r/^(?<bank_code>[0-9]{3})(?<branch_code>[0-9]{5})(?<account_number>[0-9A-Z]{16})$/i

-  @spec size() :: 28
-  def size(), do: @size
+  use IbanEx.Country.Template

-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
        %Iban{
          country_code: country_code,
          check_digits: check_digits,
--- a/lib/iban_ex/country/cz.ex
+++ b/lib/iban_ex/country/cz.ex
@@ -1,36 +1,17 @@
 defmodule IbanEx.Country.CZ do
  @moduledoc """
  Czech Republic IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "CZ", check_digits: "65", bank_code: "0800", branch_code: nil, national_check: nil, account_number: "0000192000145399"}
+    iex> |> IbanEx.Country.CZ.to_string()
+    "CZ 65 0800 0000192000145399"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 24
-
  @rule ~r/^(?<bank_code>[0-9]{4})(?<account_number>[0-9]{16})$/i

-  @spec size() :: 24
-  def size(), do: @size
-
-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
-        %Iban{
-          country_code: country_code,
-          check_digits: check_digits,
-          bank_code: bank_code,
-          branch_code: _branch_code,
-          national_check: _national_check,
-          account_number: account_number
-        } = _iban,
-        joiner \\ " "
-      ) do
-    [country_code, check_digits, bank_code, account_number]
-    |> Enum.join(joiner)
-  end
+  use IbanEx.Country.Template
 end
--- a/lib/iban_ex/country/de.ex
+++ b/lib/iban_ex/country/de.ex
@@ -1,36 +1,17 @@
 defmodule IbanEx.Country.DE do
  @moduledoc """
  Germany IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "DE", check_digits: "89", bank_code: "37040044", branch_code: nil, national_check: nil, account_number: "0532013000"}
+    iex> |> IbanEx.Country.DE.to_string()
+    "DE 89 37040044 0532013000"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 22
-
  @rule ~r/^(?<bank_code>[0-9]{8})(?<account_number>[0-9]{10})$/i

-  @spec size() :: 22
-  def size(), do: @size
-
-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
-        %Iban{
-          country_code: country_code,
-          check_digits: check_digits,
-          bank_code: bank_code,
-          branch_code: _branch_code,
-          national_check: _national_check,
-          account_number: account_number
-        } = _iban,
-        joiner \\ " "
-      ) do
-    [country_code, check_digits, bank_code, account_number]
-    |> Enum.join(joiner)
-  end
+  use IbanEx.Country.Template
 end
--- a/lib/iban_ex/country/dk.ex
+++ b/lib/iban_ex/country/dk.ex
@@ -1,36 +1,16 @@
 defmodule IbanEx.Country.DK do
  @moduledoc """
  Denmark IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "DK", check_digits: "50", bank_code: "0040", branch_code: nil, national_check: nil, account_number: "0440116243"}
+    iex> |> IbanEx.Country.DK.to_string()
+    "DK 50 0040 0440116243"
+
  """
-
-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 18
-
  @rule ~r/^(?<bank_code>[0-9]{4})(?<account_number>[0-9]{10})$/i

-  @spec size() :: 18
-  def size(), do: @size
-
-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
-        %Iban{
-          country_code: country_code,
-          check_digits: check_digits,
-          bank_code: bank_code,
-          branch_code: _branch_code,
-          national_check: _national_check,
-          account_number: account_number
-        } = _iban,
-        joiner \\ " "
-      ) do
-    [country_code, check_digits, bank_code, account_number]
-    |> Enum.join(joiner)
-  end
+  use IbanEx.Country.Template
 end
--- a/lib/iban_ex/country/ee.ex
+++ b/lib/iban_ex/country/ee.ex
@@ -1,25 +1,24 @@
 defmodule IbanEx.Country.EE do
  @moduledoc """
  Estonian IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "EE", check_digits: "38", bank_code: "22", branch_code: "00", national_check: "5", account_number: "22102014568"}
+    iex> |> IbanEx.Country.EE.to_string()
+    "EE 38 22 00 22102014568 5"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 20
-
  @rule ~r/^(?<bank_code>[0-9]{2})(?<branch_code>[0-9]{2})(?<account_number>[0-9]{11})(?<national_check>[0-9]{1})$/i

-  @spec size() :: 20
-  def size(), do: @size
+  use IbanEx.Country.Template

-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
        %Iban{
          country_code: country_code,
          check_digits: check_digits,
--- a/lib/iban_ex/country/es.ex
+++ b/lib/iban_ex/country/es.ex
@@ -1,25 +1,24 @@
 defmodule IbanEx.Country.ES do
  @moduledoc """
  Spain IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "ES", check_digits: "91", bank_code: "2100", branch_code: "0418", national_check: "45", account_number: "0200051332"}
+    iex> |> IbanEx.Country.ES.to_string()
+    "ES 91 2100 0418 45 0200051332"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 24
-
  @rule ~r/^(?<bank_code>[0-9]{4})(?<branch_code>[0-9]{4})(?<national_check>[0-9]{2})(?<account_number>[0-9]{10})$/i

-  @spec size() :: 24
-  def size(), do: @size
+  use IbanEx.Country.Template

-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
        %Iban{
          country_code: country_code,
          check_digits: check_digits,
--- a/lib/iban_ex/country/fi.ex
+++ b/lib/iban_ex/country/fi.ex
@@ -1,25 +1,24 @@
 defmodule IbanEx.Country.FI do
  @moduledoc """
  Finland IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "FI", check_digits: "21", bank_code: "123456", branch_code: nil, national_check: "5", account_number: "0000078"}
+    iex> |> IbanEx.Country.FI.to_string()
+    "FI 21 123456 0000078 5"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 18
-
  @rule ~r/^(?<bank_code>[0-9]{6})(?<account_number>[0-9]{7})(?<national_check>[0-9]{1})$/i

-  @spec size() :: 18
-  def size(), do: @size
+  use IbanEx.Country.Template

-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
        %Iban{
          country_code: country_code,
          check_digits: check_digits,
--- a/lib/iban_ex/country/fr.ex
+++ b/lib/iban_ex/country/fr.ex
@@ -1,25 +1,24 @@
 defmodule IbanEx.Country.FR do
  @moduledoc """
  France IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "FR", check_digits: "14", bank_code: "20041", branch_code: "01005", national_check: "06", account_number: "0500013M026"}
+    iex> |> IbanEx.Country.FR.to_string()
+    "FR 14 20041 01005 0500013M026 06"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 27
-
  @rule ~r/^(?<bank_code>[0-9]{5})(?<branch_code>[0-9]{5})(?<account_number>[0-9A-Z]{11})(?<national_check>[0-9]{2})$/i

-  @spec size() :: 27
-  def size(), do: @size
+  use IbanEx.Country.Template

-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
        %Iban{
          country_code: country_code,
          check_digits: check_digits,
--- a/lib/iban_ex/country/gb.ex
+++ b/lib/iban_ex/country/gb.ex
@@ -1,25 +1,24 @@
 defmodule IbanEx.Country.GB do
  @moduledoc """
  United Kingdom IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "GB", check_digits: "29", bank_code: "NWBK", branch_code: "601613", national_check: "06", account_number: "31926819"}
+    iex> |> IbanEx.Country.GB.to_string()
+    "GB 29 NWBK 601613 31926819"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 22
-
  @rule ~r/^(?<bank_code>[A-Z]{4})(?<branch_code>[0-9]{6})(?<account_number>[0-9]{8})$/i

-  @spec size() :: 22
-  def size(), do: @size
+  use IbanEx.Country.Template

-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
        %Iban{
          country_code: country_code,
          check_digits: check_digits,
--- a/lib/iban_ex/country/gi.ex
+++ b/lib/iban_ex/country/gi.ex
@@ -0,0 +1,17 @@
+defmodule IbanEx.Country.GI do
+  @moduledoc """
+  Gibraltar IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "GI", check_digits: "75", bank_code: "NWBK", branch_code: nil, national_check: nil, account_number: "000000007099453"}
+    iex> |> IbanEx.Country.GI.to_string()
+    "GI 75 NWBK 000000007099453"
+
+  """
+
+  @size 23
+  @rule ~r/^(?<bank_code>[A-Z]{4})(?<account_number>[0-9A-Z]{15})$/i
+
+  use IbanEx.Country.Template
+end
--- a/lib/iban_ex/country/gr.ex
+++ b/lib/iban_ex/country/gr.ex
@@ -0,0 +1,35 @@
+defmodule IbanEx.Country.GR do
+  @moduledoc """
+  Greece IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "GR", check_digits: "16", bank_code: "011", branch_code: "0125", national_check: nil, account_number: "0000000012300695"}
+    iex> |> IbanEx.Country.GR.to_string()
+    "GR 16 011 0125 0000000012300695"
+
+  """
+
+  @size 27
+  @rule ~r/^(?<bank_code>[0-9]{3})(?<branch_code>[0-9]{4})(?<account_number>[0-9A-Z]{16})$/i
+
+  use IbanEx.Country.Template
+
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
+        %Iban{
+          country_code: country_code,
+          check_digits: check_digits,
+          bank_code: bank_code,
+          branch_code: branch_code,
+          national_check: _national_check,
+          account_number: account_number
+        } = _iban,
+        joiner \\ " "
+      ) do
+    [country_code, check_digits, bank_code, branch_code, account_number]
+    |> Enum.join(joiner)
+  end
+end
--- a/lib/iban_ex/country/hr.ex
+++ b/lib/iban_ex/country/hr.ex
@@ -1,36 +1,17 @@
 defmodule IbanEx.Country.HR do
  @moduledoc """
  Croatia IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "HR", check_digits: "12", bank_code: "1001005", branch_code: nil, national_check: nil, account_number: "1863000160"}
+    iex> |> IbanEx.Country.HR.to_string()
+    "HR 12 1001005 1863000160"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 21
-
  @rule ~r/^(?<bank_code>[0-9]{7})(?<account_number>[0-9]{10})$/i

-  @spec size() :: 21
-  def size(), do: @size
-
-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
-        %Iban{
-          country_code: country_code,
-          check_digits: check_digits,
-          bank_code: bank_code,
-          branch_code: _branch_code,
-          national_check: _national_check,
-          account_number: account_number
-        } = _iban,
-        joiner \\ " "
-      ) do
-    [country_code, check_digits, bank_code, account_number]
-    |> Enum.join(joiner)
-  end
+  use IbanEx.Country.Template
 end
--- a/lib/iban_ex/country/hu.ex
+++ b/lib/iban_ex/country/hu.ex
@@ -0,0 +1,35 @@
+defmodule IbanEx.Country.HU do
+  @moduledoc """
+  Hungary IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "HU", check_digits: "42", bank_code: "117", branch_code: "7301", national_check: "0", account_number: "6111110180000000"}
+    iex> |> IbanEx.Country.HU.to_string()
+    "HU 42 117 7301 6111110180000000 0"
+
+  """
+
+  @size 28
+  @rule ~r/^(?<bank_code>[0-9]{3})(?<branch_code>[0-9]{4})(?<account_number>[0-9]{16})(?<national_check>[0-9]{1})$/i
+
+  use IbanEx.Country.Template
+
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
+        %Iban{
+          country_code: country_code,
+          check_digits: check_digits,
+          bank_code: bank_code,
+          branch_code: branch_code,
+          national_check: national_check,
+          account_number: account_number
+        } = _iban,
+        joiner \\ " "
+      ) do
+    [country_code, check_digits, bank_code, branch_code, account_number, national_check]
+    |> Enum.join(joiner)
+  end
+end
--- a/lib/iban_ex/country/ie.ex
+++ b/lib/iban_ex/country/ie.ex
@@ -0,0 +1,35 @@
+defmodule IbanEx.Country.IE do
+  @moduledoc """
+  Ireland IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "IE", check_digits: "29", bank_code: "AIBK", branch_code: "931152", national_check: nil, account_number: "12345678"}
+    iex> |> IbanEx.Country.IE.to_string()
+    "IE 29 AIBK 931152 12345678"
+
+  """
+
+  @size 22
+  @rule ~r/^(?<bank_code>[A-Z]{4})(?<branch_code>[0-9]{6})(?<account_number>[0-9]{8})$/i
+
+  use IbanEx.Country.Template
+
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
+        %Iban{
+          country_code: country_code,
+          check_digits: check_digits,
+          bank_code: bank_code,
+          branch_code: branch_code,
+          national_check: _national_check,
+          account_number: account_number
+        } = _iban,
+        joiner \\ " "
+      ) do
+    [country_code, check_digits, bank_code, branch_code, account_number]
+    |> Enum.join(joiner)
+  end
+end
--- a/lib/iban_ex/country/it.ex
+++ b/lib/iban_ex/country/it.ex
@@ -0,0 +1,35 @@
+defmodule IbanEx.Country.IT do
+  @moduledoc """
+  Italy IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "IT", check_digits: "60", bank_code: "05428", branch_code: "11101", national_check: "X", account_number: "000000123456"}
+    iex> |> IbanEx.Country.IT.to_string()
+    "IT 60 X 05428 11101 000000123456"
+
+  """
+
+  @size 27
+  @rule ~r/^(?<national_check>[A-Z]{1})(?<bank_code>[0-9]{5})(?<branch_code>[0-9]{5})(?<account_number>[0-9A-Z]{12})$/i
+
+  use IbanEx.Country.Template
+
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
+        %Iban{
+          country_code: country_code,
+          check_digits: check_digits,
+          bank_code: bank_code,
+          branch_code: branch_code,
+          national_check: national_check,
+          account_number: account_number
+        } = _iban,
+        joiner \\ " "
+      ) do
+    [country_code, check_digits, national_check, bank_code, branch_code, account_number]
+    |> Enum.join(joiner)
+  end
+end
--- a/lib/iban_ex/country/li.ex
+++ b/lib/iban_ex/country/li.ex
@@ -0,0 +1,17 @@
+defmodule IbanEx.Country.LI do
+  @moduledoc """
+  Liechtenstein IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "LI", check_digits: "21", bank_code: "08810", branch_code: nil, national_check: nil, account_number: "0002324013AA"}
+    iex> |> IbanEx.Country.LI.to_string()
+    "LI 21 08810 0002324013AA"
+
+  """
+
+  @size 21
+  @rule ~r/^(?<bank_code>[0-9]{5})(?<account_number>[0-9A-Z]{12})$/i
+
+  use IbanEx.Country.Template
+end
--- a/lib/iban_ex/country/lt.ex
+++ b/lib/iban_ex/country/lt.ex
@@ -1,36 +1,17 @@
 defmodule IbanEx.Country.LT do
  @moduledoc """
  Lithuanian IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "LT", check_digits: "12", bank_code: "10000", branch_code: nil, national_check: nil, account_number: "11101001000"}
+    iex> |> IbanEx.Country.LT.to_string()
+    "LT 12 10000 11101001000"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 20
-
  @rule ~r/^(?<bank_code>[0-9]{5})(?<account_number>[0-9]{11})$/i

-  @spec size() :: 20
-  def size(), do: @size
-
-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
-        %Iban{
-          country_code: country_code,
-          check_digits: check_digits,
-          bank_code: bank_code,
-          branch_code: _branch_code,
-          national_check: _national_check,
-          account_number: account_number
-        } = _iban,
-        joiner \\ " "
-      ) do
-    [country_code, check_digits, bank_code, account_number]
-    |> Enum.join(joiner)
-  end
+  use IbanEx.Country.Template
 end
--- a/lib/iban_ex/country/lu.ex
+++ b/lib/iban_ex/country/lu.ex
@@ -1,36 +1,17 @@
 defmodule IbanEx.Country.LU do
  @moduledoc """
  Luxembourg IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "LU", check_digits: "28", bank_code: "001", branch_code: nil, national_check: nil, account_number: "9400644750000"}
+    iex> |> IbanEx.Country.LU.to_string()
+    "LU 28 001 9400644750000"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 20
-
  @rule ~r/^(?<bank_code>[0-9]{3})(?<account_number>[0-9A-Z]{13})$/i

-  @spec size() :: 20
-  def size(), do: @size
-
-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
-        %Iban{
-          country_code: country_code,
-          check_digits: check_digits,
-          bank_code: bank_code,
-          branch_code: _branch_code,
-          national_check: _national_check,
-          account_number: account_number
-        } = _iban,
-        joiner \\ " "
-      ) do
-    [country_code, check_digits, bank_code, account_number]
-    |> Enum.join(joiner)
-  end
+  use IbanEx.Country.Template
 end
--- a/lib/iban_ex/country/lv.ex
+++ b/lib/iban_ex/country/lv.ex
@@ -1,36 +1,17 @@
 defmodule IbanEx.Country.LV do
  @moduledoc """
  Latvian IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "LV", check_digits: "80", bank_code: "BANK", branch_code: nil, national_check: nil, account_number: "0000435195001"}
+    iex> |> IbanEx.Country.LV.to_string()
+    "LV 80 BANK 0000435195001"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 21
-
  @rule ~r/^(?<bank_code>[A-Z]{4})(?<account_number>[0-9A-Z]{13})$/i

-  @spec size() :: 21
-  def size(), do: @size
-
-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
-        %Iban{
-          country_code: country_code,
-          check_digits: check_digits,
-          bank_code: bank_code,
-          branch_code: _branch_code,
-          national_check: _national_check,
-          account_number: account_number
-        } = _iban,
-        joiner \\ " "
-      ) do
-    [country_code, check_digits, bank_code, account_number]
-    |> Enum.join(joiner)
-  end
+  use IbanEx.Country.Template
 end
--- a/lib/iban_ex/country/mc.ex
+++ b/lib/iban_ex/country/mc.ex
@@ -0,0 +1,35 @@
+defmodule IbanEx.Country.MC do
+  @moduledoc """
+  Monaco IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "MC", check_digits: "58", bank_code: "11222", branch_code: "00001", national_check: "30", account_number: "01234567890"}
+    iex> |> IbanEx.Country.MC.to_string()
+    "MC 58 11222 00001 01234567890 30"
+
+  """
+
+  @size 27
+  @rule ~r/^(?<bank_code>[0-9]{5})(?<branch_code>[0-9]{5})(?<account_number>[0-9A-Z]{11})(?<national_check>[0-9]{2})$/i
+
+  use IbanEx.Country.Template
+
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
+        %Iban{
+          country_code: country_code,
+          check_digits: check_digits,
+          bank_code: bank_code,
+          branch_code: branch_code,
+          national_check: national_check,
+          account_number: account_number
+        } = _iban,
+        joiner \\ " "
+      ) do
+    [country_code, check_digits, bank_code, branch_code, account_number, national_check]
+    |> Enum.join(joiner)
+  end
+end
--- a/lib/iban_ex/country/mt.ex
+++ b/lib/iban_ex/country/mt.ex
@@ -1,25 +1,24 @@
 defmodule IbanEx.Country.MT do
  @moduledoc """
  Malta IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "MT", check_digits: "84", bank_code: "MALT", branch_code: "01100", national_check: nil, account_number: "0012345MTLCAST001S"}
+    iex> |> IbanEx.Country.MT.to_string()
+    "MT 84 MALT 01100 0012345MTLCAST001S"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 31
-
  @rule ~r/^(?<bank_code>[A-Z]{4})(?<branch_code>[0-9]{5})(?<account_number>[0-9A-Z]{18})$/i

-  @spec size() :: 31
-  def size(), do: @size
+  use IbanEx.Country.Template

-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
        %Iban{
          country_code: country_code,
          check_digits: check_digits,
--- a/lib/iban_ex/country/nl.ex
+++ b/lib/iban_ex/country/nl.ex
@@ -1,36 +1,17 @@
 defmodule IbanEx.Country.NL do
  @moduledoc """
  Netherlands IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "NL", check_digits: "91", bank_code: "ABNA", branch_code: nil, national_check: nil, account_number: "0417164300"}
+    iex> |> IbanEx.Country.NL.to_string()
+    "NL 91 ABNA 0417164300"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 18
-
  @rule ~r/^(?<bank_code>[A-Z]{4})(?<account_number>[0-9]{10})$/i

-  @spec size() :: 18
-  def size(), do: @size
-
-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
-        %Iban{
-          country_code: country_code,
-          check_digits: check_digits,
-          bank_code: bank_code,
-          branch_code: _branch_code,
-          national_check: _national_check,
-          account_number: account_number
-        } = _iban,
-        joiner \\ " "
-      ) do
-    [country_code, check_digits, bank_code, account_number]
-    |> Enum.join(joiner)
-  end
+  use IbanEx.Country.Template
 end
--- a/lib/iban_ex/country/no.ex
+++ b/lib/iban_ex/country/no.ex
@@ -0,0 +1,35 @@
+defmodule IbanEx.Country.NO do
+  @moduledoc """
+  Norway IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "NO", check_digits: "93", bank_code: "8601", branch_code: nil, national_check: "7", account_number: "111794"}
+    iex> |> IbanEx.Country.NO.to_string()
+    "NO 93 8601 111794 7"
+
+  """
+
+  @size 15
+  @rule ~r/^(?<bank_code>[0-9]{4})(?<account_number>[0-9]{6})(?<national_check>[0-9]{1})$/i
+
+  use IbanEx.Country.Template
+
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
+        %Iban{
+          country_code: country_code,
+          check_digits: check_digits,
+          bank_code: bank_code,
+          branch_code: _branch_code,
+          national_check: national_check,
+          account_number: account_number
+        } = _iban,
+        joiner \\ " "
+      ) do
+    [country_code, check_digits, bank_code, account_number, national_check]
+    |> Enum.join(joiner)
+  end
+end
--- a/lib/iban_ex/country/pl.ex
+++ b/lib/iban_ex/country/pl.ex
@@ -1,25 +1,24 @@
 defmodule IbanEx.Country.PL do
  @moduledoc """
  Poland IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "PL", check_digits: "61", bank_code: "109", branch_code: "0101", national_check: "4", account_number: "0000071219812874"}
+    iex> |> IbanEx.Country.PL.to_string()
+    "PL 61 109 0101 4 0000071219812874"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 28
-
  @rule ~r/^(?<bank_code>[0-9]{3})(?<branch_code>[0-9]{4})(?<national_check>[0-9]{1})(?<account_number>[0-9]{16})$/i

-  @spec size() :: 28
-  def size(), do: @size
+  use IbanEx.Country.Template

-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
        %Iban{
          country_code: country_code,
          check_digits: check_digits,
--- a/lib/iban_ex/country/pt.ex
+++ b/lib/iban_ex/country/pt.ex
@@ -1,25 +1,24 @@
 defmodule IbanEx.Country.PT do
  @moduledoc """
  Portugal IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "PT", check_digits: "50", bank_code: "0002", branch_code: "0123", national_check: "54", account_number: "12345678901"}
+    iex> |> IbanEx.Country.PT.to_string()
+    "PT 50 0002 0123 12345678901 54"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 25
-
  @rule ~r/^(?<bank_code>[0-9]{4})(?<branch_code>[0-9]{4})(?<account_number>[0-9]{11})(?<national_check>[0-9]{2})$/i

-  @spec size() :: 25
-  def size(), do: @size
+  use IbanEx.Country.Template

-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
        %Iban{
          country_code: country_code,
          check_digits: check_digits,
--- a/lib/iban_ex/country/ro.ex
+++ b/lib/iban_ex/country/ro.ex
@@ -0,0 +1,17 @@
+defmodule IbanEx.Country.RO do
+  @moduledoc """
+  Romania IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "RO", check_digits: "49", bank_code: "AAAA", branch_code: nil, national_check: nil, account_number: "1B31007593840000"}
+    iex> |> IbanEx.Country.RO.to_string()
+    "RO 49 AAAA 1B31007593840000"
+
+  """
+
+  @size 24
+  @rule ~r/^(?<bank_code>[A-Z]{4})(?<account_number>[0-9A-Z]{16})$/i
+
+  use IbanEx.Country.Template
+end
--- a/lib/iban_ex/country/se.ex
+++ b/lib/iban_ex/country/se.ex
@@ -0,0 +1,17 @@
+defmodule IbanEx.Country.SE do
+  @moduledoc """
+  Sweden IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "SE", check_digits: "45", bank_code: "500", branch_code: nil, national_check: nil, account_number: "00000058398257466"}
+    iex> |> IbanEx.Country.SE.to_string()
+    "SE 45 500 00000058398257466"
+
+  """
+
+  @size 24
+  @rule ~r/^(?<bank_code>[0-9]{3})(?<account_number>[0-9]{17})$/i
+
+  use IbanEx.Country.Template
+end
--- a/lib/iban_ex/country/si.ex
+++ b/lib/iban_ex/country/si.ex
@@ -0,0 +1,37 @@
+defmodule IbanEx.Country.SI do
+  @moduledoc """
+  Slovenia IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "SI", check_digits: "56", bank_code: "26", branch_code: "330", national_check: "86", account_number: "00120390"}
+    iex> |> IbanEx.Country.SI.to_string()
+    "SI 56 26 330 00120390 86"
+
+  """
+
+  @size 19
+  @rule ~r/^(?<bank_code>[0-9]{2})(?<branch_code>[0-9]{3})(?<account_number>[0-9]{8})(?<national_check>[0-9]{2})$/i
+
+  use IbanEx.Country.Template
+
+
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
+        %Iban{
+          country_code: country_code,
+          check_digits: check_digits,
+          bank_code: bank_code,
+          branch_code: branch_code,
+          national_check: national_check,
+          account_number: account_number
+        } = _iban,
+        joiner \\ " "
+      ) do
+    [country_code, check_digits, bank_code, branch_code, account_number, national_check]
+    |> Enum.join(joiner)
+  end
+
+end
--- a/lib/iban_ex/country/sk.ex
+++ b/lib/iban_ex/country/sk.ex
@@ -0,0 +1,17 @@
+defmodule IbanEx.Country.SK do
+  @moduledoc """
+  Slovakia IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "SK", check_digits: "31", bank_code: "1200", branch_code: nil, national_check: nil, account_number: "0000198742637541"}
+    iex> |> IbanEx.Country.SK.to_string()
+    "SK 31 1200 0000198742637541"
+
+  """
+
+  @size 24
+  @rule ~r/^(?<bank_code>[0-9]{4})(?<account_number>[0-9]{16})$/i
+
+  use IbanEx.Country.Template
+end
--- a/lib/iban_ex/country/sm.ex
+++ b/lib/iban_ex/country/sm.ex
@@ -0,0 +1,35 @@
+defmodule IbanEx.Country.SM do
+  @moduledoc """
+  San Marino IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "SM", check_digits: "86", bank_code: "03225", branch_code: "09800", national_check: "U", account_number: "000000270100"}
+    iex> |> IbanEx.Country.SM.to_string()
+    "SM 86 U 03225 09800 000000270100"
+
+  """
+
+  @size 27
+  @rule ~r/^(?<national_check>[A-Z]{1})(?<bank_code>[0-9]{5})(?<branch_code>[0-9]{5})(?<account_number>[0-9A-Z]{12})$/i
+
+  use IbanEx.Country.Template
+
+  @impl IbanEx.Country.Template
+  @spec to_string(Iban.t()) :: binary()
+  @spec to_string(Iban.t(), binary()) :: binary()
+  def to_string(
+        %Iban{
+          country_code: country_code,
+          check_digits: check_digits,
+          bank_code: bank_code,
+          branch_code: branch_code,
+          national_check: national_check,
+          account_number: account_number
+        } = _iban,
+        joiner \\ " "
+      ) do
+    [country_code, check_digits, national_check, bank_code, branch_code, account_number]
+    |> Enum.join(joiner)
+  end
+end
--- a/lib/iban_ex/country/template.ex
+++ b/lib/iban_ex/country/template.ex
@@ -1,4 +1,6 @@
 defmodule IbanEx.Country.Template do
+  @moduledoc false
+
  alias IbanEx.Iban
  @type size() :: non_neg_integer()
  @type rule() :: Regex.t()
@@ -7,6 +9,41 @@ defmodule IbanEx.Country.Template do

  @callback size() :: size()
  @callback rule() :: rule()
-  @callback to_s(Iban.t(), joiner()) :: String.t()
-  @callback to_s(Iban.t()) :: String.t()
+  @callback to_string(Iban.t(), joiner()) :: String.t()
+  @callback to_string(Iban.t()) :: String.t()
+
+  defmacro __using__(_opts) do
+    quote do
+      alias IbanEx.Iban
+      @behaviour IbanEx.Country.Template
+
+      @impl IbanEx.Country.Template
+      @spec to_string(Iban.t()) :: binary()
+      @spec to_string(Iban.t(), binary()) :: binary()
+      def to_string(
+            %Iban{
+              country_code: country_code,
+              check_digits: check_digits,
+              bank_code: bank_code,
+              branch_code: _branch_code,
+              national_check: _national_check,
+              account_number: account_number
+            } = _iban,
+            joiner \\ " "
+          ) do
+        [country_code, check_digits, bank_code, account_number]
+        |> Enum.join(joiner)
+      end
+
+      @impl IbanEx.Country.Template
+      @spec size() :: Integer.t()
+      def size(), do: @size
+
+      @impl IbanEx.Country.Template
+      @spec rule() :: Regex.t()
+      def rule(), do: @rule
+
+      defoverridable to_string: 1, to_string: 2, size: 0, rule: 0
+    end
+  end
 end
--- a/lib/iban_ex/country/ua.ex
+++ b/lib/iban_ex/country/ua.ex
@@ -1,36 +1,16 @@
 defmodule IbanEx.Country.UA do
  @moduledoc """
  Ukrainian IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "UA", check_digits: "21", bank_code: "322313", branch_code: nil, national_check: nil, account_number: "0000026007233566001"}
+    iex> |> IbanEx.Country.UA.to_string()
+    "UA 21 322313 0000026007233566001"
+
  """

-  alias IbanEx.Iban
-
-  @behaviour IbanEx.Country.Template
-
  @size 29
-
  @rule ~r/^(?<bank_code>[0-9]{6})(?<account_number>[0-9A-Z]{19})$/i
-
-  @spec size() :: 29
-  def size(), do: @size
-
-  @spec rule() :: Regex.t()
-  def rule(), do: @rule
-
-  @spec to_s(Iban.t()) :: binary()
-  @spec to_s(Iban.t(), binary()) :: binary()
-  def to_s(
-        %Iban{
-          country_code: country_code,
-          check_digits: check_digits,
-          bank_code: bank_code,
-          branch_code: _branch_code,
-          national_check: _national_check,
-          account_number: account_number
-        } = _iban,
-        joiner \\ " "
-      ) do
-    [country_code, check_digits, bank_code, account_number]
-    |> Enum.join(joiner)
-  end
+  use IbanEx.Country.Template
 end
--- a/lib/iban_ex/country/va.ex
+++ b/lib/iban_ex/country/va.ex
@@ -0,0 +1,17 @@
+defmodule IbanEx.Country.VA do
+  @moduledoc """
+  Vatican IBAN parsing rules
+
+  ## Examples
+
+    iex> %IbanEx.Iban{country_code: "VA", check_digits: "59", bank_code: "001", branch_code: nil, national_check: nil, account_number: "123000012345678"}
+    iex> |> IbanEx.Country.VA.to_string()
+    "VA 59 001 123000012345678"
+
+  """
+
+  @size 22
+  @rule ~r/^(?<bank_code>[0-9]{3})(?<account_number>[0-9]{15})$/i
+
+  use IbanEx.Country.Template
+end
--- a/lib/iban_ex/deserialize.ex
+++ b/lib/iban_ex/deserialize.ex
@@ -7,8 +7,8 @@ def to_iban(value)
 defimpl IbanEx.Deserialize, for: [BitString, String] do
  alias IbanEx.{Parser, Error}
  @type iban_or_error() :: IbanEx.Iban.t() | {:error, atom()}
+  @spec to_iban(binary()) :: iban_or_error()
  @spec to_iban(String.t()) :: iban_or_error()
-  @spec to_iban(binary()) :: IbanEx.Iban.t()
  def to_iban(string) do
    case Parser.parse(string) do
      {:ok, iban} -> iban
@@ -27,6 +27,8 @@ def to_iban(
          country_code: _country_code,
          check_digits: _check_sum_digits,
          bank_code: _bank_code,
+          branch_code: _branch_code,
+          national_check: _national_check,
          account_number: _account_number
        } = map
      ) do
@@ -38,6 +40,8 @@ def to_iban(
          "country_code" => _country_code,
          "check_digits" => _check_sum_digits,
          "bank_code" => _bank_code,
+          "branch_code" => _branch_code,
+          "national_check" => _national_check,
          "account_number" => _account_number
        } = map
      ) do
@@ -47,3 +51,11 @@ def to_iban(

  def to_iban(map) when is_map(map), do: {:error, :can_not_parse_map}
 end
+
+defimpl IbanEx.Deserialize, for: List do
+  alias IbanEx.Iban
+  @type iban_or_error() :: IbanEx.Iban.t() | {:error, :can_not_parse_map}
+
+  @spec to_iban(list()) :: iban_or_error()
+  def to_iban(list), do: struct(Iban, Map.new(list))
+end
--- a/lib/iban_ex/error.ex
+++ b/lib/iban_ex/error.ex
@@ -1,7 +1,5 @@
 defmodule IbanEx.Error do
-  @moduledoc """
-
-  """
+  @moduledoc false

  @type error() ::
          :unsupported_country_code
@@ -9,6 +7,8 @@ defmodule IbanEx.Error do
          | :invalid_length
          | :invalid_checksum
          | :can_not_parse_map
+          | :length_to_long
+          | :length_to_short
          | atom()
  @type errors() :: [error()]
  @errors [
@@ -16,15 +16,19 @@ defmodule IbanEx.Error do
    :invalid_format,
    :invalid_length,
    :invalid_checksum,
-    :can_not_parse_map
-  ]
+    :can_not_parse_map,
+    :length_to_long,
+    :length_to_short
+]

  @messages [
    unsupported_country_code: "Unsupported country code",
    invalid_format: "IBAN violates required format",
    invalid_length: "IBAN violates the required length",
    invalid_checksum: "IBAN's checksum is invalid",
-    can_not_parse_map: "Can't parse map to IBAN struct"
+    can_not_parse_map: "Can't parse map to IBAN struct",
+    length_to_long: "IBAN longer then required length",
+    length_to_short: "IBAN shorter then required length"
  ]

  @spec message(error()) :: String.t()
--- a/lib/iban_ex/formatter.ex
+++ b/lib/iban_ex/formatter.ex
@@ -1,4 +1,6 @@
 defmodule IbanEx.Formatter do
+  @moduledoc false
+
  alias IbanEx.Country
  import IbanEx.Commons, only: [normalize: 1]

@@ -28,7 +30,7 @@ def format(iban, :compact),

  def format(iban, :pretty) do
    country_module = Country.country_module(iban.country_code)
-    country_module.to_s(iban)
+    country_module.to_string(iban)
  end

  def format(iban, :splitted) do
--- a/lib/iban_ex/iban.ex
+++ b/lib/iban_ex/iban.ex
@@ -1,4 +1,6 @@
 defmodule IbanEx.Iban do
+  @moduledoc false
+
  alias IbanEx.Formatter
  alias IbanEx.{Serialize}

--- a/lib/iban_ex/parser.ex
+++ b/lib/iban_ex/parser.ex
@@ -1,4 +1,6 @@
 defmodule IbanEx.Parser do
+  @moduledoc false
+
  alias IbanEx.{Country, Iban, Validator}
  import IbanEx.Commons, only: [normalize_and_slice: 2]

@@ -9,23 +11,35 @@ defmodule IbanEx.Parser do

  @spec parse({:ok, String.t()} | String.t()) :: iban_or_error()
  def parse({:ok, iban_string}), do: parse(iban_string)
+
  def parse(iban_string) do
-    with {:ok, valid_iban} <- Validator.validate(iban_string) do
-      iban_map = %{
-        country_code: country_code(valid_iban),
-        check_digits: check_digits(valid_iban),
-      }
+    case Validator.validate(iban_string) do
+      {:ok, valid_iban} ->
+        iban_map = %{
+          country_code: country_code(valid_iban),
+          check_digits: check_digits(valid_iban)
+        }

-      regex = Country.country_module(iban_map.country_code).rule()
-      bban = bban(iban_string)
-      bban_map = for {key, val} <- Regex.named_captures(regex, bban), into: %{}, do: {String.to_atom(key), val}
+        bban_map =
+          iban_string
+          |> bban()
+          |> parse_bban(iban_map.country_code)

-      {:ok, struct(Iban, Map.merge(iban_map, bban_map))}
-    else
-      {:error, error_type} -> {:error, error_type}
+        {:ok, struct(Iban, Map.merge(iban_map, bban_map))}
+
+      {:error, error_type} ->
+        {:error, error_type}
    end
  end

+  @spec parse_bban(binary(), <<_::16>>) :: map()
+  def parse_bban(bban_string, country_code) do
+    regex = Country.country_module(country_code).rule()
+    for {key, val} <- Regex.named_captures(regex, bban_string),
+        into: %{},
+        do: {String.to_atom(key), val}
+  end
+
  @spec country_code(iban_string()) :: country_code_string()
  def country_code(iban_string), do: normalize_and_slice(iban_string, 0..1)

--- a/lib/iban_ex/serialize.ex
+++ b/lib/iban_ex/serialize.ex
@@ -1,4 +1,6 @@
 defmodule IbanEx.Serialize do
+  @moduledoc false
+
  alias IbanEx.{Iban, Formatter}

  @spec to_string(Iban.t()) :: String.t()
--- a/lib/iban_ex/validator/validator.ex
+++ b/lib/iban_ex/validator/validator.ex
@@ -1,28 +1,53 @@
 defmodule IbanEx.Validator do
+  @moduledoc false
+
  alias IbanEx.{Country, Parser}
  alias IbanEx.Validator.Replacements
  import IbanEx.Commons, only: [normalize: 1]

-  @spec validate(String.t()) :: {:ok, String.t()} | {:error}
+  defp error_accumulator(acc, error_message)
+  defp error_accumulator(acc, {:error, error}), do: [error | acc]
+  defp error_accumulator(acc, _), do: acc
+
+  defp violation_functions(),
+    do: [
+      {&__MODULE__.iban_violates_format?/1, {:error, :invalid_format}},
+      {&__MODULE__.iban_unsupported_country?/1, {:error, :unsupported_country_code}},
+      {&__MODULE__.iban_violates_length?/1, {:error, :invalid_length}},
+      {&__MODULE__.iban_violates_country_rule?/1, {:error, :invalid_format}},
+      {&__MODULE__.iban_violates_checksum?/1, {:error, :invalid_checksum}}
+    ]
+
+  @doc """
+  Accumulate check results in the list of errors
+  Check iban_violates_format?, iban_unsupported_country?, iban_violates_length?, iban_violates_country_rule?, iban_violates_checksum?
+  """
+  @spec violations(String.t()) :: [] | [atom()]
+  def violations(iban) do
+    violation_functions()
+    |> Enum.reduce([], fn {fun, value}, acc -> error_accumulator(acc, !fun.(iban) or value) end)
+    |> Enum.reverse()
+  end
+
+  @doc """
+  Make checks in this order step-by-step before first error ->
+
+    iban_violates_format?,
+    iban_unsupported_country?,
+    iban_violates_length?,
+    iban_violates_country_rule?,
+    iban_violates_checksum?
+
+  """
+  @spec validate(String.t()) :: {:ok, String.t()} | {:error, Atom.t()}
  def validate(iban) do
    cond do
-      iban_violates_format?(iban) ->
-        {:error, :invalid_format}
-
-      iban_unsupported_country?(iban) ->
-        {:error, :unsupported_country_code}
-
-      iban_violates_length?(iban) ->
-        {:error, :invalid_length}
-
-      iban_violates_country_rule?(iban) ->
-        {:error, :invalid_format}
-
-      iban_violates_checksum?(iban) ->
-        {:error, :invalid_checksum}
-
-      true ->
-        {:ok, normalize(iban)}
+      iban_violates_format?(iban) -> {:error, :invalid_format}
+      iban_unsupported_country?(iban) -> {:error, :unsupported_country_code}
+      iban_violates_length?(iban) -> {:error, :invalid_length}
+      iban_violates_country_rule?(iban) -> {:error, :invalid_format}
+      iban_violates_checksum?(iban) -> {:error, :invalid_checksum}
+      true -> {:ok, normalize(iban)}
    end
  end

@@ -35,12 +60,12 @@ defp size(iban) do

  # - Check whether a given IBAN violates the required format.
  @spec iban_violates_format?(String.t()) :: boolean
-  defp iban_violates_format?(iban),
+  def iban_violates_format?(iban),
    do: Regex.match?(~r/[^A-Z0-9]/i, normalize(iban))

  # - Check whether a given IBAN violates the supported countries.
  @spec iban_unsupported_country?(String.t()) :: boolean
-  defp iban_unsupported_country?(iban) do
+  def iban_unsupported_country?(iban) do
    supported? =
      iban
      |> Parser.country_code()
@@ -49,33 +74,52 @@ defp iban_unsupported_country?(iban) do
    !supported?
  end

-  # - Check whether a given IBAN violates the required length.
+  @doc "Check whether a given IBAN violates the required length."
  @spec iban_violates_length?(String.t()) :: boolean
-  defp iban_violates_length?(iban) do
+  def iban_violates_length?(iban) do
    with country_code <- Parser.country_code(iban),
-         country_module <- Country.country_module(country_code) do
+         country_module when is_atom(country_module) <- Country.country_module(country_code) do
      size(iban) != country_module.size()
    else
-      {:error, _} -> true
+      {:error, _error} -> true
    end
  end

-  # - Check whether a given IBAN violates the country rules.
+  @doc "Check length of IBAN"
+  @spec check_iban_length(String.t()) :: {:error, :length_to_short | :length_to_long } | :ok
+  def check_iban_length(iban) do
+    unless iban_unsupported_country?(iban) do
+      country_module =
+        iban
+        |> Parser.country_code()
+        |> Country.country_module()
+
+      case country_module.size() - size(iban) do
+        diff when diff > 0 -> {:error, :length_to_short}
+        diff when diff < 0 -> {:error, :length_to_long}
+        0 -> :ok
+      end
+    else
+      {:error, :unsupported_country_code}
+    end
+  end
+
+  @doc "Check whether a given IBAN violates the country rules"
  @spec iban_violates_country_rule?(String.t()) :: boolean
-  defp iban_violates_country_rule?(iban) do
+  def iban_violates_country_rule?(iban) do
    with country_code <- Parser.country_code(iban),
         bban <- Parser.bban(iban),
-         country_module <- Country.country_module(country_code),
+         country_module when is_atom(country_module) <- Country.country_module(country_code),
         rule <- country_module.rule() do
      !Regex.match?(rule, bban)
    else
-      {:error, _} -> true
+      {:error, _error} -> true
    end
  end

-  # - Check whether a given IBAN violates the required checksum.
+  @doc "Check whether a given IBAN violates the required checksum."
  @spec iban_violates_checksum?(String.t()) :: boolean
-  defp iban_violates_checksum?(iban) do
+  def iban_violates_checksum?(iban) do
    check_sum_base = Parser.bban(iban) <> Parser.country_code(iban) <> "00"

    replacements = Replacements.replacements()
--- a/mix.exs
+++ b/mix.exs
@@ -2,7 +2,7 @@ defmodule IbanEx.MixProject do
  use Mix.Project

  @source_url "https://g.tulz.dev/opensource/iban-ex"
-  @version "0.1.0"
+  @version "0.1.5"

  def project do
    [
@@ -68,7 +68,6 @@ defp deps do
      {:ex_doc, ">= 0.0.0", only: ~w(dev test)a, runtime: false},
      {:sobelow, ">= 0.0.0", only: ~w(dev test)a, runtime: false},
      {:mix_audit, ">= 0.0.0", only: ~w(dev test)a, runtime: false},
-      {:esbuild, "~> 0.7.0", runtime: Mix.env() == :dev},
      {:observer_cli, "~> 1.7.4", only: :dev, runtime: false},
      {:elixir_sense, github: "elixir-lsp/elixir_sense", only: ~w(dev)a}

--- a/test/iban_ex_test.exs
+++ b/test/iban_ex_test.exs
@@ -1,8 +1,130 @@
 defmodule IbanExTest do
-  use ExUnit.Case
-  doctest IbanEx
+  alias IbanEx.{Country, Iban, Parser}
+  use ExUnit.Case, async: true
+  doctest_file "README.md"
+  doctest IbanEx.Country.AT
+  doctest IbanEx.Country.BE
+  doctest IbanEx.Country.BG
+  doctest IbanEx.Country.CH
+  doctest IbanEx.Country.CY
+  doctest IbanEx.Country.CZ
+  doctest IbanEx.Country.DE
+  doctest IbanEx.Country.DK
+  doctest IbanEx.Country.EE
+  doctest IbanEx.Country.ES
+  doctest IbanEx.Country.FI
+  doctest IbanEx.Country.FR
+  doctest IbanEx.Country.GB
+  doctest IbanEx.Country.GI
+  doctest IbanEx.Country.GR
+  doctest IbanEx.Country.HR
+  doctest IbanEx.Country.HU
+  doctest IbanEx.Country.IE
+  doctest IbanEx.Country.IT
+  doctest IbanEx.Country.LI
+  doctest IbanEx.Country.LT
+  doctest IbanEx.Country.LU
+  doctest IbanEx.Country.LV
+  doctest IbanEx.Country.MC
+  doctest IbanEx.Country.MT
+  doctest IbanEx.Country.NL
+  doctest IbanEx.Country.NO
+  doctest IbanEx.Country.PL
+  doctest IbanEx.Country.PT
+  doctest IbanEx.Country.RO
+  doctest IbanEx.Country.SE
+  doctest IbanEx.Country.SM
+  doctest IbanEx.Country.SI
+  doctest IbanEx.Country.SK
+  doctest IbanEx.Country.UA
+  doctest IbanEx.Country.VA

-  test "greets the world" do
-    assert IbanEx.hello() == :world
+  @ibans [
+    "AL47212110090000000235698741",
+    "AD1200012030200359100100",
+    "AT611904300234573201",
+    "AZ21NABZ00000000137010001944",
+    "BH67BMAG00001299123456",
+    "BE68539007547034",
+    "BA391290079401028494",
+    "BR1800360305000010009795493C1",
+    "BG80BNBG96611020345678",
+    "CR05015202001026284066",
+    "HR1210010051863000160",
+    "CY17002001280000001200527600",
+    "CZ6508000000192000145399",
+    "DK5000400440116243",
+    "DO28BAGR00000001212453611324",
+    "EG380019000500000000263180002",
+    "SV62CENR00000000000000700025",
+    "EE382200221020145685",
+    "FO6264600001631634",
+    "FI2112345600000785",
+    "FR1420041010050500013M02606",
+    "GE29NB0000000101904917",
+    "DE89370400440532013000",
+    "GI75NWBK000000007099453",
+    "GR1601101250000000012300695",
+    "GL8964710001000206",
+    "GT82TRAJ01020000001210029690",
+    "HU42117730161111101800000000",
+    "IS140159260076545510730339",
+    "IE29AIBK93115212345678",
+    "IL620108000000099999999",
+    "IT60X0542811101000000123456",
+    "JO94CBJO0010000000000131000302",
+    "KZ86125KZT5004100100",
+    "XK051212012345678906",
+    "KW81CBKU0000000000001234560101",
+    "LV80BANK0000435195001",
+    "LB62099900000001001901229114",
+    "LI21088100002324013AA",
+    "LT121000011101001000",
+    "LU280019400644750000",
+    "MK07250120000058984",
+    "MT84MALT011000012345MTLCAST001S",
+    "MR1300020001010000123456753",
+    "MC5811222000010123456789030",
+    "ME25505000012345678951",
+    "NL91ABNA0417164300",
+    "NO9386011117947",
+    "PK36SCBL0000001123456702",
+    "PL61109010140000071219812874",
+    "PT50000201231234567890154",
+    "QA58DOHB00001234567890ABCDEFG",
+    "MD24AG000225100013104168",
+    "RO49AAAA1B31007593840000",
+    "SM86U0322509800000000270100",
+    "SA0380000000608010167519",
+    "RS35260005601001611379",
+    "SK3112000000198742637541",
+    "SI56263300012039086",
+    "ES9121000418450200051332",
+    "SE4550000000058398257466",
+    "CH9300762011623852957",
+    "TL380080012345678910157",
+    "TR330006100519786457841326",
+    "UA213223130000026007233566001",
+    "AE070331234567890123456",
+    "GB29NWBK60161331926819",
+    "VA59001123000012345678",
+    "VG96VPVG0000012345678901"
+  ]
+
+  test "parsing valid IBANs from available countries returns {:ok, %IbanEx.Iban{}}" do
+    assert Enum.all?(@ibans, fn iban ->
+             iban_country = iban |> String.upcase() |> String.slice(0..1)
+
+             case {Country.is_country_code_supported?(iban_country), Parser.parse(iban)} do
+               {true, {:ok, %Iban{}}} ->
+                 true
+
+               {false, {:error, :unsupported_country_code}} ->
+                 true
+
+               _ ->
+                 false
+             end
+           end)
  end
 end
--- a/test/iban_ex_validator_test.exs
+++ b/test/iban_ex_validator_test.exs
@@ -0,0 +1,18 @@
+defmodule IbanExValidatorTest do
+  alias IbanEx.{Validator}
+  use ExUnit.Case, async: true
+
+  test "check IBANs length" do
+    cases = [
+      {"FG2112345CC6000007", {:error, :unsupported_country_code}},
+      {"UK2112345CC6000007", {:error, :unsupported_country_code}},
+      {"FI2112345CC6000007", :ok},
+      {"FI2112345CC6000007a", {:error, :length_to_long}},
+      {"FI2112345CC600007", {:error, :length_to_short}}
+    ]
+
+    Enum.all?(cases, fn {iban, result} ->
+      assert Validator.check_iban_length(iban) == result
+    end)
+  end
+end
Author	SHA1	Message	Date
Danylo Negrienko	4abf01b752	bban parse function	2024-05-11 11:52:34 -04:00
Danylo Negrienko	ae17d13731	VErsion fix	2024-05-10 18:03:26 -04:00
Danylo Negrienko	4447a10bf2	Length checks added, validations added	2024-05-10 17:56:29 -04:00
Danylo Negrienko	51c5c1d800	Formatted doctests	2024-03-10 20:20:15 -04:00
Danylo Negrienko	fdf28f7609	Added all SEPA countries (IBANs from European Union countries) and minimal test coverage for countries	2024-03-10 20:02:20 -04:00
Danylo Negrienko	6b5f3676c8	Removed esbuild and bumped to 0.1.1	2024-03-07 18:41:45 -05:00
Danylo Negrienko	390036bafb	Credo warning fast fixes (disable module docs)	2024-03-07 18:39:33 -05:00
Danylo Negrienko	1a9d6758fd	”Use“ and some metaprograming to refactor behaviours implimentation	2024-03-07 18:33:38 -05:00
Danylo Negrienko	368225f331	List deserializer added	2024-03-05 19:56:59 -05:00
Danylo Negrienko	72ec45a361	Updated README.md	2024-03-05 19:49:20 -05:00