opensource/iban-ex
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added first non SEPA countries

Browse Source
This commit is contained in:
Danil Negrienko
2024-05-14 19:15:55 -04:00
parent 4abf01b752
commit 384b9b7a39
75 changed files with 1653 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
lib/iban_ex/country.ex
View File

@@ -7,42 +7,74 @@ defmodule IbanEx.Country do
@type error_tuple() :: {:error, atom()}
@supported_countries %{
"AD" => IbanEx.Country.AD,
"AE" => IbanEx.Country.AE,
"AL" => IbanEx.Country.AL,
"AT" => IbanEx.Country.AT,
"AZ" => IbanEx.Country.AZ,
"BA" => IbanEx.Country.BA,
"BE" => IbanEx.Country.BE,
"BG" => IbanEx.Country.BG,
"BH" => IbanEx.Country.BH,
"BR" => IbanEx.Country.BR,
"CH" => IbanEx.Country.CH,
"CR" => IbanEx.Country.CR,
"CY" => IbanEx.Country.CY,
"CZ" => IbanEx.Country.CZ,
"DE" => IbanEx.Country.DE,
"DO" => IbanEx.Country.DO,
"DK" => IbanEx.Country.DK,
"EE" => IbanEx.Country.EE,
"ES" => IbanEx.Country.ES,
"EG" => IbanEx.Country.EG,
"FI" => IbanEx.Country.FI,
"FR" => IbanEx.Country.FR,
"FO" => IbanEx.Country.FO,
"GB" => IbanEx.Country.GB,
"GE" => IbanEx.Country.GE,
"GI" => IbanEx.Country.GI,
"GL" => IbanEx.Country.GL,
"GR" => IbanEx.Country.GR,
"GT" => IbanEx.Country.GT,
"HR" => IbanEx.Country.HR,
"HU" => IbanEx.Country.HU,
"IE" => IbanEx.Country.IE,
"IL" => IbanEx.Country.IL,
"IT" => IbanEx.Country.IT,
"JO" => IbanEx.Country.JO,
"KZ" => IbanEx.Country.KZ,
"KW" => IbanEx.Country.KW,
"LB" => IbanEx.Country.LB,
"LI" => IbanEx.Country.LI,
"LT" => IbanEx.Country.LT,
"LU" => IbanEx.Country.LU,
"LV" => IbanEx.Country.LV,
"MC" => IbanEx.Country.MC,
"MD" => IbanEx.Country.MD,
"ME" => IbanEx.Country.ME,
"MK" => IbanEx.Country.MK,
"MR" => IbanEx.Country.MR,
"MT" => IbanEx.Country.MT,
"NL" => IbanEx.Country.NL,
"NO" => IbanEx.Country.NO,
"PL" => IbanEx.Country.PL,
"PT" => IbanEx.Country.PT,
"PK" => IbanEx.Country.PK,
"QA" => IbanEx.Country.QA,
"RO" => IbanEx.Country.RO,
"RS" => IbanEx.Country.RS,
"SA" => IbanEx.Country.SA,
"SE" => IbanEx.Country.SE,
"SM" => IbanEx.Country.SM,
"SI" => IbanEx.Country.SI,
"SK" => IbanEx.Country.SK,
"SM" => IbanEx.Country.SM,
"SV" => IbanEx.Country.SV,
"TL" => IbanEx.Country.TL,
"TR" => IbanEx.Country.TR,
"UA" => IbanEx.Country.UA,
"VA" => IbanEx.Country.VA
"VA" => IbanEx.Country.VA,
"VG" => IbanEx.Country.VG,
"XK" => IbanEx.Country.XK
}
@supported_country_codes Map.keys(@supported_countries)
@@ -57,7 +89,7 @@ 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()
@spec country_module(country_code) :: module() | error_tuple()
def country_module(country_code) when is_binary(country_code) or is_atom(country_code) do
normalized_country_code = normalize(country_code)
case is_country_code_supported?(normalized_country_code) do

42
lib/iban_ex/country/ad.ex Normal file
View File

@@ -0,0 +1,42 @@
defmodule IbanEx.Country.AD do
@moduledoc """
Andorra IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "AD",
...> check_digits: "12",
...> bank_code: "0001",
...> branch_code: "2030",
...> national_check: nil,
...> account_number: "200359100100"
...> }
...> |> IbanEx.Country.AD.to_string()
"AD 12 0001 2030 200359100100"
```
"""
@size 24
@rule ~r/^(?<bank_code>[0-9]{4})(?<branch_code>[0-9]{4})(?<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, bank_code, branch_code, account_number]
|> Enum.join(joiner)
end
end

