iban-tools

codegen_rs.py (5477B)

---

 #!/usr/bin/env python3
 
 import json
 
 with open("registry.json", "r") as json_file:
     registry = json.load(json_file)
 
 rust = """/*
   This file is part of TALER
   Copyright (C) 2025 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free Software
   Foundation; either version 3, or (at your option) any later version.
 
   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.
 
   You should have received a copy of the GNU Affero General Public License along with
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 
 use std::fmt::Display;
 
 use IbanC::*;
 use Country::*;
 
 /// IBAN ASCII characters rules
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum IbanC {
     /// Digits (0-9)
     N,
     /// Uppercase (A-Z)
     A,
     /// Digits or uppercase (0-9 & A-Z)
     C,
 }
 
 impl IbanC {
     /// Check if a valid IBAN slice follow a specific characters rules
     pub fn check(self, iban_ascii: &[u8]) -> bool {
         // IBAN are made of ASCII digits and uppercase
         debug_assert!(iban_ascii
             .iter()
             .all(|b| b.is_ascii_uppercase() || b.is_ascii_digit()));
         // As all characters are ASCII digits or uppercase
         // we can use simple masks to check the character kind
         const MASK_IS_UPPERCASE: u8 = 0b0100_0000;
         const MASK_IS_DIGIT: u8 = 0b0010_0000;
 
         let mask = match self {
             Self::N => MASK_IS_UPPERCASE,
             Self::A => MASK_IS_DIGIT,
             Self::C => return true,
         };
         iban_ascii.iter().all(|b| (*b & mask) == 0)
     }
 }
 
 /// An IBAN pattern, an array of characters rules over a number of character
 pub type Pattern = &'static [(u8, IbanC)];
 
 #[derive(Debug)]
 pub enum PatternErr {
     Len(u8, usize),
     Malformed,
 }
 """
 
 
 def gen_match(name, return_type, match):
     global rust
     rust += f"pub const fn {name}(self) -> {return_type} {{\nmatch self {{\n"
     for r in registry:
         rust += f"{r['code']} => {match(r)},\n"
     rust += "}\n}\n\n"
 
 
 def gen_range(name):
     def fmt_range(r):
         (start, end) = r[name + "_range"] or [0, 0]
         return f"{start}..{end}"
 
     gen_match(f"{name}_id", "core::ops::Range<usize>", fmt_range)
 
 
 def gen_pattern(name):
     def fmt_pattern(r):
         pattern = r[name + "_rules"] or []
         fmt = "&["
         for repetition, char in pattern:
             fmt += f"({repetition}, {char.upper()}),"
         return fmt + "]"
 
     gen_match(f"{name}_pattern", "Pattern", fmt_pattern)
 
 
 rust += "#[derive(Debug, Clone, Copy, PartialEq, Eq)]\n"
 rust += "pub enum Country {\n"
 for r in registry:
     rust += f"    {r['code']},\n"
 rust += "}\n\n"
 rust += "impl Country {\n"
 rust += "pub fn from_str(country: &str) -> Option<Self> {\n"
 rust += "    match country {\n"
 for r in registry:
     rust += f'"{r["code"]}" => Some({r["code"]}),\n'
 rust += "        _ => None,\n"
 rust += "    }\n"
 rust += "}\n\n"
 gen_match("as_str", "&'static str", lambda r: f'"{r["code"]}"')
 gen_match("as_bytes", "&'static [u8; 2]", lambda r: f'b"{r["code"]}"')
 gen_match("iban_len", "usize", lambda r: f"{r['iban_len']}")
 rust += "pub const fn bban_len(self) -> usize {\n"
 rust += "    self.iban_len() - 4\n"
 rust += "}\n\n"
 gen_range("bank")
 gen_range("branch")
 gen_pattern("bban")
 gen_pattern("bank")
 gen_pattern("branch")
 rust += "}\n\n"
 
 rust += """
 impl Display for Country {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str(self.as_str())
     }
 }
 
 /// Generate random ASCII string following an IBAN pattern rules
 pub fn rng_pattern(out: &mut [u8], pattern: Pattern) {
     let mut cursor = 0;
     for (len, rule) in pattern {
         let alphabet = match rule {
             IbanC::C => "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
             IbanC::N => "0123456789",
             IbanC::A => "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
         };
         for b in &mut out[cursor..cursor + *len as usize] {
             *b = *fastrand::choice(alphabet.as_bytes()).unwrap();
         }
         cursor += *len as usize
     }
 }
 
 /// Valid an IBAN slice against a pattern
 pub fn check_pattern(iban_ascii: &[u8], pattern: Pattern) -> Result<(), PatternErr> {
     // IBAN are made of ASCII digits and uppercase
     debug_assert!(iban_ascii.iter().all(|b| b.is_ascii_uppercase() || b.is_ascii_digit()));
     let pattern_len: u8 = pattern.iter().map(|(len, _)| *len as u8).sum();
     if iban_ascii.len() != pattern_len as usize {
         return Err(PatternErr::Len(pattern_len, iban_ascii.len()));
     }
     let mut cursor = 0;
     for (repetition, char) in pattern {
         if !char.check(&iban_ascii[cursor..cursor + *repetition as usize]) {
             return Err(PatternErr::Malformed);
         }
         cursor += *repetition as usize;
     }
     Ok(())
 }
 
 """
 rust += "#[cfg(test)]\n"
 rust += f"pub const VALID_IBAN: [(&str, Option<&str>); {len(registry)}] = [\n"
 for r in registry:
     rust += f'("{r["iban_example"]}", '
     bban = r["bban_example"]
     if bban is None:
         rust += "None"
     else:
         bban = "".join(filter(str.isalnum, bban))
         rust += f'Some("{bban}")'
     rust += "),\n"
 rust += "]\n;"
 
 with open("registry.rs", "w") as rs_file:
     rs_file.write(rust)