Partial IBAN parser added

lib/iban_ex/country/template.ex

@@ -9,7 +9,10 @@ defmodule IbanEx.Country.Template do
 
   @callback size() :: size()
   @callback rule() :: rule()
-  @callback incomplete_rule() :: rule()
+  @callback rules() :: []
+  @callback rules_map() :: %{}
+  @callback bban_fields() :: [atom()]
+  @callback bban_size() :: non_neg_integer()
   @callback to_string(Iban.t(), joiner()) :: String.t()
   @callback to_string(Iban.t()) :: String.t()
 
@@ -47,26 +50,50 @@ defmodule IbanEx.Country.Template do
       @spec rule() :: Regex.t()
       def rule(), do: @rule
 
-      @doc """
-      Return Regex without trailing “$” for parsing incomplete BBAN (part of IBAN string) (for partial suggestions)
-      """
       @impl IbanEx.Country.Template
-      @spec incomplete_rule() :: Regex.t()
+      @spec bban_size() :: integer()
-      def incomplete_rule() do
+      def bban_size() do
+        {_rules, bban_size} = calculate_rules()
+        bban_size
+      end
+
+      @impl IbanEx.Country.Template
+      @spec bban_fields() :: []
+      def bban_fields(), do: rules_map() |> Map.keys()
+
+      @impl IbanEx.Country.Template
+      @spec rules_map() :: %{}
+      def rules_map(), do: rules() |> Map.new()
+
+      @impl IbanEx.Country.Template
+      @spec rules() :: []
+      def rules() do
+        {rules, _bban_size} = calculate_rules()
+        rules
+      end
+
+      defp calculate_rules() do
+        scanner = ~r/\(\?\<([\w_]+)\>(([^{]+)\{(\d+)\})\)/i
+
         source =
           @rule
           |> Regex.source()
-          |> String.slice(0..-2//1)
-          |> String.replace("{", "{0,")
 
-        opts =
+        {list, bban_length} =
-          @rule
+          Regex.scan(scanner, source)
-          |> Regex.opts()
+          |> Enum.reduce({[], 0}, fn [_part, k, r, _syms, l], {list, position} = acc ->
+            key = String.to_atom(k)
+            {:ok, regex} = Regex.compile(r, "i")
+            length = String.to_integer(l)
+            left = position
+            right = left + length - 1
+            {[{key, %{regex: regex, range: left..right}} | list], right + 1}
+          end)
 
-        Regex.compile!(source, opts)
+        {Enum.reverse(list), bban_length}
       end
 
-      defoverridable to_string: 1, to_string: 2, size: 0, rule: 0, incomplete_rule: 0
+      defoverridable to_string: 1, to_string: 2, size: 0, rule: 0
     end
   end
 end

lib/iban_ex/parser.ex

@@ -20,8 +20,9 @@ defmodule IbanEx.Parser do
   @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, options \\ [incomplete: false])
-  def parse(iban_string) do
+
+  def parse(iban_string, incomplete: false) do
     case Validator.validate(iban_string) do
       {:ok, valid_iban} ->
         iban_map = %{
@@ -41,14 +42,35 @@ defmodule IbanEx.Parser do
     end
   end
 
+  def parse(iban_string, incomplete: true) do
+    iban_map = %{
+      country_code: country_code(iban_string),
+      check_digits: check_digits(iban_string)
+    }
+
+    bban = bban(iban_string)
+
+    case Country.is_country_code_supported?(iban_map.country_code) do
+      true ->
+        result =
+          parse_bban(bban, iban_map.country_code, incomplete: true)
+          |> Map.merge(iban_map)
+
+        {:ok, struct(Iban, result)}
+
+      false ->
+        {:error, :unsupported_country_code}
+    end
+  end
+
   @spec parse_bban(binary(), <<_::16>>) :: map()
   def parse_bban(bban_string, country_code, options \\ [incomplete: false])
 
   def parse_bban(bban_string, country_code, incomplete: true) do
     case Country.is_country_code_supported?(country_code) do
       true ->
-        Country.country_module(country_code).incomplete_rule()
+        parse_bban_by_rules(bban_string, Country.country_module(country_code))
-        |> parse_bban_by_regex(bban_string)
+
       false ->
         %{}
     end
@@ -59,12 +81,20 @@ defmodule IbanEx.Parser do
       true ->
         Country.country_module(country_code).rule()
         |> parse_bban_by_regex(bban_string)
+
       false ->
         %{}
     end
   end
 
+  defp parse_bban_by_rules(bban_string, country_module) do
+    for {field, rule} <- country_module.rules,
+        into: %{},
+        do: {field, normalize_and_slice(bban_string, rule.range)}
+  end
+
   defp parse_bban_by_regex(_regex, nil), do: %{}
+
   defp parse_bban_by_regex(regex, bban_string) do
     case Regex.named_captures(regex, bban_string) do
       map when is_map(map) ->