25
lib/iban_ex/country/ae.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.AE do
@moduledoc """
United Arab Emirates IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "AE",
...> check_digits: "07",
...> bank_code: "033",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "1234567890123456"
...> }
...> |> IbanEx.Country.AE.to_string()
"AE 07 033 1234567890123456"
```
"""
@size 23
@rule ~r/^(?<bank_code>[0-9]{3})(?<account_number>[0-9]{16})$/i
use IbanEx.Country.Template
end

42
lib/iban_ex/country/al.ex Normal file
View File

@@ -0,0 +1,42 @@
defmodule IbanEx.Country.AL do
@moduledoc """
Albania IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "AL",
...> check_digits: "47",
...> bank_code: "212",
...> branch_code: "1100",
...> national_check: "9",
...> account_number: "0000000235698741"
...> }
...> |> IbanEx.Country.AL.to_string()
"AL 47 212 1100 9 0000000235698741"
```
"""
@size 28
@rule ~r/^(?<bank_code>[0-9]{3})(?<branch_code>[0-9]{4})(?<national_check>[0-9]{1})(?<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, national_check, account_number]
|> Enum.join(joiner)
end
end

25
lib/iban_ex/country/az.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.AZ do
@moduledoc """
Azerbaijan IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "AZ",
...> check_digits: "21",
...> bank_code: "NABZ",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "00000000137010001944"
...> }
...> |> IbanEx.Country.AZ.to_string()
"AZ 21 NABZ 00000000137010001944"
```
"""
@size 28
@rule ~r/^(?<bank_code>[A-Z]{4})(?<account_number>[0-9A-Z]{20})$/i
use IbanEx.Country.Template
end

42
lib/iban_ex/country/ba.ex Normal file
View File

@@ -0,0 +1,42 @@
defmodule IbanEx.Country.BA do
@moduledoc """
Bosnia and Herzegovina IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "BA",
...> check_digits: "39",
...> bank_code: "129",
...> branch_code: "007",
...> national_check: "94",
...> account_number: "94010284"
...> }
...> |> IbanEx.Country.BA.to_string()
"BA 39 129 007 94010284 94"
```
"""
@size 20
@rule ~r/^(?<bank_code>[0-9]{3})(?<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

25
lib/iban_ex/country/bh.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.BH do
@moduledoc """
Bahrain IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "BH",
...> check_digits: "67",
...> bank_code: "BMAG",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "00001299123456"
...> }
...> |> IbanEx.Country.BH.to_string()
"BH 67 BMAG 00001299123456"
```
"""
@size 22
@rule ~r/^(?<bank_code>[A-Z]{4})(?<account_number>[0-9]{14})$/i
use IbanEx.Country.Template
end

42
lib/iban_ex/country/br.ex Normal file
View File

@@ -0,0 +1,42 @@
defmodule IbanEx.Country.BR do
@moduledoc """
Brazil IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "BR",
...> check_digits: "18",
...> bank_code: "00360305",
...> branch_code: "00001",
...> account_number: "0009795493",
...> national_check: "C1"
...> }
...> |> IbanEx.Country.BR.to_string()
"BR 18 00360305 00001 0009795493 C1"
```
"""
@size 29
@rule ~r/^(?<bank_code>[0-9]{8})(?<branch_code>[0-9]{5})(?<account_number>[0-9]{10})(?<national_check>[A-Z]{1}[0-9A-Z]{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,
account_number: account_number,
national_check: national_check
} = _iban,
joiner \\ " "
) do
[country_code, check_digits, bank_code, branch_code, account_number, national_check]
|> Enum.join(joiner)
end
end

16
lib/iban_ex/country/ch.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.CH do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "CH",
...> check_digits: "93",
...> bank_code: "00762",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "011623852957"
...> }
...> |> IbanEx.Country.CH.to_string()
"CH 93 00762 011623852957"
```
"""
@size 21

25
lib/iban_ex/country/cr.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.CR do
@moduledoc """
Costa Rica IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "CR",
...> check_digits: "05",
...> bank_code: "0152",
...> branch_code: nil,
...> account_number: "02001026284066",
...> national_check: nil
...> }
...> |> IbanEx.Country.CR.to_string()
"CR 05 0152 02001026284066"
```
"""
@size 22
@rule ~r/^(?<bank_code>[0-9]{4})(?<account_number>[0-9]{14})$/i
use IbanEx.Country.Template
end

16
lib/iban_ex/country/cy.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.CY do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "CY",
...> check_digits: "17",
...> bank_code: "002",
...> branch_code: "00128",
...> national_check: nil,
...> account_number: "0000001200527600"
...> }
...> |> IbanEx.Country.CY.to_string()
"CY 17 002 00128 0000001200527600"
```
"""
@size 28

