use crate::date::{self, GwDate};
use crate::error::{GwError, GwErrorKind, Result};
use crate::lexer::{cut_space, Cursor};
use crate::model::key::{Key, Somebody};
use crate::model::person::{Access, Burial, Death, DeathReason, Person, Sex};
use crate::model::title::{Title, TitleName};
#[derive(Debug, Clone, Copy)]
pub struct LineCtx<'a> {
pub no: usize,
pub raw: &'a str,
}
impl LineCtx<'_> {
#[must_use]
pub fn err(self, kind: GwErrorKind) -> GwError {
GwError::at(self.no, self.raw, kind)
}
pub fn syntax(self, what: impl Into<String>) -> GwError {
self.err(GwErrorKind::Syntax(what.into()))
}
}
#[derive(Debug, Clone, Copy)]
pub struct Identity<'a> {
pub first_name: &'a str,
pub surname: &'a str,
pub occ: u32,
pub sex: Sex,
}
impl<'a> Identity<'a> {
#[must_use]
pub fn new(first_name: &'a str, surname: &'a str, occ: u32) -> Self {
Self {
first_name,
surname,
occ,
sex: Sex::Neuter,
}
}
}
#[derive(Debug, Clone, Copy, Default)]
pub struct FamilyDefaults<'a> {
pub sources: &'a str,
pub birth_place: &'a str,
}
fn is_name_start(b: u8) -> bool {
b.is_ascii_alphanumeric() || matches!(b, 0xC0..=0xDD | 0xE0..=0xFF | b'?' | b' ')
}
fn first_byte(token: &str) -> Option<u8> {
token.as_bytes().first().copied()
}
fn get_name(cur: &mut Cursor<'_>) -> String {
let Some(token) = cur.peek() else {
return String::new();
};
if token == "#nick" || token == "#alias" {
return String::new();
}
match first_byte(token) {
Some(b'{') | None => String::new(),
Some(b) if is_name_start(b) => {
cur.advance();
cut_space(token).to_owned()
}
Some(_) => String::new(),
}
}
fn make_int(s: &str) -> Option<u32> {
if s.is_empty() || !s.bytes().all(|b| b.is_ascii_digit()) {
return None;
}
s.parse().ok()
}
fn get_first_name(cur: &mut Cursor<'_>, ctx: LineCtx<'_>) -> Result<(String, u32)> {
let token = cur
.peek()
.ok_or_else(|| ctx.syntax("expected a given name"))?;
let valid = match first_byte(token) {
Some(b'[') => true,
Some(b) => is_name_start(b),
None => false,
};
if !valid {
return Err(ctx.syntax(format!("`{token}` cannot begin a given name")));
}
cur.advance();
let name = cut_space(token);
match name.rfind('.') {
Some(i) => match make_int(&name[i + 1..]) {
Some(occ) => Ok((name[..i].to_owned(), occ)),
None => Ok((name.to_owned(), 0)),
},
None => Ok((name.to_owned(), 0)),
}
}
fn get_first_name_aliases(cur: &mut Cursor<'_>) -> Vec<String> {
let mut out = Vec::new();
while let Some(token) = cur.peek() {
let bytes = token.as_bytes();
if bytes.len() >= 2 && bytes[0] == b'{' && bytes[bytes.len() - 1] == b'}' {
cur.advance();
out.push(cut_space(&token[1..token.len() - 1]).to_owned());
} else {
break;
}
}
out
}
fn get_repeated(cur: &mut Cursor<'_>, tag: &str) -> Vec<String> {
let mut out = Vec::new();
loop {
let value = cur.field(tag);
if value.is_empty() && cur.peek() != Some(tag) {
break;
}
out.push(value);
}
out
}
fn get_public_name(cur: &mut Cursor<'_>) -> String {
let Some(token) = cur.peek() else {
return String::new();
};
let bytes = token.as_bytes();
if bytes.len() >= 2 && bytes[0] == b'(' && bytes[bytes.len() - 1] == b')' {
cur.advance();
cut_space(&token[1..token.len() - 1]).to_owned()
} else {
String::new()
}
}
fn get_image(cur: &mut Cursor<'_>) -> String {
let image = cur.field("#image");
if image.is_empty() && cur.peek() != Some("#image") {
cur.field("#photo")
} else {
image
}
}
fn get_access(cur: &mut Cursor<'_>) -> Access {
match cur.eat_any(&["#apubl", "#apriv", "#semipub", "#afriend"]) {
Some("#apubl") => Access::Public,
Some("#apriv") => Access::Private,
Some("#semipub" | "#afriend") => Access::SemiPublic,
_ => Access::IfTitles,
}
}
fn title_field(t: &str, start: usize) -> (String, usize) {
let bytes = t.as_bytes();
let mut out = String::new();
let mut i = start;
while i < bytes.len() {
match bytes[i] {
b':' => return (out, i + 1),
b'\\' if i + 1 < bytes.len() => {
let rest = &t[i + 1..];
if let Some(c) = rest.chars().next() {
out.push(c);
i += 1 + c.len_utf8();
} else {
i += 1;
}
}
_ => {
let rest = &t[i..];
if let Some(c) = rest.chars().next() {
out.push(c);
i += c.len_utf8();
} else {
i += 1;
}
}
}
}
(out, i)
}
fn scan_title(t: &str, ctx: LineCtx<'_>) -> Result<Title> {
let bad = || ctx.err(GwErrorKind::InvalidTitle(t.to_owned()));
let (name, i) = title_field(t, 0);
if i == t.len() {
return Err(bad());
}
let name = match name.as_str() {
"" => TitleName::None,
"*" => TitleName::Main,
other => TitleName::Name(other.to_owned()),
};
let (ident, i) = title_field(t, i);
if i == 0 || t.as_bytes().get(i - 1) != Some(&b':') {
return Err(bad());
}
let (place, i) = title_field(t, i);
let (start, i) = title_field(t, i);
let (end, i) = title_field(t, i);
let (nth, i) = title_field(t, i);
if i != t.len() {
return Err(bad());
}
let parse_date = |s: &str| -> Result<Option<GwDate>> {
if s.is_empty() {
Ok(None)
} else {
date::parse(s).map_err(|kind| ctx.err(kind))
}
};
Ok(Title {
name,
ident,
place,
date_start: parse_date(&start)?,
date_end: parse_date(&end)?,
nth: if nth.is_empty() {
0
} else {
nth.parse().map_err(|_| bad())?
},
})
}
fn get_titles(cur: &mut Cursor<'_>, ctx: LineCtx<'_>) -> Result<Vec<Title>> {
let mut out = Vec::new();
while let Some(token) = cur.peek() {
let bytes = token.as_bytes();
if bytes.len() >= 2 && bytes[0] == b'[' && bytes[bytes.len() - 1] == b']' {
cur.advance();
let title = scan_title(&token[1..token.len() - 1], ctx)?;
if !title.ident.is_empty() {
out.push(title);
}
} else {
break;
}
}
Ok(out)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DateField {
Absent,
Unknown,
Known(GwDate),
}
impl DateField {
#[must_use]
pub fn into_date(self) -> Option<GwDate> {
match self {
Self::Known(date) => Some(date),
Self::Absent | Self::Unknown => None,
}
}
}
pub(crate) fn optional_date(
cur: &mut Cursor<'_>,
ctx: LineCtx<'_>,
baptism: bool,
) -> Result<DateField> {
let Some(token) = cur.peek() else {
return Ok(DateField::Absent);
};
let body = if baptism {
match token.strip_prefix('!') {
Some(rest) => rest,
None => return Ok(DateField::Absent),
}
} else {
if date::starts_baptism_date(token) {
return Ok(DateField::Absent);
}
token
};
if !date::starts_date(body) {
return Ok(DateField::Absent);
}
cur.advance();
let offset = token.len() - body.len();
Ok(
match date::parse_from(token, offset).map_err(|kind| ctx.err(kind))? {
Some(date) => DateField::Known(date),
None => DateField::Unknown,
},
)
}
fn get_death(cur: &mut Cursor<'_>, ctx: LineCtx<'_>) -> Result<Option<Death>> {
let Some(token) = cur.peek() else {
return Ok(None);
};
match token {
"?" => {
cur.advance();
return Ok(Some(Death::DontKnowIfDead));
}
"mj" => {
cur.advance();
return Ok(Some(Death::DeadYoung));
}
"od" => {
cur.advance();
return Ok(Some(Death::OfCourseDead));
}
_ => {}
}
let (reason, offset) = match first_byte(token) {
Some(b'k') => (DeathReason::Killed, 1),
Some(b'm') => (DeathReason::Murdered, 1),
Some(b'e') => (DeathReason::Executed, 1),
Some(b's') => (DeathReason::Disappeared, 1),
_ => (DeathReason::Unspecified, 0),
};
if offset >= token.len() || !date::starts_date(&token[offset..]) {
return Ok(None);
}
cur.advance();
let death = match date::parse_from(token, offset).map_err(|kind| ctx.err(kind))? {
Some(date) => Death::Dead { reason, date },
None => Death::DeadDontKnowWhen,
};
Ok(Some(death))
}
fn get_burial(cur: &mut Cursor<'_>, ctx: LineCtx<'_>) -> Result<Burial> {
let Some(tag) = cur.eat_any(&["#buri", "#crem"]) else {
return Ok(Burial::Unknown);
};
let mut date = None;
if let Some(token) = cur.peek() {
if date::starts_date(token) {
cur.advance();
date = date::parse(token).map_err(|kind| ctx.err(kind))?;
}
}
Ok(if tag == "#buri" {
Burial::Buried(date)
} else {
Burial::Cremated(date)
})
}
pub(crate) fn get_optional_sex(cur: &mut Cursor<'_>) -> Sex {
let (sex, token) = match cur.peek() {
Some("h" | "m") => (Sex::Male, true),
Some("f") => (Sex::Female, true),
_ => (Sex::Neuter, false),
};
if token && cur.peek_at(1).is_some() {
cur.advance();
sex
} else {
Sex::Neuter
}
}
pub fn set_infos(
identity: Identity<'_>,
defaults: FamilyDefaults<'_>,
cur: &mut Cursor<'_>,
ctx: LineCtx<'_>,
) -> Result<Person> {
let Identity {
first_name,
surname,
occ,
sex,
} = identity;
let FamilyDefaults {
sources: common_sources,
birth_place: common_birth_place,
} = defaults;
let first_names_aliases = get_first_name_aliases(cur);
let surnames_aliases = get_repeated(cur, "#salias");
let public_name = get_public_name(cur);
let image = get_image(cur);
let qualifiers = get_repeated(cur, "#nick");
let aliases = get_repeated(cur, "#alias");
let titles = get_titles(cur, ctx)?;
let access = get_access(cur);
let occupation = cur.field("#occu");
let sources = cur.field("#src");
let birth = optional_date(cur, ctx, false)?;
let birth_place = cur.field("#bp");
let birth_note = cur.field("#bn");
let birth_src = cur.field("#bs");
let baptism = optional_date(cur, ctx, true)?;
let baptism_place = {
let pp = cur.field("#pp");
if pp.is_empty() {
cur.field("#bp")
} else {
pp
}
};
let baptism_note = cur.field("#pn");
let baptism_src = cur.field("#ps");
let death_field = get_death(cur, ctx)?;
let death_place = cur.field("#dp");
let death_note = cur.field("#dn");
let death_src = cur.field("#ds");
let death = match (&birth, death_field) {
(_, Some(death)) => death,
(DateField::Known(_), None) => Death::NotDead,
(DateField::Absent | DateField::Unknown, None) => Death::DontKnowIfDead,
};
let burial = get_burial(cur, ctx)?;
let burial_place = cur.field("#rp");
let burial_note = cur.field("#rn");
let burial_src = cur.field("#rs");
Ok(Person {
first_name: first_name.to_owned(),
surname: surname.to_owned(),
occ,
sex,
first_names_aliases,
surnames_aliases,
public_name,
image,
qualifiers,
aliases,
titles,
access,
occupation,
sources: if sources.is_empty() {
common_sources.to_owned()
} else {
sources
},
birth: birth.into_date(),
birth_place: if birth_place.is_empty() {
common_birth_place.to_owned()
} else {
birth_place
},
birth_note,
birth_src,
baptism: baptism.into_date(),
baptism_place,
baptism_note,
baptism_src,
death,
death_place,
death_note,
death_src,
burial,
burial_place,
burial_note,
burial_src,
notes: String::new(),
events: Vec::new(),
relations: Vec::new(),
})
}
pub fn parse_parent(cur: &mut Cursor<'_>, ctx: LineCtx<'_>) -> Result<(Somebody, String)> {
let surname = get_name(cur);
let (first_name, occ) = get_first_name(cur, ctx)?;
let anonymous = first_name == "?" || surname == "?";
let defined = anonymous
|| match cur.peek() {
None => false,
Some(token) => first_byte(token) != Some(b'+'),
};
if !defined {
let key = Key::new(&first_name, &surname, occ);
return Ok((Somebody::Reference(key), surname));
}
let person = set_infos(
Identity::new(&first_name, &surname, occ),
FamilyDefaults::default(),
cur,
ctx,
)?;
Ok((Somebody::Definition(Box::new(person)), surname))
}
pub fn parse_child(
cur: &mut Cursor<'_>,
father_surname: &str,
sex: Sex,
defaults: FamilyDefaults<'_>,
ctx: LineCtx<'_>,
) -> Result<Person> {
let (first_name, occ) = get_first_name(cur, ctx)?;
let surname = match cur.peek() {
Some("?") => get_name(cur),
Some(token) => match first_byte(token) {
Some(b'<' | b'>' | b'!' | b'~' | b'?' | b'-' | b'0'..=b'9' | b'{' | b'#') => {
father_surname.to_owned()
}
Some(b'(' | b'[') => {
if first_name.is_empty() {
String::new()
} else {
father_surname.to_owned()
}
}
_ => get_name(cur),
},
None => father_surname.to_owned(),
};
set_infos(
Identity {
sex,
..Identity::new(&first_name, &surname, occ)
},
defaults,
cur,
ctx,
)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::date::{Calendar, Dmy, Precision};
use crate::lexer::fields;
fn ctx() -> LineCtx<'static> {
LineCtx { no: 1, raw: "" }
}
fn person(line: &str) -> Person {
let toks = fields(line);
let mut cur = Cursor::new(&toks);
let p = set_infos(
Identity {
sex: Sex::Male,
..Identity::new("Jean", "Dupont", 0)
},
FamilyDefaults::default(),
&mut cur,
ctx(),
)
.expect("should parse");
assert!(cur.is_empty(), "unconsumed tokens: {:?}", cur.remaining());
p
}
#[test]
fn field_order_is_positional() {
let p = person(concat!(
"{Jeannot} #salias Dupond (Le_Grand) #image p.jpg #nick Titi #alias Toto ",
"[comte:comte:Paris:1850:1860:2] #apubl #occu Marchand #src Archives ",
"7/9/1830 #bp Reims #bn nb #bs bs ",
"!8/9/1830 #pp Rouen #pn pn #ps ps ",
"12/5/1900 #dp Lyon #dn dn #ds ds ",
"#buri 14/5/1900 #rp Lyon #rn rn #rs rs",
));
assert_eq!(p.first_names_aliases, ["Jeannot"]);
assert_eq!(p.surnames_aliases, ["Dupond"]);
assert_eq!(p.public_name, "Le Grand");
assert_eq!(p.image, "p.jpg");
assert_eq!(p.qualifiers, ["Titi"]);
assert_eq!(p.aliases, ["Toto"]);
assert_eq!(p.titles.len(), 1);
assert_eq!(p.access, Access::Public);
assert_eq!(p.occupation, "Marchand");
assert_eq!(p.sources, "Archives");
assert_eq!(p.birth_place, "Reims");
assert_eq!(p.birth_note, "nb");
assert_eq!(p.baptism_place, "Rouen");
assert_eq!(p.death_place, "Lyon");
assert!(matches!(p.burial, Burial::Buried(Some(_))));
assert_eq!(p.burial_src, "rs");
}
#[test]
fn the_baptism_place_fallback_does_not_actually_fall_back() {
let p = person("1830 #bp Reims !1831");
assert_eq!(p.birth_place, "Reims");
assert_eq!(p.baptism_place, "");
let p = person("1830 #bp Reims !1831 #bp Rouen");
assert_eq!(p.baptism_place, "Rouen");
}
#[test]
fn a_birth_date_without_a_death_field_means_alive() {
assert_eq!(person("1950").death, Death::NotDead);
assert_eq!(person("0").death, Death::DontKnowIfDead);
assert_eq!(person("").death, Death::DontKnowIfDead);
}
#[test]
fn death_markers() {
assert_eq!(person("1900 ?").death, Death::DontKnowIfDead);
assert_eq!(person("1900 mj").death, Death::DeadYoung);
assert_eq!(person("1900 od").death, Death::OfCourseDead);
assert!(matches!(
person("1900 k1916").death,
Death::Dead {
reason: DeathReason::Killed,
..
}
));
assert!(matches!(
person("1900 s1916").death,
Death::Dead {
reason: DeathReason::Disappeared,
..
}
));
assert!(matches!(
person("1900 1980").death,
Death::Dead {
reason: DeathReason::Unspecified,
..
}
));
}
#[test]
fn titles_need_all_six_fields() {
let p = person("[*:duc:Bretagne:1450:1470:3]");
let t = &p.titles[0];
assert_eq!(t.name, TitleName::Main);
assert_eq!(t.ident, "duc");
assert_eq!(t.place, "Bretagne");
assert_eq!(t.nth, 3);
assert!(matches!(
t.date_start,
Some(GwDate::Structured {
dmy: Dmy { year: 1450, .. },
calendar: Calendar::Gregorian
})
));
let p = person("[:duc::::]");
assert_eq!(p.titles[0].name, TitleName::None);
let toks = fields("[duc:Bretagne]");
let mut cur = Cursor::new(&toks);
assert!(set_infos(
Identity::new("a", "b", 0),
FamilyDefaults::default(),
&mut cur,
ctx()
)
.is_err());
}
#[test]
fn a_title_with_an_empty_ident_is_dropped() {
assert!(person("[nom:::::]").titles.is_empty());
}
#[test]
fn escaping_a_colon_in_a_title_takes_two_backslashes() {
let p = person(r"[*:duc\\:roi:Bretagne:::]");
assert_eq!(p.titles[0].ident, "duc:roi");
let p = person(r"[*:duc\:roi:::]");
assert_eq!(p.titles[0].ident, "duc");
assert_eq!(p.titles[0].place, "roi");
}
#[test]
fn common_family_defaults_apply_only_when_absent() {
let toks = fields("1830");
let mut cur = Cursor::new(&toks);
let p = set_infos(
Identity {
sex: Sex::Male,
..Identity::new("A", "B", 0)
},
FamilyDefaults {
sources: "csrc",
birth_place: "cbp",
},
&mut cur,
ctx(),
)
.unwrap();
assert_eq!(p.sources, "csrc");
assert_eq!(p.birth_place, "cbp");
let toks = fields("#src own 1830 #bp here");
let mut cur = Cursor::new(&toks);
let p = set_infos(
Identity {
sex: Sex::Male,
..Identity::new("A", "B", 0)
},
FamilyDefaults {
sources: "csrc",
birth_place: "cbp",
},
&mut cur,
ctx(),
)
.unwrap();
assert_eq!(p.sources, "own");
assert_eq!(p.birth_place, "here");
}
#[test]
fn occurrence_numbers() {
let parse = |s: &str| {
let toks = fields(s);
let mut cur = Cursor::new(&toks);
get_first_name(&mut cur, ctx()).unwrap()
};
assert_eq!(parse("Jean"), ("Jean".into(), 0));
assert_eq!(parse("Jean.2"), ("Jean".into(), 2));
assert_eq!(parse("Jean."), ("Jean.".into(), 0));
assert_eq!(parse("St.Jean"), ("St.Jean".into(), 0));
}
#[test]
fn a_parent_is_a_reference_when_nothing_but_the_marriage_follows() {
let toks = fields("Dupont Jean +1850");
let mut cur = Cursor::new(&toks);
let (who, surname) = parse_parent(&mut cur, ctx()).unwrap();
assert_eq!(surname, "Dupont");
assert!(matches!(who, Somebody::Reference(_)));
let toks = fields("Dupont Jean 1820 +1850");
let mut cur = Cursor::new(&toks);
let (who, _) = parse_parent(&mut cur, ctx()).unwrap();
assert!(matches!(who, Somebody::Definition(_)));
}
#[test]
fn the_anonymous_person_is_always_a_definition() {
let toks = fields("? ?");
let mut cur = Cursor::new(&toks);
let (who, _) = parse_parent(&mut cur, ctx()).unwrap();
assert!(matches!(who, Somebody::Definition(_)));
}
#[test]
fn a_child_inherits_the_father_surname_unless_it_gives_one() {
let child = |s: &str| {
let toks = fields(s);
let mut cur = Cursor::new(&toks);
parse_child(
&mut cur,
"Galichet",
Sex::Male,
FamilyDefaults::default(),
ctx(),
)
.unwrap()
};
assert_eq!(child("Pierre 1814").surname, "Galichet");
assert_eq!(child("Pierre #occu Négociant").surname, "Galichet");
assert_eq!(child("Pierre Martin 1814").surname, "Martin");
assert_eq!(child("Pierre ? 1814").surname, "?");
assert_eq!(child("Pierre").surname, "Galichet");
}
#[test]
fn a_sex_marker_needs_something_after_it() {
let toks = fields("m Pierre");
let mut cur = Cursor::new(&toks);
assert_eq!(get_optional_sex(&mut cur), Sex::Male);
assert_eq!(cur.peek(), Some("Pierre"));
let toks = fields("m");
let mut cur = Cursor::new(&toks);
assert_eq!(get_optional_sex(&mut cur), Sex::Neuter);
assert_eq!(cur.peek(), Some("m"));
}
#[test]
fn access_accepts_the_retired_spelling() {
assert_eq!(person("#apriv").access, Access::Private);
assert_eq!(person("#semipub").access, Access::SemiPublic);
assert_eq!(person("#afriend").access, Access::SemiPublic);
assert_eq!(person("").access, Access::IfTitles);
}
#[test]
fn image_accepts_both_spellings() {
assert_eq!(person("#image a.jpg").image, "a.jpg");
assert_eq!(person("#photo b.jpg").image, "b.jpg");
}
#[test]
fn repeated_tags_accumulate() {
let p = person("#nick Titi #nick Toto #alias A #alias B");
assert_eq!(p.qualifiers, ["Titi", "Toto"]);
assert_eq!(p.aliases, ["A", "B"]);
}
#[test]
fn precision_survives_into_the_person() {
let p = person("<1849");
assert!(matches!(
p.birth,
Some(GwDate::Structured {
dmy: Dmy {
precision: Precision::Before,
year: 1849,
..
},
..
})
));
}
}