use crate::checksum::{
aggressive_defiller, char_value, defiller, digitize, fix_doc_code, fix_name_separator,
is_mrz_charset, letterize, line1_variants, normalize_line, repair_positions, variants, verify,
};
use crate::repair::{solve_class_sweep, FieldKind, Resolution};
use crate::{
country_name, passport_type, Checks, DateRole, Format, MrzData, MrzDate, MrzError,
ParseOptions, RawDateField, Sex,
};
struct Overflow {
full: String,
check_ok: bool,
legacy: bool,
consumed: usize,
}
fn read_overflow(number_field: &str, check: char, optional: &str) -> Option<Overflow> {
if check != '<' {
return None;
}
if number_field.trim_end_matches('<').is_empty() {
return None;
}
let end = optional.find('<')?;
if end < 2 {
return None; }
let (remainder, check_digit) = optional[..end].split_at(end - 1);
let check_digit = check_digit.chars().next()?;
if !check_digit.is_ascii_digit() {
return None;
}
let consumed = end + 1;
let spec_full = format!("{number_field}{remainder}");
if verify(&spec_full, check_digit) {
return Some(Overflow {
full: spec_full,
check_ok: true,
legacy: false,
consumed,
});
}
if number_field.ends_with('<') {
let head = number_field[0..8].trim_end_matches('<');
let legacy_full = format!("{head}{remainder}");
if verify(&legacy_full, check_digit) {
return Some(Overflow {
full: legacy_full,
check_ok: true,
legacy: true,
consumed,
});
}
}
Some(Overflow {
full: spec_full,
check_ok: false,
legacy: false,
consumed,
})
}
fn optional_tail<'a>(optional: &'a str, overflow: &Option<Overflow>) -> &'a str {
match overflow {
Some(o) => optional[o.consumed..].trim_end_matches('<'),
None => optional.trim_end_matches('<'),
}
}
fn opt_string(s: &str) -> Option<String> {
(!s.is_empty()).then(|| s.to_string())
}
fn clean_name(field: &str) -> (String, String) {
let trimmed = field.trim_end_matches('<');
let (surname, given) = match trimmed.split_once("<<") {
Some((s, g)) => (s, g),
None => match trimmed.split_once('<') {
Some((s, g)) => (s, g),
None => (trimmed, ""),
},
};
(
surname.replace('<', " ").trim().to_string(),
given.replace('<', " ").trim().to_string(),
)
}
fn ensure_charset(line: &str, line_number: usize) -> Result<(), MrzError> {
for (position, c) in line.chars().enumerate() {
if char_value(c).is_none() {
return Err(MrzError::BadCharacter {
character: c,
line: Some(line_number),
position,
});
}
}
Ok(())
}
fn ensure_document_number_leads(field: &str, line: usize, position: usize) -> Result<(), MrzError> {
if field.starts_with('<') {
return Err(MrzError::LeadingFiller {
field: crate::Field::DocumentNumber,
line,
position,
});
}
Ok(())
}
fn date_field(
line: &str,
line_number: usize,
start: usize,
role: DateRole,
pivot_yy: u32,
) -> Result<MrzDate, MrzError> {
let text = line
.get(start..start + 6)
.unwrap_or_else(|| line.get(start..).unwrap_or(""));
match RawDateField::try_from(text) {
Ok(field) => Ok(MrzDate::from_field(field, role, pivot_yy)),
Err(_) => {
let (offset, character) = text
.chars()
.enumerate()
.find(|&(_, c)| char_value(c).is_none())
.unwrap_or_else(|| (0, text.chars().next().unwrap_or('<')));
Err(MrzError::BadCharacter {
character,
line: Some(line_number),
position: start + offset,
})
}
}
}
pub fn parse_td3(line1: &str, line2: &str) -> Result<MrzData, MrzError> {
parse_td3_with(line1, line2, &ParseOptions::default())
}
pub fn parse_td3_with(line1: &str, line2: &str, opts: &ParseOptions) -> Result<MrzData, MrzError> {
for (line_number, line) in [line1, line2].into_iter().enumerate() {
let got = line.chars().count();
if got != 44 {
return Err(MrzError::BadLength { expected: 44, got });
}
ensure_charset(line, line_number)?;
}
if !line1.starts_with('P') {
return Err(MrzError::BadDocumentCode(line1[0..2].to_string()));
}
ensure_document_number_leads(&line2[0..9], 1, 0)?;
let (surname, given_names) = clean_name(&line1[5..44]);
let document_number = line2[0..9].trim_end_matches('<').to_string();
let personal_raw = &line2[28..42];
let overflow = read_overflow(&line2[0..9], line2.as_bytes()[9] as char, personal_raw);
let personal = optional_tail(personal_raw, &overflow);
let checks = Checks::from_verifications(
Format::Td3,
[
match &overflow {
Some(o) => o.check_ok,
None => verify(&line2[0..9], line2.as_bytes()[9] as char),
},
verify(&line2[13..19], line2.as_bytes()[19] as char),
verify(&line2[21..27], line2.as_bytes()[27] as char),
verify(personal_raw, line2.as_bytes()[42] as char),
verify(
&format!("{}{}{}", &line2[0..10], &line2[13..20], &line2[21..43]),
line2.as_bytes()[43] as char,
),
],
);
let document_number_legacy_encoding = overflow.as_ref().is_some_and(|o| o.legacy);
Ok(MrzData {
format: Format::Td3,
document_type: line1[0..2].trim_end_matches('<').to_string(),
issuing_country: line1[2..5].trim_end_matches('<').to_string(),
document_number,
document_number_full: overflow.map(|o| o.full),
document_number_legacy_encoding,
surname,
given_names,
nationality: line2[10..13].trim_end_matches('<').to_string(),
date_of_birth: date_field(line2, 1, 13, DateRole::Birth, opts.pivot_yy)?,
sex: Sex::from_zone(line2.as_bytes()[20] as char),
date_of_expiry: date_field(line2, 1, 21, DateRole::Expiry, opts.pivot_yy)?,
optional_data_1: opt_string(personal),
optional_data_2: None,
mrz_lines: format!("{line1}\n{line2}"),
checks,
damaged_recovery: false,
})
}
pub fn parse_td2(line1: &str, line2: &str) -> Result<MrzData, MrzError> {
parse_td2_with(line1, line2, &ParseOptions::default())
}
pub fn parse_td2_with(line1: &str, line2: &str, opts: &ParseOptions) -> Result<MrzData, MrzError> {
for (line_number, line) in [line1, line2].into_iter().enumerate() {
let got = line.chars().count();
if got != 36 {
return Err(MrzError::BadLength { expected: 36, got });
}
ensure_charset(line, line_number)?;
}
let code = line1[0..2].trim_end_matches('<');
if !matches!(code.as_bytes().first(), Some(b'I' | b'A' | b'C')) {
return Err(MrzError::BadDocumentCode(line1[0..2].to_string()));
}
ensure_document_number_leads(&line2[0..9], 1, 0)?;
let (surname, given_names) = clean_name(&line1[5..36]);
let document_number = line2[0..9].trim_end_matches('<').to_string();
let optional_raw = &line2[28..35];
let overflow = read_overflow(&line2[0..9], line2.as_bytes()[9] as char, optional_raw);
let optional = optional_tail(optional_raw, &overflow);
let checks = Checks::from_verifications(
Format::Td2,
[
match &overflow {
Some(o) => o.check_ok,
None => verify(&line2[0..9], line2.as_bytes()[9] as char),
},
verify(&line2[13..19], line2.as_bytes()[19] as char),
verify(&line2[21..27], line2.as_bytes()[27] as char),
false,
verify(
&format!("{}{}{}", &line2[0..10], &line2[13..20], &line2[21..35]),
line2.as_bytes()[35] as char,
),
],
);
let document_number_legacy_encoding = overflow.as_ref().is_some_and(|o| o.legacy);
Ok(MrzData {
format: Format::Td2,
document_type: code.to_string(),
issuing_country: line1[2..5].trim_end_matches('<').to_string(),
document_number,
document_number_full: overflow.map(|o| o.full),
document_number_legacy_encoding,
surname,
given_names,
nationality: line2[10..13].trim_end_matches('<').to_string(),
date_of_birth: date_field(line2, 1, 13, DateRole::Birth, opts.pivot_yy)?,
sex: Sex::from_zone(line2.as_bytes()[20] as char),
date_of_expiry: date_field(line2, 1, 21, DateRole::Expiry, opts.pivot_yy)?,
optional_data_1: opt_string(optional),
optional_data_2: None,
mrz_lines: format!("{line1}\n{line2}"),
checks,
damaged_recovery: false,
})
}
pub fn parse_td1(line1: &str, line2: &str, line3: &str) -> Result<MrzData, MrzError> {
parse_td1_with(line1, line2, line3, &ParseOptions::default())
}
pub fn parse_td1_with(
line1: &str,
line2: &str,
line3: &str,
opts: &ParseOptions,
) -> Result<MrzData, MrzError> {
for (line_number, line) in [line1, line2, line3].into_iter().enumerate() {
let got = line.chars().count();
if got != 30 {
return Err(MrzError::BadLength { expected: 30, got });
}
ensure_charset(line, line_number)?;
}
let code = line1[0..2].trim_end_matches('<');
if !matches!(code.as_bytes().first(), Some(b'I' | b'A' | b'C')) {
return Err(MrzError::BadDocumentCode(line1[0..2].to_string()));
}
ensure_document_number_leads(&line1[5..14], 0, 5)?;
let (surname, given_names) = clean_name(line3);
let optional1_raw = &line1[15..30];
let overflow = read_overflow(&line1[5..14], line1.as_bytes()[14] as char, optional1_raw);
let optional1 = optional_tail(optional1_raw, &overflow);
let optional2 = line2[18..29].trim_end_matches('<');
let checks = Checks::from_verifications(
Format::Td1,
[
match &overflow {
Some(o) => o.check_ok,
None => verify(&line1[5..14], line1.as_bytes()[14] as char),
},
verify(&line2[0..6], line2.as_bytes()[6] as char),
verify(&line2[8..14], line2.as_bytes()[14] as char),
false,
verify(
&format!(
"{}{}{}{}",
&line1[5..30],
&line2[0..7],
&line2[8..15],
&line2[18..29]
),
line2.as_bytes()[29] as char,
),
],
);
let document_number_legacy_encoding = overflow.as_ref().is_some_and(|o| o.legacy);
Ok(MrzData {
format: Format::Td1,
document_type: code.to_string(),
issuing_country: line1[2..5].trim_end_matches('<').to_string(),
document_number: line1[5..14].trim_end_matches('<').to_string(),
document_number_full: overflow.map(|o| o.full),
document_number_legacy_encoding,
surname,
given_names,
nationality: line2[15..18].trim_end_matches('<').to_string(),
date_of_birth: date_field(line2, 1, 0, DateRole::Birth, opts.pivot_yy)?,
sex: Sex::from_zone(line2.as_bytes()[7] as char),
date_of_expiry: date_field(line2, 1, 8, DateRole::Expiry, opts.pivot_yy)?,
optional_data_1: opt_string(optional1),
optional_data_2: opt_string(optional2),
mrz_lines: format!("{line1}\n{line2}\n{line3}"),
checks,
damaged_recovery: false,
})
}
pub fn parse_mrv_a(line1: &str, line2: &str) -> Result<MrzData, MrzError> {
parse_mrv_a_with(line1, line2, &ParseOptions::default())
}
pub fn parse_mrv_a_with(
line1: &str,
line2: &str,
opts: &ParseOptions,
) -> Result<MrzData, MrzError> {
for (line_number, line) in [line1, line2].into_iter().enumerate() {
let got = line.chars().count();
if got != 44 {
return Err(MrzError::BadLength { expected: 44, got });
}
ensure_charset(line, line_number)?;
}
if !line1.starts_with('V') {
return Err(MrzError::BadDocumentCode(line1[0..2].to_string()));
}
ensure_document_number_leads(&line2[0..9], 1, 0)?;
let (surname, given_names) = clean_name(&line1[5..44]);
let document_number = line2[0..9].trim_end_matches('<').to_string();
let optional = line2[28..44].trim_end_matches('<');
let checks = Checks::from_verifications(
Format::MrvA,
[
verify(&line2[0..9], line2.as_bytes()[9] as char),
verify(&line2[13..19], line2.as_bytes()[19] as char),
verify(&line2[21..27], line2.as_bytes()[27] as char),
false,
false,
],
);
Ok(MrzData {
format: Format::MrvA,
document_type: line1[0..2].trim_end_matches('<').to_string(),
issuing_country: line1[2..5].trim_end_matches('<').to_string(),
document_number,
document_number_full: None,
document_number_legacy_encoding: false,
surname,
given_names,
nationality: line2[10..13].trim_end_matches('<').to_string(),
date_of_birth: date_field(line2, 1, 13, DateRole::Birth, opts.pivot_yy)?,
sex: Sex::from_zone(line2.as_bytes()[20] as char),
date_of_expiry: date_field(line2, 1, 21, DateRole::Expiry, opts.pivot_yy)?,
optional_data_1: opt_string(optional),
optional_data_2: None,
mrz_lines: format!("{line1}\n{line2}"),
checks,
damaged_recovery: false,
})
}
pub fn parse_mrv_b(line1: &str, line2: &str) -> Result<MrzData, MrzError> {
parse_mrv_b_with(line1, line2, &ParseOptions::default())
}
pub fn parse_mrv_b_with(
line1: &str,
line2: &str,
opts: &ParseOptions,
) -> Result<MrzData, MrzError> {
for (line_number, line) in [line1, line2].into_iter().enumerate() {
let got = line.chars().count();
if got != 36 {
return Err(MrzError::BadLength { expected: 36, got });
}
ensure_charset(line, line_number)?;
}
if !line1.starts_with('V') {
return Err(MrzError::BadDocumentCode(line1[0..2].to_string()));
}
ensure_document_number_leads(&line2[0..9], 1, 0)?;
let (surname, given_names) = clean_name(&line1[5..36]);
let document_number = line2[0..9].trim_end_matches('<').to_string();
let optional = line2[28..36].trim_end_matches('<');
let checks = Checks::from_verifications(
Format::MrvB,
[
verify(&line2[0..9], line2.as_bytes()[9] as char),
verify(&line2[13..19], line2.as_bytes()[19] as char),
verify(&line2[21..27], line2.as_bytes()[27] as char),
false,
false,
],
);
Ok(MrzData {
format: Format::MrvB,
document_type: line1[0..2].trim_end_matches('<').to_string(),
issuing_country: line1[2..5].trim_end_matches('<').to_string(),
document_number,
document_number_full: None,
document_number_legacy_encoding: false,
surname,
given_names,
nationality: line2[10..13].trim_end_matches('<').to_string(),
date_of_birth: date_field(line2, 1, 13, DateRole::Birth, opts.pivot_yy)?,
sex: Sex::from_zone(line2.as_bytes()[20] as char),
date_of_expiry: date_field(line2, 1, 21, DateRole::Expiry, opts.pivot_yy)?,
optional_data_1: opt_string(optional),
optional_data_2: None,
mrz_lines: format!("{line1}\n{line2}"),
checks,
damaged_recovery: false,
})
}
fn unshift_line1_prefix(repaired: String, target_width: usize) -> String {
if repaired.len() != target_width || repaired.as_bytes().get(1) == Some(&b'<') {
return repaired;
}
format!("{}<{}", &repaired[0..1], &repaired[1..target_width - 1])
}
pub(crate) fn country_resolves(slice: &str) -> bool {
country_name(slice.trim_end_matches('<')).is_some()
}
fn looks_like_non_mrz_text(data: &MrzData) -> bool {
!country_resolves(&data.issuing_country)
&& !country_resolves(&data.nationality)
&& matches!(data.date_of_birth, MrzDate::Malformed(_))
}
fn shift_line1_right_at_country(repaired: String, target_width: usize) -> String {
if repaired.len() != target_width
|| target_width < 6
|| repaired.as_bytes().get(1) != Some(&b'<')
{
return repaired;
}
if country_resolves(&repaired[2..5]) {
return repaired;
}
if !country_resolves(&repaired[3..6]) {
return repaired;
}
format!("{}{}<", &repaired[0..2], &repaired[3..target_width])
}
fn shift_or_unshift_line1(repaired: String, target_width: usize) -> String {
let shifted = shift_line1_right_at_country(repaired.clone(), target_width);
if shifted != repaired {
return shifted;
}
unshift_if_country_resolves(repaired, target_width)
}
fn unshift_if_country_resolves(repaired: String, target_width: usize) -> String {
let unshifted = unshift_line1_prefix(repaired.clone(), target_width);
if unshifted != repaired && target_width >= 5 && country_resolves(&unshifted[2..5]) {
unshifted
} else {
repaired
}
}
fn repair_td3_line1(l: &str) -> String {
let l = fix_doc_code(&repair_positions(l, &[(2..5, letterize)]));
format!("{}{}", &l[0..5], fix_name_separator(&defiller(&l[5..])))
}
fn td3_line1_is_genuine_table_code(l: &str) -> bool {
l.len() >= 5
&& (&l[0..2] == "P<" || crate::passport_type(&l[0..2]).is_some())
&& country_resolves(&l[2..5])
}
fn repair_td3_line1_shifted(l: &str) -> String {
let target_width = l.len();
let repaired = repair_td3_line1(l);
if td3_line1_is_genuine_table_code(&repaired) {
return repaired;
}
shift_or_unshift_line1(repaired, target_width)
}
#[derive(Debug, PartialEq, Eq)]
enum Td3Prefix {
Keep,
Repair(String),
Ambiguous,
}
fn td3_line1_admissible(line1: &str) -> bool {
if line1.len() != 44 {
return false;
}
let doc_code = &line1[0..2];
if doc_code != "P<" && passport_type(doc_code).is_none() {
return false;
}
let Some(issuer) = line1.get(2..5) else {
return false;
};
let issuer: String = issuer.chars().map(letterize).collect();
country_resolves(&issuer)
}
fn td3_prefix_verdict(line: &str) -> Td3Prefix {
const TD3_LINE1_LEN: usize = 44;
if line.len() != TD3_LINE1_LEN + 1 || !line.starts_with('P') || !is_mrz_charset(line) {
return Td3Prefix::Keep;
}
let as_read: String = line[2..5].chars().map(letterize).collect();
if country_resolves(&as_read) {
return Td3Prefix::Keep;
}
let mut resolved: Vec<String> = Vec::new();
for cell in 2..=4 {
let mut candidate = String::with_capacity(TD3_LINE1_LEN);
candidate.push_str(&line[..cell]);
candidate.push_str(&line[cell + 1..]);
if td3_line1_admissible(&candidate) && !resolved.contains(&candidate) {
resolved.push(candidate);
}
}
match resolved.len() {
1 => Td3Prefix::Repair(repair_td3_line1(&resolved.remove(0))),
0 => Td3Prefix::Keep,
_ => Td3Prefix::Ambiguous,
}
}
fn td3_line1_variants(
raw: &str,
width: usize,
prefixes: &[u8],
rep1: fn(&str) -> String,
) -> Vec<String> {
if width != 44 || prefixes != b"P" {
return two_line_line1_variants_shifted(raw, width, prefixes, rep1);
}
match td3_prefix_verdict(&fix_doc_code(&normalize_line(raw))) {
Td3Prefix::Ambiguous => Vec::new(),
Td3Prefix::Repair(fixed) => vec![fixed],
Td3Prefix::Keep => {
let candidates: Vec<String> = line1_variants(raw, width, repair_td3_line1_shifted)
.into_iter()
.chain(line1_variants(raw, width, rep1))
.collect();
if candidates.iter().any(|c| td3_line1_admissible(c)) {
candidates
.into_iter()
.filter(|c| td3_line1_admissible(c))
.collect()
} else {
candidates
}
}
}
}
fn line1_admissible(line1: &str, width: usize, prefixes: &[u8]) -> bool {
if line1.len() != width || !line1.bytes().next().is_some_and(|c| prefixes.contains(&c)) {
return false;
}
let issuer: String = line1[2..5].chars().map(letterize).collect();
country_resolves(&issuer)
}
fn prefer_admissible_line1(candidates: Vec<String>, width: usize, prefixes: &[u8]) -> Vec<String> {
if candidates
.iter()
.any(|c| line1_admissible(c, width, prefixes))
{
candidates
.into_iter()
.filter(|c| line1_admissible(c, width, prefixes))
.collect()
} else {
candidates
}
}
fn two_line_line1_variants_shifted(
raw: &str,
width: usize,
prefixes: &[u8],
rep1: fn(&str) -> String,
) -> Vec<String> {
let shifted: fn(&str) -> String = match (width, prefixes) {
(44, b"V") => repair_mrv_a_line1_shifted,
(36, b"V") => repair_mrv_b_line1_shifted,
(36, b"IAC") => repair_td2_line1_shifted,
_ => return line1_variants(raw, width, rep1),
};
let candidates: Vec<String> = line1_variants(raw, width, shifted)
.into_iter()
.chain(line1_variants(raw, width, rep1))
.collect();
prefer_admissible_line1(candidates, width, prefixes)
}
fn repair_td3_line2(l: &str) -> String {
let l = repair_positions(
l,
&[
(9..10, digitize), (10..13, letterize), (13..20, digitize), (21..28, digitize), (42..44, digitize), ],
);
format!(
"{}{}{}",
&l[0..28],
aggressive_defiller(&defiller(&l[28..42])),
&l[42..44]
)
}
fn repair_td2_line1(l: &str) -> String {
let l = fix_doc_code(&repair_positions(l, &[(2..5, letterize)]));
format!("{}{}", &l[0..5], fix_name_separator(&defiller(&l[5..])))
}
fn repair_td2_line1_shifted(l: &str) -> String {
let target_width = l.len();
unshift_if_country_resolves(repair_td2_line1(l), target_width)
}
fn repair_td2_line2(l: &str) -> String {
let l = repair_positions(
l,
&[
(9..10, digitize), (10..13, letterize), (13..20, digitize), (21..28, digitize), (35..36, digitize), ],
);
format!(
"{}{}{}",
&l[0..28],
aggressive_defiller(&defiller(&l[28..35])),
&l[35..36]
)
}
fn repair_td1_line1(l: &str) -> String {
let l = fix_doc_code(&repair_positions(
l,
&[(2..5, letterize), (14..15, digitize)],
));
format!("{}{}", &l[0..15], aggressive_defiller(&defiller(&l[15..])))
}
fn repair_td1_line1_unshifted(l: &str) -> String {
let repaired = repair_td1_line1(l);
if repaired.len() != 30 || repaired.as_bytes().get(1) == Some(&b'<') {
return repaired;
}
format!("{}<{}", &repaired[0..1], &repaired[1..29])
}
fn td1_line1_variants(raw: &str) -> Vec<String> {
let candidates: Vec<String> = variants(raw, 30, repair_td1_line1)
.into_iter()
.chain(variants(raw, 30, repair_td1_line1_unshifted))
.collect();
prefer_admissible_line1(candidates, 30, b"IAC")
}
fn td1_line1_searched(search: impl Fn(fn(&str) -> String) -> Vec<String>) -> Vec<String> {
let plain = search(repair_td1_line1);
if plain.is_empty() {
return plain;
}
let unshifted = search(repair_td1_line1_unshifted);
let mut seen = std::collections::HashSet::new();
let admissible: Vec<String> = plain
.iter()
.chain(&unshifted)
.filter(|c| line1_admissible(c, 30, b"IAC") && seen.insert(c.as_str()))
.cloned()
.collect();
if admissible.is_empty() {
plain
} else {
admissible
}
}
fn repair_td1_line2(l: &str) -> String {
let l = repair_positions(
l,
&[
(0..7, digitize), (8..15, digitize), (15..18, letterize), (29..30, digitize), ],
);
format!(
"{}{}{}",
&l[0..18],
aggressive_defiller(&defiller(&l[18..29])),
&l[29..30]
)
}
fn repair_td1_line3(l: &str) -> String {
fix_name_separator(&defiller(l))
}
fn repair_mrv_line1(l: &str) -> String {
let l = fix_doc_code(&repair_positions(l, &[(2..5, letterize)]));
format!("{}{}", &l[0..5], fix_name_separator(&defiller(&l[5..])))
}
fn repair_mrv_a_line1(l: &str) -> String {
repair_mrv_line1(l)
}
fn repair_mrv_b_line1(l: &str) -> String {
repair_mrv_line1(l)
}
fn repair_mrv_a_line1_unshifted(l: &str) -> String {
let target_width = l.len();
unshift_line1_prefix(repair_mrv_a_line1(l), target_width)
}
fn repair_mrv_b_line1_unshifted(l: &str) -> String {
let target_width = l.len();
unshift_line1_prefix(repair_mrv_b_line1(l), target_width)
}
fn repair_mrv_a_line1_shifted(l: &str) -> String {
let target_width = l.len();
shift_or_unshift_line1(repair_mrv_a_line1(l), target_width)
}
fn repair_mrv_b_line1_shifted(l: &str) -> String {
let target_width = l.len();
shift_or_unshift_line1(repair_mrv_b_line1(l), target_width)
}
fn repair_mrv_a_line2(l: &str) -> String {
repair_positions(
l,
&[
(9..10, digitize), (10..13, letterize), (13..20, digitize), (21..28, digitize), ],
)
}
fn repair_mrv_b_line2(l: &str) -> String {
repair_positions(
l,
&[
(9..10, digitize), (10..13, letterize), (13..20, digitize), (21..28, digitize), ],
)
}
pub fn find_and_parse(text: &str) -> Result<MrzData, MrzError> {
find_and_parse_with(text, &ParseOptions::default())
}
fn rejoin_exact_width_tokens(line: &str) -> Vec<String> {
let is_line_width = |len| matches!(len, 30 | 36 | 44);
let raw: Vec<&str> = line.split_whitespace().collect();
let mut tokens = Vec::with_capacity(raw.len());
let mut i = 0;
while i < raw.len() {
if i + 1 < raw.len()
&& !is_line_width(raw[i].len())
&& !is_line_width(raw[i + 1].len())
&& is_line_width(raw[i].len() + raw[i + 1].len())
{
let mut joined = String::with_capacity(raw[i].len() + raw[i + 1].len());
joined.push_str(raw[i]);
joined.push_str(raw[i + 1]);
tokens.push(joined);
i += 2;
} else {
tokens.push(raw[i].to_string());
i += 1;
}
}
tokens
}
pub(crate) fn candidate_lines(text: &str) -> Vec<String> {
let text = text.replace("<", "<");
let mut out: Vec<String> = Vec::new();
for line in text.lines() {
let tokens: Vec<String> = rejoin_exact_width_tokens(line)
.into_iter()
.filter(|t| t.len() >= 20)
.collect();
if tokens.len() >= 2 {
out.extend(tokens);
} else {
out.push(line.to_string());
}
}
out
}
pub fn find_and_parse_with(text: &str, opts: &ParseOptions) -> Result<MrzData, MrzError> {
let owned_lines = candidate_lines(text);
let lines: Vec<&str> = owned_lines.iter().map(String::as_str).collect();
let mut fallback: Option<MrzData> = None;
let mut flagged_first: Option<MrzData> = None;
let mut consider = |data: MrzData| -> Option<MrzData> {
if data.valid() {
if crate::rank::flagged(&data) {
flagged_first.get_or_insert(data);
return None;
}
return Some(data);
}
match &fallback {
Some(best)
if fallback_rank(&best.checks, &data.checks) != core::cmp::Ordering::Less => {}
_ => fallback = Some(data),
}
None
};
let mut refused: Option<MrzError> = None;
let mut note_refusal = |result: Result<MrzData, MrzError>| -> Option<MrzData> {
match result {
Ok(data) => Some(data),
Err(e @ MrzError::LeadingFiller { .. }) => {
refused.get_or_insert(e);
None
}
Err(_) => None,
}
};
let mut shape_seen: Option<Format> = None;
for i in 0..lines.len() {
let merged = normalize_line(lines[i]);
if merged.starts_with('P') && (84..=92).contains(&merged.len()) && is_mrz_charset(&merged) {
let head = &merged[0..44];
let tail = &merged[44..];
match td3_prefix_verdict(&fix_doc_code(head)) {
Td3Prefix::Ambiguous => {}
Td3Prefix::Repair(l1) => {
for l2 in variants(tail, 44, repair_td3_line2) {
if let Some(data) = note_refusal(parse_td3_with(&l1, &l2, opts)) {
if let Some(valid) = consider(data) {
return Ok(valid);
}
}
}
}
Td3Prefix::Keep => {
for l1 in [
repair_td3_line1_shifted(head),
repair_td3_line1(head),
head.to_string(),
] {
for l2 in variants(tail, 44, repair_td3_line2) {
if let Some(data) = note_refusal(parse_td3_with(&l1, &l2, opts)) {
if let Some(valid) = consider(data) {
return Ok(valid);
}
}
}
}
}
}
}
match td3_prefix_verdict(&fix_doc_code(&merged)) {
Td3Prefix::Repair(l1) => {
shape_seen.get_or_insert(Format::Td3);
for l2_raw in lines.iter().skip(i + 1).take(3) {
for l2 in variants(l2_raw, 44, repair_td3_line2) {
if let Some(data) = note_refusal(parse_td3_with(&l1, &l2, opts)) {
if let Some(valid) = consider(data) {
return Ok(valid);
}
}
}
}
continue;
}
Td3Prefix::Ambiguous => {
shape_seen.get_or_insert(Format::Td3);
continue;
}
Td3Prefix::Keep => {}
}
let l1_candidates = line1_variants(lines[i], 44, repair_td3_line1_shifted)
.into_iter()
.chain(line1_variants(lines[i], 44, repair_td3_line1));
for l1 in l1_candidates {
if !l1.starts_with('P') {
continue;
}
shape_seen.get_or_insert(Format::Td3);
for l2_raw in lines.iter().skip(i + 1).take(3) {
for l2 in variants(l2_raw, 44, repair_td3_line2) {
if let Some(data) = note_refusal(parse_td3_with(&l1, &l2, opts)) {
if let Some(valid) = consider(data) {
return Ok(valid);
}
}
}
}
}
}
for i in 0..lines.len() {
let merged = normalize_line(lines[i]);
if merged.starts_with('V') && (68..=76).contains(&merged.len()) && is_mrz_charset(&merged) {
let head = &merged[0..36];
let tail = &merged[36..];
for l1 in [
repair_mrv_b_line1_shifted(head),
repair_mrv_b_line1_unshifted(head),
repair_mrv_b_line1(head),
head.to_string(),
] {
for l2 in variants(tail, 36, repair_mrv_b_line2) {
if let Some(data) = note_refusal(parse_mrv_b_with(&l1, &l2, opts)) {
if let Some(valid) = consider(data) {
return Ok(valid);
}
}
}
}
}
let l1_candidates = line1_variants(lines[i], 36, repair_mrv_b_line1_shifted)
.into_iter()
.chain(line1_variants(lines[i], 36, repair_mrv_b_line1_unshifted))
.chain(line1_variants(lines[i], 36, repair_mrv_b_line1));
for l1 in l1_candidates {
if !l1.starts_with('V') {
continue;
}
shape_seen.get_or_insert(Format::MrvB);
for l2_raw in lines.iter().skip(i + 1).take(3) {
for l2 in variants(l2_raw, 36, repair_mrv_b_line2) {
if let Some(data) = note_refusal(parse_mrv_b_with(&l1, &l2, opts)) {
if let Some(valid) = consider(data) {
return Ok(valid);
}
}
}
}
}
}
for i in 0..lines.len() {
let merged = normalize_line(lines[i]);
if merged.starts_with('V') && (84..=92).contains(&merged.len()) && is_mrz_charset(&merged) {
let head = &merged[0..44];
let tail = &merged[44..];
for l1 in [
repair_mrv_a_line1_shifted(head),
repair_mrv_a_line1_unshifted(head),
repair_mrv_a_line1(head),
head.to_string(),
] {
for l2 in variants(tail, 44, repair_mrv_a_line2) {
if let Some(data) = note_refusal(parse_mrv_a_with(&l1, &l2, opts)) {
if let Some(valid) = consider(data) {
return Ok(valid);
}
}
}
}
}
let l1_candidates = line1_variants(lines[i], 44, repair_mrv_a_line1_shifted)
.into_iter()
.chain(line1_variants(lines[i], 44, repair_mrv_a_line1_unshifted))
.chain(line1_variants(lines[i], 44, repair_mrv_a_line1));
for l1 in l1_candidates {
if !l1.starts_with('V') {
continue;
}
shape_seen.get_or_insert(Format::MrvA);
for l2_raw in lines.iter().skip(i + 1).take(3) {
for l2 in variants(l2_raw, 44, repair_mrv_a_line2) {
if let Some(data) = note_refusal(parse_mrv_a_with(&l1, &l2, opts)) {
if let Some(valid) = consider(data) {
return Ok(valid);
}
}
}
}
}
}
for i in 0..lines.len() {
let merged = normalize_line(lines[i]);
if matches!(merged.as_bytes().first(), Some(b'I' | b'A' | b'C'))
&& (86..=94).contains(&merged.len())
&& is_mrz_charset(&merged)
{
let head = &merged[0..30];
let mid = &merged[30..60];
let tail = &merged[60..];
let l1_candidates = prefer_admissible_line1(
vec![
repair_td1_line1(head),
repair_td1_line1_unshifted(head),
head.to_string(),
],
30,
b"IAC",
);
for l1 in l1_candidates {
for l2 in [repair_td1_line2(mid), mid.to_string()] {
for l3 in variants(tail, 30, repair_td1_line3) {
if let Some(data) = note_refusal(parse_td1_with(&l1, &l2, &l3, opts)) {
if let Some(valid) = consider(data) {
return Ok(valid);
}
}
}
}
}
}
for l1 in td1_line1_variants(lines[i]) {
if !matches!(l1.as_bytes().first(), Some(b'I' | b'A' | b'C')) {
continue;
}
shape_seen.get_or_insert(Format::Td1);
for (j, l2_raw) in lines.iter().enumerate().skip(i + 1).take(3) {
for l2 in variants(l2_raw, 30, repair_td1_line2) {
for l3_raw in lines.iter().skip(j + 1).take(3) {
for l3 in variants(l3_raw, 30, repair_td1_line3) {
if let Some(data) = note_refusal(parse_td1_with(&l1, &l2, &l3, opts)) {
if let Some(valid) = consider(data) {
return Ok(valid);
}
}
}
}
}
}
}
}
let intact_td1_starts = intact_td1_starts(&lines, opts);
for &line in &lines {
let merged = normalize_line(line);
if (68..=76).contains(&merged.len())
&& is_mrz_charset(&merged)
&& matches!(merged.as_bytes().first(), Some(b'I' | b'A' | b'C'))
{
let head = &merged[0..36];
let tail = &merged[36..];
for l1 in [
repair_td2_line1_shifted(head),
repair_td2_line1(head),
head.to_string(),
] {
for l2 in variants(tail, 36, repair_td2_line2) {
if let Some(data) = note_refusal(parse_td2_with(&l1, &l2, opts)) {
if let Some(valid) = consider(data) {
return Ok(valid);
}
}
}
}
}
}
for i in 0..lines.len().saturating_sub(1) {
if intact_td1_starts.contains(&i) {
continue;
}
let l1_candidates = line1_variants(lines[i], 36, repair_td2_line1_shifted)
.into_iter()
.chain(line1_variants(lines[i], 36, repair_td2_line1));
for l1 in l1_candidates {
if !matches!(l1.as_bytes().first(), Some(b'I' | b'A' | b'C')) {
continue;
}
shape_seen.get_or_insert(Format::Td2);
for l2 in variants(lines[i + 1], 36, repair_td2_line2) {
if let Some(data) = note_refusal(parse_td2_with(&l1, &l2, opts)) {
if let Some(valid) = consider(data) {
return Ok(valid);
}
}
}
}
}
if fallback.is_some() || refused.is_some() || flagged_first.is_some() {
if let Some(mut data) = damaged_pass(&lines, opts, &intact_td1_starts) {
data.damaged_recovery = true;
if !crate::rank::flagged(&data) {
return Ok(data);
}
flagged_first.get_or_insert(data);
}
}
if let Some(data) = flagged_first {
return Ok(data);
}
if let Some(data) = &fallback {
if !data.valid() && looks_like_non_mrz_text(data) {
return Err(MrzError::NotFound);
}
}
match fallback {
Some(data) => Ok(data),
None => Err(refused.unwrap_or_else(|| match shape_seen {
Some(format) => MrzError::IncompleteSequence {
format,
lines_found: 1,
lines_expected: expected_lines(format),
},
None => MrzError::NotFound,
})),
}
}
fn expected_lines(format: Format) -> u8 {
match format {
Format::Td1 => 3,
Format::Td2 | Format::Td3 | Format::MrvA | Format::MrvB => 2,
}
}
type TwoLineParse = fn(&str, &str, &ParseOptions) -> Result<MrzData, MrzError>;
type TwoLineFormat = (
usize,
&'static [u8],
fn(&str) -> String,
fn(&str) -> String,
TwoLineParse,
);
const MAX_DAMAGED_ATTEMPTS: usize = 200_000;
fn restored(raw: &str, target: usize, repair: fn(&str) -> String) -> Vec<String> {
let n = normalize_line(raw);
if n.len() + 1 != target || !is_mrz_charset(&n) {
return Vec::new();
}
let mut seen = std::collections::HashSet::new();
let mut out: Vec<String> = Vec::new();
for shaped in crate::repair::width_candidates(&n, target) {
if shaped.starts_with(crate::repair::UNKNOWN) || !shaped.contains(crate::repair::UNKNOWN) {
continue;
}
for concrete in crate::repair::concrete_fillings(&shaped) {
for form in [repair(&concrete), concrete] {
if seen.insert(form.clone()) {
out.push(form);
}
}
}
}
out
}
fn substituted(raw: &str, target: usize, repair: fn(&str) -> String) -> Vec<String> {
let n = normalize_line(raw);
if n.len() != target || !is_mrz_charset(&n) {
return Vec::new();
}
let mut seen = std::collections::HashSet::new();
let mut out: Vec<String> = Vec::new();
for concrete in crate::repair::substitution_candidates(&n) {
for form in [repair(&concrete), concrete] {
if seen.insert(form.clone()) {
out.push(form);
}
}
}
out
}
type CdFields = &'static [(usize, usize, usize, FieldKind)];
const TD1_LINE1_CD_FIELDS: CdFields = &[(5, 14, 14, FieldKind::DocumentNumber)];
const TD1_LINE2_CD_FIELDS: CdFields = &[(0, 6, 6, FieldKind::Date), (8, 14, 14, FieldKind::Date)];
const TD2_LINE2_CD_FIELDS: CdFields = &[
(0, 9, 9, FieldKind::DocumentNumber),
(13, 19, 19, FieldKind::Date),
(21, 27, 27, FieldKind::Date),
];
const TD3_LINE2_CD_FIELDS: CdFields = &[
(0, 9, 9, FieldKind::DocumentNumber),
(13, 19, 19, FieldKind::Date),
(21, 27, 27, FieldKind::Date),
(28, 42, 42, FieldKind::PersonalNumber),
];
const MRV_LINE2_CD_FIELDS: CdFields = &[
(0, 9, 9, FieldKind::DocumentNumber),
(13, 19, 19, FieldKind::Date),
(21, 27, 27, FieldKind::Date),
];
#[cfg(test)]
pub(crate) fn cd_field_tables() -> [(Format, usize, CdFields); 6] {
[
(Format::Td1, 0, TD1_LINE1_CD_FIELDS),
(Format::Td1, 1, TD1_LINE2_CD_FIELDS),
(Format::Td2, 1, TD2_LINE2_CD_FIELDS),
(Format::Td3, 1, TD3_LINE2_CD_FIELDS),
(Format::MrvA, 1, MRV_LINE2_CD_FIELDS),
(Format::MrvB, 1, MRV_LINE2_CD_FIELDS),
]
}
type TwoLineSweep = (
usize,
&'static [u8],
fn(&str) -> String,
fn(&str) -> String,
TwoLineParse,
CdFields,
);
fn class_swept(
raw: &str,
target: usize,
repair: fn(&str) -> String,
fields: CdFields,
) -> Vec<String> {
let n = normalize_line(raw);
if n.len() != target || !is_mrz_charset(&n) {
return Vec::new();
}
let mut seen = std::collections::HashSet::new();
let mut out: Vec<String> = Vec::new();
for base in [repair(&n), n.clone()] {
let mut cells: Vec<char> = base.chars().collect();
if cells.len() != target {
continue;
}
let mut changed = false;
for &(start, end, cd_col, kind) in fields {
if end > cells.len() || cd_col >= cells.len() {
continue;
}
let field: String = cells[start..end].iter().collect();
if let Resolution::Unique(fixed) = solve_class_sweep(&field, cells[cd_col], kind) {
let (Ok(cd), true) = (
crate::check_digit(&fixed),
fixed.chars().count() == end - start,
) else {
continue;
};
let Some(cd_char) = char::from_digit(cd, 10) else {
continue;
};
for (i, c) in fixed.chars().enumerate() {
cells[start + i] = c;
}
cells[cd_col] = cd_char;
changed = true;
}
}
if changed {
let line: String = cells.into_iter().collect();
if seen.insert(line.clone()) {
out.push(line);
}
}
}
out
}
fn class_sweep_pass(
lines: &[&str],
opts: &ParseOptions,
intact_td1_starts: &[usize],
) -> Option<MrzData> {
if !opts.class_sweep {
return None;
}
let mut hits: Vec<MrzData> = Vec::new();
for i in 0..lines.len().saturating_sub(2) {
let (a, b, c) = (lines[i], lines[i + 1], lines[i + 2]);
let v3 = variants(c, 30, repair_td1_line3);
for (v1, v2) in [
(
td1_line1_searched(|repair| class_swept(a, 30, repair, TD1_LINE1_CD_FIELDS)),
variants(b, 30, repair_td1_line2),
),
(
td1_line1_variants(a),
class_swept(b, 30, repair_td1_line2, TD1_LINE2_CD_FIELDS),
),
] {
for l1 in &v1 {
if !matches!(l1.as_bytes().first(), Some(b'I' | b'A' | b'C')) {
continue;
}
for l2 in &v2 {
for l3 in &v3 {
if let Ok(data) = parse_td1_with(l1, l2, l3, opts) {
if accept_damaged(&data)
&& !hits.iter().any(|h| h.mrz_lines == data.mrz_lines)
{
hits.push(data);
}
}
}
}
}
}
}
let two_line: [TwoLineSweep; 4] = [
(
44,
b"P",
repair_td3_line1,
repair_td3_line2,
parse_td3_with,
TD3_LINE2_CD_FIELDS,
),
(
44,
b"V",
repair_mrv_a_line1,
repair_mrv_a_line2,
parse_mrv_a_with,
MRV_LINE2_CD_FIELDS,
),
(
36,
b"IAC",
repair_td2_line1,
repair_td2_line2,
parse_td2_with,
TD2_LINE2_CD_FIELDS,
),
(
36,
b"V",
repair_mrv_b_line1,
repair_mrv_b_line2,
parse_mrv_b_with,
MRV_LINE2_CD_FIELDS,
),
];
for i in 0..lines.len().saturating_sub(1) {
let (a, b) = (lines[i], lines[i + 1]);
for (width, prefixes, rep1, rep2, parse, cd_fields) in two_line {
if width == 36 && prefixes == b"IAC" && intact_td1_starts.contains(&i) {
continue;
}
let v1 = td3_line1_variants(a, width, prefixes, rep1);
let v2 = class_swept(b, width, rep2, cd_fields);
for l1 in &v1 {
if !l1.bytes().next().is_some_and(|c| prefixes.contains(&c)) {
continue;
}
for l2 in &v2 {
if let Ok(data) = parse(l1, l2, opts) {
if accept_damaged(&data)
&& !hits.iter().any(|h| h.mrz_lines == data.mrz_lines)
{
hits.push(data);
}
}
}
}
}
}
single(hits)
}
fn intact_td1_starts(lines: &[&str], opts: &ParseOptions) -> Vec<usize> {
lines
.windows(3)
.enumerate()
.filter_map(|(index, rows)| {
let [first, second, third] = [rows[0], rows[1], rows[2]].map(normalize_line);
let shaped = [&first, &second, &third]
.iter()
.all(|row| row.len() == 30 && is_mrz_charset(row));
let intact = shaped
&& matches!(
parse_td1_with(&first, &second, &third, opts),
Ok(_) | Err(MrzError::LeadingFiller { .. })
);
intact.then_some(index)
})
.collect()
}
fn accept_damaged(data: &MrzData) -> bool {
data.valid()
&& data
.validity(crate::Date::new(2000, 1, 1))
.dates_well_formed
}
fn damaged_pass(
lines: &[&str],
opts: &ParseOptions,
intact_td1_starts: &[usize],
) -> Option<MrzData> {
if let Some(data) = class_sweep_pass(lines, opts, intact_td1_starts) {
return Some(data);
}
let mut budget = MAX_DAMAGED_ATTEMPTS;
let mut hits: Vec<MrzData> = Vec::new();
let record = |data: MrzData, hits: &mut Vec<MrzData>| {
if accept_damaged(&data) && !hits.iter().any(|h| h.mrz_lines == data.mrz_lines) {
hits.push(data);
}
};
for i in 0..lines.len().saturating_sub(2) {
let (a, b, c) = (lines[i], lines[i + 1], lines[i + 2]);
let shapes: [(Vec<String>, Vec<String>, Vec<String>); 6] = [
(
restored(a, 30, repair_td1_line1),
variants(b, 30, repair_td1_line2),
variants(c, 30, repair_td1_line3),
),
(
td1_line1_variants(a),
restored(b, 30, repair_td1_line2),
variants(c, 30, repair_td1_line3),
),
(
td1_line1_variants(a),
variants(b, 30, repair_td1_line2),
restored(c, 30, repair_td1_line3),
),
(
td1_line1_searched(|repair| substituted(a, 30, repair)),
variants(b, 30, repair_td1_line2),
variants(c, 30, repair_td1_line3),
),
(
td1_line1_variants(a),
substituted(b, 30, repair_td1_line2),
variants(c, 30, repair_td1_line3),
),
(
td1_line1_variants(a),
variants(b, 30, repair_td1_line2),
substituted(c, 30, repair_td1_line3),
),
];
for (v1, v2, v3) in shapes {
for l1 in &v1 {
if !matches!(l1.as_bytes().first(), Some(b'I' | b'A' | b'C')) {
continue;
}
for l2 in &v2 {
for l3 in &v3 {
if budget == 0 {
return single(hits);
}
budget -= 1;
if let Ok(data) = parse_td1_with(l1, l2, l3, opts) {
record(data, &mut hits);
}
}
}
}
}
}
let two_line: [TwoLineFormat; 4] = [
(44, b"P", repair_td3_line1, repair_td3_line2, parse_td3_with),
(
44,
b"V",
repair_mrv_a_line1,
repair_mrv_a_line2,
parse_mrv_a_with,
),
(
36,
b"IAC",
repair_td2_line1,
repair_td2_line2,
parse_td2_with,
),
(
36,
b"V",
repair_mrv_b_line1,
repair_mrv_b_line2,
parse_mrv_b_with,
),
];
for i in 0..lines.len().saturating_sub(1) {
let (a, b) = (lines[i], lines[i + 1]);
for (width, prefixes, rep1, rep2, parse) in two_line {
if width == 36 && prefixes == b"IAC" && intact_td1_starts.contains(&i) {
continue;
}
for (v1, v2) in [
(restored(a, width, rep1), variants(b, width, rep2)),
(
td3_line1_variants(a, width, prefixes, rep1),
restored(b, width, rep2),
),
(substituted(a, width, rep1), variants(b, width, rep2)),
(
td3_line1_variants(a, width, prefixes, rep1),
substituted(b, width, rep2),
),
] {
for l1 in &v1 {
if !l1.bytes().next().is_some_and(|c| prefixes.contains(&c)) {
continue;
}
for l2 in &v2 {
if budget == 0 {
return single(hits);
}
budget -= 1;
if let Ok(data) = parse(l1, l2, opts) {
record(data, &mut hits);
}
}
}
}
}
}
single(hits)
}
fn fallback_rank(a: &Checks, b: &Checks) -> core::cmp::Ordering {
use core::cmp::Ordering;
match (a.applicable(), b.applicable()) {
(0, 0) => Ordering::Equal,
(0, _) => Ordering::Less,
(_, 0) => Ordering::Greater,
(a_applicable, b_applicable) => (a.verified() * b_applicable)
.cmp(&(b.verified() * a_applicable))
.then_with(|| a_applicable.cmp(&b_applicable)),
}
}
fn single(mut hits: Vec<MrzData>) -> Option<MrzData> {
let answer = |data: &MrzData| {
let mut data = data.clone();
data.mrz_lines.clear();
data
};
let first = answer(hits.first()?);
if hits.iter().all(|h| answer(h) == first) {
return Some(hits.remove(0));
}
None
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn td1_line1_variants_recovers_a_dropped_filler() {
use crate::checksum::check_digit;
use crate::{format_td1, Td1Fields};
let document_number = "345678912";
let mrz = format_td1(&Td1Fields {
document_code: "I".to_string(),
issuing_country: "UTO".to_string(),
document_number: document_number.to_string(),
optional_data_1: None,
surname: "ESKANDARI".to_string(),
given_names: "MAREN".to_string(),
nationality: "UTO".to_string(),
date_of_birth: MrzDate::from_field(
RawDateField::try_from("440101").expect("six MRZ date characters"),
DateRole::Birth,
crate::CURRENT_YY,
),
sex: Sex::Female,
date_of_expiry: MrzDate::from_field(
RawDateField::try_from("301230").expect("six MRZ date characters"),
DateRole::Expiry,
crate::CURRENT_YY,
),
optional_data_2: None,
});
let mut lines = mrz.lines();
let l1 = lines.next().expect("format_td1 emits line 1").to_string();
let l2 = lines.next().expect("format_td1 emits line 2");
let l3 = lines.next().expect("format_td1 emits line 3");
assert_eq!(l1.len(), 30, "sanity: a TD1 line is 30 cells");
assert!(
parse_td1_with(&l1, l2, l3, &ParseOptions::default())
.expect("the emitted fixture parses")
.valid(),
"sanity: the fixture must be checksum-valid before it is damaged"
);
let mut damaged = l1.clone();
damaged.remove(1);
assert_eq!(damaged.len(), 29, "dropping one character narrows the line");
let candidates = td1_line1_variants(&damaged);
assert!(
candidates.contains(&l1),
"the unshifted candidate must reconstruct the original line exactly, got {candidates:?}"
);
let shifted_only: Vec<&String> = candidates.iter().filter(|c| c.as_str() != l1).collect();
assert!(
shifted_only.iter().all(|c| {
c.len() != 30
|| check_digit(&c[5..14]).ok()
!= c.as_bytes().get(14).and_then(|b| (*b as char).to_digit(10))
}),
"every other candidate's own document-number check digit must fail, got {candidates:?}"
);
let recovered = parse_td1_with(&l1, l2, l3, &ParseOptions::default())
.expect("the unshifted candidate parses");
assert_eq!(recovered.document_number, document_number);
assert!(recovered.valid());
}
#[test]
fn prefer_admissible_line1_keeps_admissible_in_order_or_everything() {
let good_a = "I<FRAAHGEK9H885<<<<<<<<<<<<<<<".to_string();
let good_b = "IDFRAAHGEK9H885<<<<<<<<<<<<<<<".to_string();
let shifted = "IFRAAHGEK9H885<<<<<<<<<<<<<<<<".to_string();
let short = "I<FRA".to_string();
for line in [&good_a, &good_b, &shifted] {
assert_eq!(line.len(), 30, "sanity: {line}");
}
let mixed = vec![
shifted.clone(),
good_b.clone(),
short.clone(),
good_a.clone(),
good_b.clone(),
];
assert_eq!(
prefer_admissible_line1(mixed, 30, b"IAC"),
vec![good_b.clone(), good_a.clone(), good_b.clone()]
);
let none = vec![
shifted.clone(),
short.clone(),
"I<QQQAAAAAAAAAA<<<<<<<<<<<<<<<".into(),
];
assert_eq!(prefer_admissible_line1(none.clone(), 30, b"IAC"), none);
assert_eq!(
prefer_admissible_line1(Vec::new(), 30, b"IAC"),
Vec::<String>::new()
);
assert!(!line1_admissible(&good_a.replacen('I', "P", 1), 30, b"IAC"));
assert!(!line1_admissible(&good_a, 36, b"IAC"));
assert!(line1_admissible(&good_a.replacen('I', "C", 1), 30, b"IAC"));
}
#[test]
fn td1_line1_variants_drops_a_validating_shifted_reading() {
use crate::{format_td1, Td1Fields};
let mrz = format_td1(&Td1Fields {
document_code: "I".to_string(),
issuing_country: "FRA".to_string(),
document_number: "AHGEK9H88".to_string(),
optional_data_1: None,
surname: "MARTIN".to_string(),
given_names: "CLAIRE".to_string(),
nationality: "FRA".to_string(),
date_of_birth: MrzDate::from_field(
RawDateField::try_from("070707").expect("six MRZ date characters"),
DateRole::Birth,
crate::CURRENT_YY,
),
sex: Sex::Female,
date_of_expiry: MrzDate::from_field(
RawDateField::try_from("330615").expect("six MRZ date characters"),
DateRole::Expiry,
crate::CURRENT_YY,
),
optional_data_2: None,
});
let lines: Vec<&str> = mrz.lines().collect();
let (l1, l2, l3) = (lines[0], lines[1], lines[2]);
let opts = ParseOptions::default();
let shifted = format!("{}{}<", &l1[..1], &l1[2..]);
assert_eq!(l1.as_bytes()[14], b'5', "sanity: the true check digit");
assert!(parse_td1_with(l1, l2, l3, &opts)
.expect("truth parses")
.valid());
assert!(
parse_td1_with(&shifted, l2, l3, &opts)
.expect("shifted parses")
.valid(),
"sanity: the shifted reading validates too"
);
let dropped = &shifted[..29];
let candidates = td1_line1_variants(dropped);
assert!(candidates.contains(&l1.to_string()), "{candidates:?}");
assert!(
candidates.iter().all(|c| line1_admissible(c, 30, b"IAC")),
"no inadmissible candidate may survive when one is admissible: {candidates:?}"
);
assert!(!candidates.contains(&shifted), "{candidates:?}");
}
#[test]
fn single_refuses_readings_that_disagree_on_any_exposed_field() {
let base = parse_td3(
"P<UTOERIKSSON<<ANNA<MARIA<<<<<<<<<<<<<<<<<<<",
"L898902C36UTO7408122F1204159ZE184226B<<<<<10",
)
.expect("the Doc 9303 specimen parses");
let mut twin = base.clone();
twin.mrz_lines.push('<');
assert_eq!(single(vec![base.clone(), twin]), Some(base.clone()));
assert_eq!(single(vec![base.clone()]), Some(base.clone()));
assert_eq!(single(Vec::new()), None);
type Mutation = (&'static str, fn(&mut MrzData));
let mutations: [Mutation; 8] = [
("format", |d| d.format = Format::MrvA),
("document_type", |d| d.document_type = "PO".into()),
("issuing_country", |d| d.issuing_country = "D".into()),
("document_number_full", |d| {
d.document_number_full = Some("L898902C3123".into());
}),
("document_number_legacy_encoding", |d| {
d.document_number_legacy_encoding = !d.document_number_legacy_encoding;
}),
("sex", |d| d.sex = Sex::Male),
("optional_data_1", |d| {
d.optional_data_1 = Some("ZE184226C".into())
}),
("optional_data_2", |d| d.optional_data_2 = Some("1".into())),
];
for (field, mutate) in mutations {
let mut other = base.clone();
mutate(&mut other);
assert_ne!(other, base, "the {field} mutation must change the record");
assert_eq!(
single(vec![base.clone(), other.clone()]),
None,
"readings that disagree on {field} are not one answer"
);
assert_eq!(
single(vec![other, base.clone()]),
None,
"the refusal on {field} does not depend on candidate order"
);
}
}
#[test]
fn date_field_reads_a_vetted_slice() {
assert_eq!(
date_field("<<740812", 1, 2, DateRole::Birth, 30),
Ok(MrzDate::Calendar(crate::Date::new(1974, 8, 12)))
);
}
#[test]
fn date_field_maps_an_unvetted_slice_to_bad_character_not_a_panic() {
let line = format!("{}74a812", "<".repeat(13));
assert_eq!(
date_field(&line, 1, 13, DateRole::Birth, 30),
Err(MrzError::BadCharacter {
character: 'a',
line: Some(1),
position: 15
})
);
assert_eq!(
date_field("7408", 1, 0, DateRole::Expiry, 30),
Err(MrzError::BadCharacter {
character: '7',
line: Some(1),
position: 0
})
);
}
#[test]
fn a_missing_interior_cell_is_still_restored() {
let zone = crate::format_td3(&crate::Td3Fields {
document_code: "P".to_string(),
issuing_country: "UTO".to_string(),
document_number: "E00000000".to_string(),
surname: "SPECIMEN".to_string(),
given_names: "TEST".to_string(),
nationality: "UTO".to_string(),
date_of_birth: MrzDate::from_field(
RawDateField::try_from("800101").expect("six MRZ date characters"),
DateRole::Birth,
crate::CURRENT_YY,
),
sex: Sex::Female,
date_of_expiry: MrzDate::from_field(
RawDateField::try_from("301230").expect("six MRZ date characters"),
DateRole::Expiry,
crate::CURRENT_YY,
),
personal_number: None,
});
let (line1, _) = zone.split_once('\n').expect("emitted TD3 has two lines");
let at = line1.find("<<").expect("emitted name separator") + 1;
let mut short_line1 = line1.to_string();
short_line1.remove(at);
assert_eq!(short_line1.len(), 43);
let candidates = restored(&short_line1, 44, repair_td3_line1);
assert!(
candidates.iter().any(|line| line == line1),
"the original line must remain a restoration candidate"
);
}
#[test]
fn td3_prefix_verdict_table() {
let two_resolving = "P<COHLERIKSSON<<ANNA<MARIA<<<<<<<<<<<<<<<<<<<";
assert_eq!(two_resolving.len(), 45);
assert_eq!(td3_prefix_verdict(two_resolving), Td3Prefix::Ambiguous);
let one_resolving = "P<UXTOERIKSSON<<ANNA<MARIA<<<<<<<<<<<<<<<<<<<";
assert_eq!(one_resolving.len(), 45);
let Td3Prefix::Repair(repaired) = td3_prefix_verdict(one_resolving) else {
panic!("expected exactly one resolving deletion to repair the line");
};
assert_eq!(repaired.len(), 44);
assert_eq!(&repaired[0..5], "P<UTO");
assert_eq!(&repaired[5..], &one_resolving[6..]);
let already_resolves = "P<CANFOO<<GIVEN<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<";
assert_eq!(already_resolves.len(), 45);
assert_eq!(td3_prefix_verdict(already_resolves), Td3Prefix::Keep);
let bogus_doc_code = "PXCOHLERIKSSON<<ANNA<MARIA<<<<<<<<<<<<<<<<<<<";
assert_eq!(bogus_doc_code.len(), 45);
assert_eq!(td3_prefix_verdict(bogus_doc_code), Td3Prefix::Keep);
let right_length = "P<UTOERIKSSON<<ANNA<MARIA<<<<<<<<<<<<<<<<<<<";
assert_eq!(right_length.len(), 44);
assert_eq!(td3_prefix_verdict(right_length), Td3Prefix::Keep);
let two_cells_long = "P<XUTOERIKSSON<<ANNA<MARIA<<<<<<<<<<<<<<<<<<<X";
assert_eq!(two_cells_long.len(), 46);
assert_eq!(td3_prefix_verdict(two_cells_long), Td3Prefix::Keep);
}
use core::cmp::Ordering;
fn checks(states: [Option<bool>; 5]) -> Checks {
Checks {
document_number: states[0],
date_of_birth: states[1],
date_of_expiry: states[2],
personal_number: states[3],
composite: states[4],
}
}
#[test]
fn fallback_rank_uses_exact_fraction_then_coverage_then_incumbent() {
let none = checks([None, None, None, None, None]);
let one_verified = checks([Some(true), None, None, None, None]);
assert_eq!(fallback_rank(&none, &one_verified), Ordering::Less);
let three_of_four = checks([Some(true), Some(true), Some(true), Some(false), None]);
let two_of_three = checks([Some(true), Some(true), Some(false), None, None]);
assert_eq!(
fallback_rank(&three_of_four, &two_of_three),
Ordering::Greater
);
let three_of_three = checks([Some(true), Some(true), Some(true), None, None]);
let four_of_five = checks([Some(true), Some(true), Some(true), Some(true), Some(false)]);
assert_eq!(
fallback_rank(&three_of_three, &four_of_five),
Ordering::Greater
);
let four_of_four = checks([Some(true), Some(true), Some(true), Some(true), None]);
assert_eq!(
fallback_rank(&three_of_three, &four_of_four),
Ordering::Less
);
assert_eq!(
fallback_rank(&three_of_three, &three_of_three),
Ordering::Equal
);
}
}