16
lib/iban_ex/country/cz.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.CZ do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "CZ",
...> check_digits: "65",
...> bank_code: "0800",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "0000192000145399"
...> }
...> |> IbanEx.Country.CZ.to_string()
"CZ 65 0800 0000192000145399"
```
"""
@size 24

16
lib/iban_ex/country/de.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.DE do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "DE",
...> check_digits: "89",
...> bank_code: "37040044",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "0532013000"
...> }
...> |> IbanEx.Country.DE.to_string()
"DE 89 37040044 0532013000"
```
"""
@size 22

16
lib/iban_ex/country/dk.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.DK do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "DK",
...> check_digits: "50",
...> bank_code: "0040",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "0440116243"
...> }
...> |> IbanEx.Country.DK.to_string()
"DK 50 0040 0440116243"
```
"""
@size 18
@rule ~r/^(?<bank_code>[0-9]{4})(?<account_number>[0-9]{10})$/i

25
lib/iban_ex/country/do.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.DO do
@moduledoc """
Dominican Republic IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "DO",
...> check_digits: "28",
...> bank_code: "BAGR",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "00000001212453611324"
...> }
...> |> IbanEx.Country.DO.to_string()
"DO 28 BAGR 00000001212453611324"
```
"""
@size 28
@rule ~r/^(?<bank_code>[0-9A-Z]{4})(?<account_number>[0-9]{20})$/i
use IbanEx.Country.Template
end

16
lib/iban_ex/country/ee.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.EE do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "EE",
...> check_digits: "38",
...> bank_code: "22",
...> branch_code: "00",
...> national_check: "5",
...> account_number: "22102014568"
...> }
...> |> IbanEx.Country.EE.to_string()
"EE 38 22 00 22102014568 5"
```
"""
@size 20

42
lib/iban_ex/country/eg.ex Normal file
View File

@@ -0,0 +1,42 @@
defmodule IbanEx.Country.EG do
@moduledoc """
Egypt IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "EG",
...> check_digits: "38",
...> bank_code: "0019",
...> branch_code: "0005",
...> national_check: nil,
...> account_number: "00000000263180002"
...> }
...> |> IbanEx.Country.EG.to_string()
"EG 38 0019 0005 00000000263180002"
```
"""
@size 29
@rule ~r/^(?<bank_code>[0-9]{4})(?<branch_code>[0-9]{4})(?<account_number>[0-9]{17})$/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

16
lib/iban_ex/country/es.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.ES do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "ES",
...> check_digits: "91",
...> bank_code: "2100",
...> branch_code: "0418",
...> national_check: "45",
...> account_number: "0200051332"
...> }
...> |> IbanEx.Country.ES.to_string()
"ES 91 2100 0418 45 0200051332"
```
"""
@size 24

16
lib/iban_ex/country/fi.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.FI do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "FI",
...> check_digits: "21",
...> bank_code: "123456",
...> branch_code: nil,
...> national_check: "5",
...> account_number: "0000078"
...> }
...> |> IbanEx.Country.FI.to_string()
"FI 21 123456 0000078 5"
```
"""
@size 18

43
lib/iban_ex/country/fo.ex Normal file
View File

@@ -0,0 +1,43 @@
defmodule IbanEx.Country.FO do
@moduledoc """
Faroe Islands IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "FO",
...> check_digits: "62",
...> bank_code: "6460",
...> branch_code: nil,
...> national_check: "4",
...> account_number: "000163163"
...> }
...> |> IbanEx.Country.FO.to_string()
"FO 62 6460 000163163 4"
```
"""
@size 18
@rule ~r/^(?<bank_code>[0-9]{4})(?<account_number>[0-9]{9})(?<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

16
lib/iban_ex/country/fr.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.FR do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "FR",
...> check_digits: "14",
...> bank_code: "20041",
...> branch_code: "01005",
...> national_check: "06",
...> account_number: "0500013M026"
...> }
...> |> IbanEx.Country.FR.to_string()
"FR 14 20041 01005 0500013M026 06"
```
"""
@size 27

16
lib/iban_ex/country/gb.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.GB do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "GB",
...> check_digits: "29",
...> bank_code: "NWBK",
...> branch_code: "601613",
...> national_check: "06",
...> account_number: "31926819"
...> }
...> |> IbanEx.Country.GB.to_string()
"GB 29 NWBK 601613 31926819"
```
"""
@size 22

25
lib/iban_ex/country/ge.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.GE do
@moduledoc """
Georgia IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "GE",
...> check_digits: "29",
...> bank_code: "NB",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "0000000101904917"
...> }
...> |> IbanEx.Country.GE.to_string()
"GE 29 NB 0000000101904917"
```
"""
@size 22
@rule ~r/^(?<bank_code>[A-Z]{2})(?<account_number>[0-9]{16})$/i
use IbanEx.Country.Template
end

16
lib/iban_ex/country/gi.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.GI do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "GI",
...> check_digits: "75",
...> bank_code: "NWBK",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "000000007099453"
...> }
...> |> IbanEx.Country.GI.to_string()
"GI 75 NWBK 000000007099453"
```
"""
@size 23

25
lib/iban_ex/country/gl.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.GL do
@moduledoc """
Greenland IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "GL",
...> check_digits: "89",
...> bank_code: "6471",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "0001000206"
...> }
...> |> IbanEx.Country.GL.to_string()
"GL 89 6471 0001000206"
```
"""
@size 18
@rule ~r/^(?<bank_code>[0-9]{4})(?<account_number>[0-9]{10})$/i
use IbanEx.Country.Template
end

16
lib/iban_ex/country/gr.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.GR do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "GR",
...> check_digits: "16",
...> bank_code: "011",
...> branch_code: "0125",
...> national_check: nil,
...> account_number: "0000000012300695"
...> }
...> |> IbanEx.Country.GR.to_string()
"GR 16 011 0125 0000000012300695"
```
"""
@size 27

25
lib/iban_ex/country/gt.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.GT do
@moduledoc """
Guatemala IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "GT",
...> check_digits: "82",
...> bank_code: "TRAJ",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "01020000001210029690"
...> }
...> |> IbanEx.Country.GT.to_string()
"GT 82 TRAJ 01020000001210029690"
```
"""
@size 28
@rule ~r/^(?<bank_code>[A-Z]{4})(?<account_number>[0-9]{20})$/i
use IbanEx.Country.Template
end

16
lib/iban_ex/country/hr.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.HR do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "HR",
...> check_digits: "12",
...> bank_code: "1001005",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "1863000160"
...> }
...> |> IbanEx.Country.HR.to_string()
"HR 12 1001005 1863000160"
```
"""
@size 21

16
lib/iban_ex/country/hu.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.HU do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "HU",
...> check_digits: "42",
...> bank_code: "117",
...> branch_code: "7301",
...> national_check: "0",
...> account_number: "6111110180000000"
...> }
...> |> IbanEx.Country.HU.to_string()
"HU 42 117 7301 6111110180000000 0"
```
"""
@size 28

16
lib/iban_ex/country/ie.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.IE do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "IE",
...> check_digits: "29",
...> bank_code: "AIBK",
...> branch_code: "931152",
...> national_check: nil,
...> account_number: "12345678"
...> }
...> |> IbanEx.Country.IE.to_string()
"IE 29 AIBK 931152 12345678"
```
"""
@size 22

42
lib/iban_ex/country/il.ex Normal file
View File

@@ -0,0 +1,42 @@
defmodule IbanEx.Country.IL do
@moduledoc """
Israel IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "IL",
...> check_digits: "62",
...> bank_code: "010",
...> branch_code: "800",
...> national_check: nil,
...> account_number: "0000099999999"
...> }
...> |> IbanEx.Country.IL.to_string()
"IL 62 010 800 0000099999999"
```
"""
@size 23
@rule ~r/^(?<bank_code>[0-9]{3})(?<branch_code>[0-9]{3})(?<account_number>[0-9]{13})$/i
use 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

16
lib/iban_ex/country/it.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.IT do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "IT",
...> check_digits: "60",
...> bank_code: "05428",
...> branch_code: "11101",
...> national_check: "X",
...> account_number: "000000123456"
...> }
...> |> IbanEx.Country.IT.to_string()
"IT 60 X 05428 11101 000000123456"
```
"""
@size 27

42
lib/iban_ex/country/jo.ex Normal file
View File

@@ -0,0 +1,42 @@
defmodule IbanEx.Country.JO do
@moduledoc """
Jordan IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "JO",
...> check_digits: "94",
...> bank_code: "CBJO",
...> branch_code: "0010",
...> national_check: nil,
...> account_number: "000000000131000302"
...> }
...> |> IbanEx.Country.JO.to_string()
"JO 94 CBJO 0010 000000000131000302"
```
"""
@size 30
@rule ~r/^(?<bank_code>[A-Z0-9]{4})(?<branch_code>[0-9]{4})(?<account_number>[A-Z0-9]{18})$/i
use 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

25
lib/iban_ex/country/kw.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.KW do
@moduledoc """
Kuwait IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "KW",
...> check_digits: "81",
...> bank_code: "CBKU",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "0000000000001234560101"
...> }
...> |> IbanEx.Country.KW.to_string()
"KW 81 CBKU 0000000000001234560101"
```
"""
@size 30
@rule ~r/^(?<bank_code>[A-Z0-9]{4})(?<account_number>[0-9]{22})$/i
use IbanEx.Country.Template
end

25
lib/iban_ex/country/kz.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.KZ do
@moduledoc """
Kazakhstan IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "KZ",
...> check_digits: "86",
...> bank_code: "125",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "KZT5004100100"
...> }
...> |> IbanEx.Country.KZ.to_string()
"KZ 86 125 KZT5004100100"
```
"""
@size 20
@rule ~r/^(?<bank_code>[0-9]{3})(?<account_number>[A-Z0-9]{13})$/i
use IbanEx.Country.Template
end

25
lib/iban_ex/country/lb.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.LB do
@moduledoc """
Lebanon IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "LB",
...> check_digits: "62",
...> bank_code: "0999",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "00000001001901229114"
...> }
...> |> IbanEx.Country.LB.to_string()
"LB 62 0999 00000001001901229114"
```
"""
@size 28
@rule ~r/^(?<bank_code>[0-9]{4})(?<account_number>[0-9]{20})$/i
use IbanEx.Country.Template
end

16
lib/iban_ex/country/li.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.LI do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "LI",
...> check_digits: "21",
...> bank_code: "08810",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "0002324013AA"
...> }
...> |> IbanEx.Country.LI.to_string()
"LI 21 08810 0002324013AA"
```
"""
@size 21

16
lib/iban_ex/country/lt.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.LT do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "LT",
...> check_digits: "12",
...> bank_code: "10000",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "11101001000"
...> }
...> |> IbanEx.Country.LT.to_string()
"LT 12 10000 11101001000"
```
"""
@size 20

16
lib/iban_ex/country/lu.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.LU do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "LU",
...> check_digits: "28",
...> bank_code: "001",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "9400644750000"
...> }
...> |> IbanEx.Country.LU.to_string()
"LU 28 001 9400644750000"
```
"""
@size 20

16
lib/iban_ex/country/lv.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.LV do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "LV",
...> check_digits: "80",
...> bank_code: "BANK",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "0000435195001"
...> }
...> |> IbanEx.Country.LV.to_string()
"LV 80 BANK 0000435195001"
```
"""
@size 21

16
lib/iban_ex/country/mc.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.MC do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "MC",
...> check_digits: "58",
...> bank_code: "11222",
...> branch_code: "00001",
...> national_check: "30",
...> account_number: "01234567890"
...> }
...> |> IbanEx.Country.MC.to_string()
"MC 58 11222 00001 01234567890 30"
```
"""
@size 27

25
lib/iban_ex/country/md.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.MD do
@moduledoc """
Republic of Moldova IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "MD",
...> check_digits: "24",
...> bank_code: "AG",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "000225100013104168"
...> }
...> |> IbanEx.Country.MD.to_string()
"MD 24 AG 000225100013104168"
```
"""
@size 24
@rule ~r/^(?<bank_code>[A-Z]{2})(?<account_number>[0-9]{18})$/i
use IbanEx.Country.Template
end

43
lib/iban_ex/country/me.ex Normal file
View File

@@ -0,0 +1,43 @@
defmodule IbanEx.Country.ME do
@moduledoc """
Montenegro IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "ME",
...> check_digits: "25",
...> bank_code: "505",
...> branch_code: nil,
...> national_check: "51",
...> account_number: "0000123456789"
...> }
...> |> IbanEx.Country.ME.to_string()
"ME 25 505 0000123456789 51"
```
"""
@size 22
@rule ~r/^(?<bank_code>[0-9]{3})(?<account_number>[0-9]{13})(?<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, account_number, national_check]
|> Enum.join(joiner)
end
end

43
lib/iban_ex/country/mk.ex Normal file
View File

@@ -0,0 +1,43 @@
defmodule IbanEx.Country.MK do
@moduledoc """
Macedonia IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "MK",
...> check_digits: "07",
...> bank_code: "250",
...> branch_code: nil,
...> national_check: "84",
...> account_number: "1200000589"
...> }
...> |> IbanEx.Country.MK.to_string()
"MK 07 250 1200000589 84"
```
"""
@size 19
@rule ~r/^(?<bank_code>[0-9]{3})(?<account_number>[0-9]{10})(?<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, account_number, national_check]
|> Enum.join(joiner)
end
end

43
lib/iban_ex/country/mr.ex Normal file
View File

@@ -0,0 +1,43 @@
defmodule IbanEx.Country.MR do
@moduledoc """
Mauritania IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "MR",
...> check_digits: "13",
...> bank_code: "00020",
...> branch_code: "00101",
...> national_check: "53",
...> account_number: "00001234567"
...> }
...> |> IbanEx.Country.MR.to_string()
"MR 13 00020 00101 00001234567 53"
```
"""
@size 27
@rule ~r/^(?<bank_code>[0-9]{5})(?<branch_code>[0-9]{5})(?<account_number>[0-9]{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

16
lib/iban_ex/country/mt.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.MT do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "MT",
...> check_digits: "84",
...> bank_code: "MALT",
...> branch_code: "01100",
...> national_check: nil,
...> account_number: "0012345MTLCAST001S"
...> }
...> |> IbanEx.Country.MT.to_string()
"MT 84 MALT 01100 0012345MTLCAST001S"
```
"""
@size 31

16
lib/iban_ex/country/nl.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.NL do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "NL",
...> check_digits: "91",
...> bank_code: "ABNA",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "0417164300"
...> }
...> |> IbanEx.Country.NL.to_string()
"NL 91 ABNA 0417164300"
```
"""
@size 18

16
lib/iban_ex/country/no.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.NO do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "NO",
...> check_digits: "93",
...> bank_code: "8601",
...> branch_code: nil,
...> national_check: "7",
...> account_number: "111794"
...> }
...> |> IbanEx.Country.NO.to_string()
"NO 93 8601 111794 7"
```
"""
@size 15

25
lib/iban_ex/country/pk.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.PK do
@moduledoc """
Pakistan IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "PK",
...> check_digits: "36",
...> bank_code: "SCBL",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "0000001123456702"
...> }
...> |> IbanEx.Country.PK.to_string()
"PK 36 SCBL 0000001123456702"
```
"""
@size 24
@rule ~r/^(?<bank_code>[A-Z]{4})(?<account_number>[0-9]{16})$/i
use IbanEx.Country.Template
end

16
lib/iban_ex/country/pl.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.PL do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "PL",
...> check_digits: "61",
...> bank_code: "109",
...> branch_code: "0101",
...> national_check: "4",
...> account_number: "0000071219812874"
...> }
...> |> IbanEx.Country.PL.to_string()
"PL 61 109 0101 4 0000071219812874"
```
"""
@size 28

16
lib/iban_ex/country/pt.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.PT do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "PT",
...> check_digits: "50",
...> bank_code: "0002",
...> branch_code: "0123",
...> national_check: "54",
...> account_number: "12345678901"
...> }
...> |> IbanEx.Country.PT.to_string()
"PT 50 0002 0123 12345678901 54"
```
"""
@size 25

25
lib/iban_ex/country/qa.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.QA do
@moduledoc """
Qatar IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "QA",
...> check_digits: "58",
...> bank_code: "DOHB",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "00001234567890ABCDEFG"
...> }
...> |> IbanEx.Country.QA.to_string()
"QA 58 DOHB 00001234567890ABCDEFG"
```
"""
@size 29
@rule ~r/^(?<bank_code>[A-Z]{4})(?<account_number>[A-Z0-9]{21})$/i
use IbanEx.Country.Template
end

16
lib/iban_ex/country/ro.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.RO do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "RO",
...> check_digits: "49",
...> bank_code: "AAAA",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "1B31007593840000"
...> }
...> |> IbanEx.Country.RO.to_string()
"RO 49 AAAA 1B31007593840000"
```
"""
@size 24

43
lib/iban_ex/country/rs.ex Normal file
View File

@@ -0,0 +1,43 @@
defmodule IbanEx.Country.RS do
@moduledoc """
Serbia IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "RS",
...> check_digits: "35",
...> bank_code: "260",
...> branch_code: nil,
...> national_check: "79",
...> account_number: "0056010016113"
...> }
...> |> IbanEx.Country.RS.to_string()
"RS 35 260 0056010016113 79"
```
"""
@size 22
@rule ~r/^(?<bank_code>[0-9]{3})(?<account_number>[0-9]{13})(?<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, account_number, national_check]
|> Enum.join(joiner)
end
end

25
lib/iban_ex/country/sa.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.SA do
@moduledoc """
Saudi Arabia IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "SA",
...> check_digits: "03",
...> bank_code: "80",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "000000608010167519"
...> }
...> |> IbanEx.Country.SA.to_string()
"SA 03 80 000000608010167519"
```
"""
@size 24
@rule ~r/^(?<bank_code>[0-9]{2})(?<account_number>[0-9]{18})$/i
use IbanEx.Country.Template
end

16
lib/iban_ex/country/se.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.SE do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "SE",
...> check_digits: "45",
...> bank_code: "500",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "00000058398257466"
...> }
...> |> IbanEx.Country.SE.to_string()
"SE 45 500 00000058398257466"
```
"""
@size 24

16
lib/iban_ex/country/si.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.SI do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "SI",
...> check_digits: "56",
...> bank_code: "26",
...> branch_code: "330",
...> national_check: "86",
...> account_number: "00120390"
...> }
...> |> IbanEx.Country.SI.to_string()
"SI 56 26 330 00120390 86"
```
"""
@size 19

16
lib/iban_ex/country/sk.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.SK do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "SK",
...> check_digits: "31",
...> bank_code: "1200",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "0000198742637541"
...> }
...> |> IbanEx.Country.SK.to_string()
"SK 31 1200 0000198742637541"
```
"""
@size 24

16
lib/iban_ex/country/sm.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.SM do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "SM",
...> check_digits: "86",
...> bank_code: "03225",
...> branch_code: "09800",
...> national_check: "U",
...> account_number: "000000270100"
...> }
...> |> IbanEx.Country.SM.to_string()
"SM 86 U 03225 09800 000000270100"
```
"""
@size 27

25
lib/iban_ex/country/sv.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.SV do
@moduledoc """
El Salvador IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "SV",
...> check_digits: "62",
...> bank_code: "CENR",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "00000000000000700025"
...> }
...> |> IbanEx.Country.SV.to_string()
"SV 62 CENR 00000000000000700025"
```
"""
@size 28
@rule ~r/^(?<bank_code>[A-Z0-9]{4})(?<account_number>[0-9]{20})$/i
use IbanEx.Country.Template
end

2
lib/iban_ex/country/template.ex
View File

@@ -36,7 +36,7 @@ def to_string(
end
@impl IbanEx.Country.Template
@spec size() :: Integer.t()
@spec size() :: integer()
def size(), do: @size
@impl IbanEx.Country.Template

43
lib/iban_ex/country/tl.ex Normal file
View File

@@ -0,0 +1,43 @@
defmodule IbanEx.Country.TL do
@moduledoc """
Timor-Leste IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "TL",
...> check_digits: "38",
...> bank_code: "008",
...> branch_code: nil,
...> national_check: "57",
...> account_number: "00123456789101"
...> }
...> |> IbanEx.Country.TL.to_string()
"TL 38 008 00123456789101 57"
```
"""
@size 23
@rule ~r/^(?<bank_code>[0-9]{3})(?<account_number>[0-9]{14})(?<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, account_number, national_check]
|> Enum.join(joiner)
end
end

43
lib/iban_ex/country/tr.ex Normal file
View File

@@ -0,0 +1,43 @@
defmodule IbanEx.Country.TR do
@moduledoc """
Turkey IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "TR",
...> check_digits: "33",
...> bank_code: "00061",
...> branch_code: nil,
...> national_check: "0",
...> account_number: "0519786457841326"
...> }
...> |> IbanEx.Country.TR.to_string()
"TR 33 00061 0 0519786457841326"
```
"""
@size 26
@rule ~r/^(?<bank_code>[A-Z0-9]{5})(?<national_check>[0-9]{1})(?<account_number>[0-9]{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, national_check, account_number]
|> Enum.join(joiner)
end
end

16
lib/iban_ex/country/ua.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.UA do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "UA",
...> check_digits: "21",
...> bank_code: "322313",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "0000026007233566001"
...> }
...> |> IbanEx.Country.UA.to_string()
"UA 21 322313 0000026007233566001"
```
"""
@size 29

16
lib/iban_ex/country/va.ex
View File

@@ -4,10 +4,18 @@ defmodule IbanEx.Country.VA do
## 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"
```elixir
iex> %IbanEx.Iban{
...> country_code: "VA",
...> check_digits: "59",
...> bank_code: "001",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "123000012345678"
...> }
...> |> IbanEx.Country.VA.to_string()
"VA 59 001 123000012345678"
```
"""
@size 22

25
lib/iban_ex/country/vg.ex Normal file
View File

@@ -0,0 +1,25 @@
defmodule IbanEx.Country.VG do
@moduledoc """
British Virgin Islands IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "VG",
...> check_digits: "96",
...> bank_code: "VPVG",
...> branch_code: nil,
...> national_check: nil,
...> account_number: "0000012345678901"
...> }
...> |> IbanEx.Country.VG.to_string()
"VG 96 VPVG 0000012345678901"
```
"""
@size 24
@rule ~r/^(?<bank_code>[A-Z]{4})(?<account_number>[0-9]{16})$/i
use IbanEx.Country.Template
end

43
lib/iban_ex/country/xk.ex Normal file
View File

@@ -0,0 +1,43 @@
defmodule IbanEx.Country.XK do
@moduledoc """
Kosovo IBAN parsing rules
## Examples
```elixir
iex> %IbanEx.Iban{
...> country_code: "XK",
...> check_digits: "05",
...> bank_code: "12",
...> branch_code: "12",
...> national_check: "06",
...> account_number: "0123456789"
...> }
...> |> IbanEx.Country.XK.to_string()
"XK 05 12 12 0123456789 06"
```
"""
@size 20
@rule ~r/^(?<bank_code>[0-9]{2})(?<branch_code>[0-9]{2})(?<account_number>[0-9]{10})(?<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

39
lib/iban_ex/deserialize.ex
View File

@@ -1,14 +1,27 @@
defprotocol IbanEx.Deserialize do
@type iban_or_error() :: IbanEx.Iban.t() | {:error, :can_not_parse_map | atom()}
@type iban() :: IbanEx.Iban.t()
@type iban_or_error() ::
iban()
| {:invalid_checksum, binary()}
| {:invalid_format, binary()}
| {:invalid_length, binary()}
| {:can_not_parse_map, binary()}
| {:unsupported_country_code, binary()}
@spec to_iban(t()) :: iban_or_error()
def to_iban(value)
end
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()
@type iban() :: IbanEx.Iban.t()
@type iban_or_error() ::
iban()
| {:invalid_checksum, binary()}
| {:invalid_format, binary()}
| {:invalid_length, binary()}
| {:can_not_parse_map, binary()}
| {:unsupported_country_code, binary()}
def to_iban(string) do
case Parser.parse(string) do
{:ok, iban} -> iban
@@ -18,10 +31,17 @@ def to_iban(string) do
end
defimpl IbanEx.Deserialize, for: Map do
alias IbanEx.Iban
@type iban_or_error() :: IbanEx.Iban.t() | {:error, :can_not_parse_map}
alias IbanEx.{Iban, Error}
@type iban() :: IbanEx.Iban.t()
@type iban_or_error() ::
iban()
| {:invalid_checksum, binary()}
| {:invalid_format, binary()}
| {:invalid_length, binary()}
| {:can_not_parse_map, binary()}
| {:unsupported_country_code, binary()}
@spec to_iban(map()) :: iban_or_error()
def to_iban(
%{
country_code: _country_code,
@@ -49,13 +69,10 @@ def to_iban(
to_iban(atomized_map)
end
def to_iban(map) when is_map(map), do: {:error, :can_not_parse_map}
def to_iban(map) when is_map(map), do: {:can_not_parse_map, Error.message(: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

13
lib/iban_ex/parser.ex
View File

@@ -7,11 +7,20 @@ defmodule IbanEx.Parser do
@type iban_string() :: String.t()
@type country_code_string() :: <<_::16>>
@type check_digits_string() :: <<_::16>>
@type iban_or_error() :: IbanEx.Iban.t() | {:error, atom()}
@spec parse({:ok, String.t()} | String.t()) :: iban_or_error()
@type iban() :: IbanEx.Iban.t()
@type iban_or_error() ::
{:ok, iban()}
| {:invalid_checksum, binary()}
| {:invalid_format, binary()}
| {:invalid_length, binary()}
| {:can_not_parse_map, binary()}
| {:unsupported_country_code, binary()}
@spec parse({:ok, binary()}) :: iban_or_error()
def parse({:ok, iban_string}), do: parse(iban_string)
@spec parse(binary()) :: iban_or_error()
def parse(iban_string) do
case Validator.validate(iban_string) do
{:ok, valid_iban} ->

2
lib/iban_ex/serialize.ex
View File

@@ -6,6 +6,6 @@ defmodule IbanEx.Serialize do
@spec to_string(Iban.t()) :: String.t()
def to_string(iban), do: Formatter.format(iban)
@spec to_map(Iban.t()) :: Map.t()
@spec to_map(Iban.t()) :: map()
def to_map(iban), do: Map.from_struct(iban)
end

42
lib/iban_ex/validator/validator.ex
View File

@@ -14,7 +14,7 @@ defp violation_functions(),
{&__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_country_rule?/1, {:error, :invalid_format_for_country}},
{&__MODULE__.iban_violates_checksum?/1, {:error, :invalid_checksum}}
]
@@ -39,13 +39,21 @@ def violations(iban) do
iban_violates_checksum?
"""
@spec validate(String.t()) :: {:ok, String.t()} | {:error, Atom.t()}
@type iban() :: binary()
@type iban_or_error() ::
{:ok, iban()}
| {:invalid_checksum, binary()}
| {:invalid_format, binary()}
| {:invalid_length, binary()}
| {:unsupported_country_code, binary()}
@spec validate(String.t()) :: {:ok, String.t()} | {:error, atom()}
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_country_rule?(iban) -> {:error, :invalid_format_for_country}
iban_violates_checksum?(iban) -> {:error, :invalid_checksum}
true -> {:ok, normalize(iban)}
end
@@ -86,21 +94,23 @@ def iban_violates_length?(iban) do
end
@doc "Check length of IBAN"
@spec check_iban_length(String.t()) :: {:error, :length_to_short | :length_to_long } | :ok
@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 iban_unsupported_country?(iban) do
true ->
{:error, :unsupported_country_code}
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}
false ->
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
end
end