gedcomkit 0.1.8__tar.gz → 0.1.9__tar.gz

{gedcomkit-0.1.8 → gedcomkit-0.1.9}/CHANGELOG.md

@@ -5,6 +5,32 @@ format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 the project uses semantic versioning within the usual pre-1.0 compatibility
 rules.
 
+## [0.1.9] - 2026-09-27
+
+### Fixed
+
+- `validate::inspect` drew years from dates the reader could not read: a
+  year merely mentioned in an unreadable payload (`WFT Est 1804-1911`) was
+  taken as the event's year, contrary to the module's own rule, and made
+  contradictions out of nothing. Such dates are now left out of every check.
+- A date that bounds a year rather than naming one (`BEF 1811`, `AFT 1850`,
+  `BET 1800 AND 1810`) was compared as if it named its one mentioned year.
+  Checks now compare the years a date admits, so a finding is reported only
+  when no year both dates allow could be true, and the message says the
+  bounds it was drawn from (`born 1807 and died before 1805`; a parent age
+  of `at most 10 years old`).
+- A birth dated after a death was reported twice, as `died-before-born` and
+  as `event-after-death`; it is now reported once.
+- A Hebrew or French Republican year was compared as if it were Gregorian;
+  such dates are now left out of the checks. A range written backwards
+  (`BET 1910 AND 1900`) admits the same years as one written forwards.
+- `child-born-after-mother-died` was skipped whenever the mother's own birth
+  year was unknown, although it needs only her death and the child's birth;
+  it now runs whenever those two are known, and alongside a
+  `parent-too-young` finding rather than instead of one. A child born before
+  its parent is worded as such (`5 years before the parent was born`), and a
+  lifespan between two exact years is stated exactly.
+
 ## [0.1.8] - 2026-09-27
 
 ### Added

{gedcomkit-0.1.8 → gedcomkit-0.1.9}/Cargo.lock

@@ -35,7 +35,7 @@ dependencies = [
 
 [[package]]
 name = "gedcomkit"
-version = "0.1.8"
+version = "0.1.9"
 dependencies = [
  "flate2",
  "serde",

{gedcomkit-0.1.8 → gedcomkit-0.1.9}/Cargo.toml

@@ -3,7 +3,7 @@
 # was checked on crates.io, npm, and PyPI before the initial release.
 [package]
 name = "gedcomkit"
-version = "0.1.8"
+version = "0.1.9"
 description = "A byte-preserving GEDCOM document model: decoding, parsing, readings, version conversion, plausibility checks, and the GEDZIP container, for GEDCOM 5.5 through 7.x."
 edition = "2024"
 # The true minimum, not the workspace's toolchain: a parser library is a leaf

{gedcomkit-0.1.8 → gedcomkit-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gedcomkit
-Version: 0.1.8
+Version: 0.1.9
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython

{gedcomkit-0.1.8 → gedcomkit-0.1.9}/bindings/gedcomkit-py/Cargo.lock

@@ -35,7 +35,7 @@ dependencies = [
 
 [[package]]
 name = "gedcomkit"
-version = "0.1.8"
+version = "0.1.9"
 dependencies = [
  "flate2",
  "serde",
@@ -43,7 +43,7 @@ dependencies = [
 
 [[package]]
 name = "gedcomkit-py"
-version = "0.1.8"
+version = "0.1.9"
 dependencies = [
  "gedcomkit",
  "pyo3",

{gedcomkit-0.1.8 → gedcomkit-0.1.9}/bindings/gedcomkit-py/Cargo.toml

@@ -2,7 +2,7 @@
 # abi3 keeps it to one wheel per platform across Python versions.
 [package]
 name = "gedcomkit-py"
-version = "0.1.8"
+version = "0.1.9"
 description = "Python bindings for gedcomkit: an archival-grade GEDCOM library — byte-preserving round-trip, encoding detection, GEDCOM 5.5 through 7.x, GEDZIP."
 edition = "2024"
 rust-version = "1.88"

{gedcomkit-0.1.8 → gedcomkit-0.1.9}/src/validate.rs

@@ -20,12 +20,18 @@
 //! **A date nobody can read is not a contradiction.** Half the dates in a real
 //! file are approximate, and a check that treats "about 1850" as a claim about
 //! a particular day produces a page of findings nobody will read twice. Only
-//! years are compared, and only where a year was actually recovered.
-
-use crate::dates::GedcomDate;
+//! years are compared, and only where the date reader recovered a reading: a
+//! year merely *mentioned* in an unreadable payload (`WFT Est 1804-1911`) says
+//! nothing about when the event happened. A date that bounds a year rather
+//! than naming one — `BEF 1811`, `AFT 1850`, `BET 1804 AND 1911` — is
+//! compared by its bounds, so it contradicts another only when no year it
+//! admits could be true.
+
+use crate::dates::{Calendar, GedcomDate};
 use crate::view::{FamilyView, IndividualView, record_title};
 use crate::{Document, Node};
 use std::collections::HashMap;
+use std::fmt;
 
 /// How much a finding is claiming.
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
@@ -81,12 +87,81 @@ const OLDEST_FATHER: i32 = 80;
 /// A parent younger than this at a birth is almost always a mis-keyed year.
 const YOUNGEST_PARENT: i32 = 12;
 
+/// The years a date admits: its earliest and latest, either open when the
+/// date bounds only one side (`BEF 1811` has no earliest).
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct Years {
+    earliest: Option<i32>,
+    latest: Option<i32>,
+}
+
+impl Years {
+    /// The years a `DATE` payload admits, or `None` when the reader could not
+    /// read it — a year that merely appears in unreadable text is not used.
+    ///
+    /// Only Gregorian and Julian years are comparable with each other; a
+    /// Hebrew or French Republican year counts from another epoch, so such a
+    /// date is left out rather than compared as if it were Gregorian. A range
+    /// written backwards (`BET 1910 AND 1900`) admits the same years as one
+    /// written forwards.
+    fn of(payload: &str) -> Option<Self> {
+        let date = GedcomDate::parse(payload);
+        if !date.is_parsed() || !matches!(date.calendar, Calendar::Gregorian | Calendar::Julian) {
+            return None;
+        }
+        let mut years = Self {
+            earliest: date.earliest.map(|point| point.year),
+            latest: date.latest.map(|point| point.year),
+        };
+        if let (Some(start), Some(end)) = (years.earliest, years.latest)
+            && start > end
+        {
+            years = Self {
+                earliest: Some(end),
+                latest: Some(start),
+            };
+        }
+        (years.earliest.is_some() || years.latest.is_some()).then_some(years)
+    }
+
+    /// Whether every year this admits comes before every year `other` admits.
+    const fn wholly_before(self, other: Self) -> bool {
+        matches!((self.latest, other.earliest), (Some(end), Some(start)) if end < start)
+    }
+
+    /// The smallest and largest number of years from `self` to `later` that
+    /// the two dates allow, each `None` when a bound is open.
+    fn gap_to(self, later: Self) -> (Option<i32>, Option<i32>) {
+        let least = later
+            .earliest
+            .zip(self.latest)
+            .map(|(end, start)| end - start);
+        let most = later
+            .latest
+            .zip(self.earliest)
+            .map(|(end, start)| end - start);
+        (least, most)
+    }
+}
+
+impl fmt::Display for Years {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match (self.earliest, self.latest) {
+            (Some(start), Some(end)) if start == end => write!(formatter, "{start}"),
+            (Some(start), Some(end)) => write!(formatter, "between {start} and {end}"),
+            (None, Some(end)) => write!(formatter, "before {end}"),
+            (Some(start), None) => write!(formatter, "after {start}"),
+            (None, None) => formatter.write_str("undated"),
+        }
+    }
+}
+
 /// What one person's record says about when they lived.
 #[derive(Clone, Copy, Default)]
 struct Life {
-    born: Option<i32>,
-    died: Option<i32>,
-    buried: Option<i32>,
+    born: Option<Years>,
+    died: Option<Years>,
+    buried: Option<Years>,
 }
 
 /// Every finding in the document, in record order.
@@ -119,12 +194,12 @@ pub fn inspect(document: &Document) -> Vec<Finding> {
     found
 }
 
-fn year_of(view: &IndividualView, tag: &str) -> Option<i32> {
+fn year_of(view: &IndividualView, tag: &str) -> Option<Years> {
     view.events
         .iter()
         .find(|event| event.tag == tag)
         .and_then(|event| event.date.as_deref())
-        .and_then(|payload| GedcomDate::parse(payload).year_hint())
+        .and_then(Years::of)
 }
 
 fn life_of(view: &IndividualView) -> Life {
@@ -162,7 +237,7 @@ fn inspect_person(
         .unwrap_or_default();
 
     if let (Some(born), Some(died)) = (life.born, life.died) {
-        if died < born {
+        if died.wholly_before(born) {
             add(
                 found,
                 record,
@@ -170,22 +245,28 @@ fn inspect_person(
                 Severity::Contradiction,
                 format!("born {born} and died {died}"),
             );
-        } else if died - born > LONGEST_LIFE {
+        } else if let (Some(shortest), _) = born.gap_to(died)
+            && shortest > LONGEST_LIFE
+        {
             add(
                 found,
                 record,
                 "improbable-lifespan",
                 Severity::Question,
                 format!(
-                    "born {born} and died {died}, which is {} years",
-                    died - born
+                    "born {born} and died {died}, which is {}{shortest} years",
+                    if born.gap_to(died).1 == Some(shortest) {
+                        ""
+                    } else {
+                        "at least "
+                    }
                 ),
             );
         }
     }
 
     if let (Some(died), Some(buried)) = (life.died, life.buried)
-        && buried < died
+        && buried.wholly_before(died)
     {
         add(
             found,
@@ -197,23 +278,20 @@ fn inspect_person(
     }
 
     // An event after the funeral is either a wrong year or a second person.
-    // Probate and a will are the two that legitimately come after a death.
+    // Probate and a will are the two that legitimately come after a death;
+    // a birth after it is already `died-before-born`, reported once.
     if let Some(died) = life.died {
         for event in &view.events {
             if matches!(
                 event.tag.as_str(),
-                "DEAT" | "BURI" | "CREM" | "PROB" | "WILL"
+                "BIRT" | "DEAT" | "BURI" | "CREM" | "PROB" | "WILL"
             ) {
                 continue;
             }
-            let Some(year) = event
-                .date
-                .as_deref()
-                .and_then(|payload| GedcomDate::parse(payload).year_hint())
-            else {
+            let Some(year) = event.date.as_deref().and_then(Years::of) else {
                 continue;
             };
-            if year > died {
+            if died.wholly_before(year) {
                 add(
                     found,
                     record,
@@ -244,7 +322,7 @@ fn inspect_family(record: &Node, lives: &HashMap<String, Life>, found: &mut Vec<
     let married = record
         .first("MARR")
         .and_then(|event| event.value_of("DATE"))
-        .and_then(|payload| GedcomDate::parse(&payload).year_hint());
+        .and_then(|payload| Years::of(&payload));
 
     for parent in family.partners() {
         let Some(parent_life) = lives.get(&parent.to_ascii_uppercase()).copied() else {
@@ -293,30 +371,55 @@ fn inspect_family(record: &Node, lives: &HashMap<String, Life>, found: &mut Vec<
     }
 }
 
-fn inspect_marriage(record: &Node, married: Option<i32>, parent: Life, found: &mut Vec<Finding>) {
+fn inspect_marriage(record: &Node, married: Option<Years>, parent: Life, found: &mut Vec<Finding>) {
     let (Some(married), Some(born)) = (married, parent.born) else {
         return;
     };
-    let age = married - born;
-    if age < 0 {
+    if married.wholly_before(born) {
         add(
             found,
             record,
             "married-before-born",
             Severity::Contradiction,
-            format!("a marriage in {married} for somebody born {born}"),
+            format!("a marriage {} for somebody born {born}", in_year(married)),
         );
-    } else if age < YOUNGEST_MARRIAGE {
+    } else if let (_, Some(oldest)) = born.gap_to(married)
+        && oldest < YOUNGEST_MARRIAGE
+    {
         add(
             found,
             record,
             "married-as-a-child",
             Severity::Question,
-            format!("married in {married} at {age}, born {born}"),
+            format!(
+                "married {} {}, born {born}",
+                in_year(married),
+                age(born, married)
+            ),
         );
     }
 }
 
+/// `in 1900`, or the bounded form (`before 1811`) as it stands.
+fn in_year(years: Years) -> String {
+    match (years.earliest, years.latest) {
+        (Some(start), Some(end)) if start == end => format!("in {start}"),
+        _ => years.to_string(),
+    }
+}
+
+/// The age between two dates as a phrase: `at 9` when both are single years,
+/// the range the dates allow otherwise (`at 9 to 12`, `at most 9`).
+fn age(from: Years, to: Years) -> String {
+    match from.gap_to(to) {
+        (Some(least), Some(most)) if least == most => format!("at {least}"),
+        (Some(least), Some(most)) => format!("at {least} to {most}"),
+        (Some(least), None) => format!("at least {least}"),
+        (None, Some(most)) => format!("at most {most}"),
+        (None, None) => "at an unknown age".to_owned(),
+    }
+}
+
 fn inspect_parenthood(
     record: &Node,
     parent: Life,
@@ -324,46 +427,64 @@ fn inspect_parenthood(
     mother: bool,
     found: &mut Vec<Finding>,
 ) {
-    let (Some(parent_born), Some(child_born)) = (parent.born, child.born) else {
+    let Some(child_born) = child.born else {
         return;
     };
-    let age = child_born - parent_born;
-    if age < YOUNGEST_PARENT {
-        let how = if age < 0 { "before" } else { "at" };
+
+    // A father may die before a birth; a mother may not. This needs only her
+    // death and the child's birth, not her own birth year.
+    if let (true, Some(parent_died)) = (mother, parent.died)
+        && parent_died.wholly_before(child_born)
+    {
         add(
             found,
             record,
-            "parent-too-young",
+            "child-born-after-mother-died",
             Severity::Contradiction,
-            format!(
-                "a parent born {parent_born} with a child born {child_born}, {how} {} years old",
-                age.abs()
-            ),
+            format!("a mother who died {parent_died} with a child born {child_born}"),
         );
-        return;
     }
 
-    let limit = if mother { OLDEST_MOTHER } else { OLDEST_FATHER };
-    if age > limit {
+    let Some(parent_born) = parent.born else {
+        return;
+    };
+    let (youngest, oldest) = parent_born.gap_to(child_born);
+    // Too young only if even the oldest age the dates allow is too young.
+    if let Some(oldest) = oldest
+        && oldest < YOUNGEST_PARENT
+    {
+        // The sign decides the wording: a negative oldest age means the child
+        // was born before the parent whatever the dates' ranges.
+        let said = if oldest < 0 {
+            format!("{} years before the parent was born", oldest.abs())
+        } else if youngest == Some(oldest) {
+            format!("at {oldest} years old")
+        } else {
+            format!("at most {oldest} years old")
+        };
         add(
             found,
             record,
-            "parent-too-old",
-            Severity::Question,
-            format!("a parent born {parent_born} with a child born {child_born}, at {age}"),
+            "parent-too-young",
+            Severity::Contradiction,
+            format!("a parent born {parent_born} with a child born {child_born}, {said}"),
         );
+        return;
     }
 
-    // A father may die before a birth; a mother may not.
-    if let (true, Some(parent_died)) = (mother, parent.died)
-        && child_born > parent_died
+    let limit = if mother { OLDEST_MOTHER } else { OLDEST_FATHER };
+    if let Some(youngest) = youngest
+        && youngest > limit
     {
         add(
             found,
             record,
-            "child-born-after-mother-died",
-            Severity::Contradiction,
-            format!("a mother who died {parent_died} with a child born {child_born}"),
+            "parent-too-old",
+            Severity::Question,
+            format!(
+                "a parent born {parent_born} with a child born {child_born}, {}",
+                age(parent_born, child_born)
+            ),
         );
     }
 }
@@ -549,6 +670,155 @@ mod tests {
         );
     }
 
+    #[test]
+    fn a_year_mentioned_in_an_unreadable_date_is_not_a_death_year() {
+        // `WFT Est 1804-1911` mentions 1804; it does not say the person died
+        // then, so a birth in 1807 contradicts nothing.
+        let found = findings(
+            "0 HEAD\n0 @I1@ INDI\n1 BIRT\n2 DATE 1807\n1 DEAT\n2 DATE WFT Est 1804-1911\n0 TRLR\n",
+        );
+        assert!(
+            !checks(&found).contains(&"died-before-born")
+                && !checks(&found).contains(&"event-after-death"),
+            "{found:?}"
+        );
+    }
+
+    #[test]
+    fn a_bounded_date_contradicts_only_when_no_year_it_allows_could_be_true() {
+        // Died before 1811 and born 1807: both can be true.
+        let found =
+            findings("0 HEAD\n0 @I1@ INDI\n1 BIRT\n2 DATE 1807\n1 DEAT\n2 DATE BEF 1811\n0 TRLR\n");
+        assert!(!checks(&found).contains(&"died-before-born"), "{found:?}");
+        // Died before 1805 and born 1807: they cannot.
+        let found =
+            findings("0 HEAD\n0 @I1@ INDI\n1 BIRT\n2 DATE 1807\n1 DEAT\n2 DATE BEF 1805\n0 TRLR\n");
+        let died = found
+            .iter()
+            .find(|finding| finding.check == "died-before-born")
+            .expect("a contradiction");
+        assert_eq!(died.message, "born 1807 and died before 1805");
+        // A range is compared by both of its ends.
+        let found = findings(
+            "0 HEAD\n0 @I1@ INDI\n1 BIRT\n2 DATE BET 1800 AND 1810\n1 DEAT\n2 DATE 1805\n0 TRLR\n",
+        );
+        assert!(!checks(&found).contains(&"died-before-born"), "{found:?}");
+    }
+
+    #[test]
+    fn a_bounded_marriage_says_its_age_once() {
+        let found = findings(
+            "0 HEAD\n\
+0 @I1@ INDI\n\
+1 BIRT\n\
+2 DATE 1802\n\
+0 @F1@ FAM\n\
+1 HUSB @I1@\n\
+1 MARR\n\
+2 DATE BEF 1811\n\
+0 TRLR\n",
+        );
+        let child = found
+            .iter()
+            .find(|finding| finding.check == "married-as-a-child")
+            .expect("married as a child");
+        assert_eq!(child.message, "married before 1811 at most 9, born 1802");
+    }
+
+    #[test]
+    fn another_calendar_and_a_backwards_range_are_not_misread() {
+        // 5620 is a Hebrew year (1859-60), not a birth after a death in 1900.
+        let found = findings(
+            "0 HEAD\n\
+0 @I1@ INDI\n\
+1 BIRT\n\
+2 DATE @#DHEBREW@ 5620\n\
+1 DEAT\n\
+2 DATE 1900\n\
+0 TRLR\n",
+        );
+        assert!(!checks(&found).contains(&"died-before-born"), "{found:?}");
+        let found = findings(
+            "0 HEAD\n\
+0 @I1@ INDI\n\
+1 BIRT\n\
+2 DATE BET 1910 AND 1900\n\
+1 DEAT\n\
+2 DATE 1905\n\
+0 TRLR\n",
+        );
+        assert!(!checks(&found).contains(&"died-before-born"), "{found:?}");
+    }
+
+    #[test]
+    fn a_child_born_before_its_parent_says_so_plainly() {
+        let found = findings(
+            "0 HEAD\n\
+0 @I1@ INDI\n\
+1 BIRT\n\
+2 DATE BET 1850 AND 1855\n\
+0 @I2@ INDI\n\
+1 BIRT\n\
+2 DATE BET 1840 AND 1845\n\
+0 @F1@ FAM\n\
+1 HUSB @I1@\n\
+1 CHIL @I2@\n\
+0 TRLR\n",
+        );
+        let young = found
+            .iter()
+            .find(|finding| finding.check == "parent-too-young")
+            .expect("born before the parent");
+        assert!(
+            young
+                .message
+                .ends_with("5 years before the parent was born"),
+            "{}",
+            young.message
+        );
+    }
+
+    #[test]
+    fn a_mother_dead_before_the_birth_needs_no_birth_year_of_her_own() {
+        let found = findings(
+            "0 HEAD\n\
+0 @I1@ INDI\n\
+1 DEAT\n\
+2 DATE 1850\n\
+0 @I2@ INDI\n\
+1 BIRT\n\
+2 DATE 1860\n\
+0 @F1@ FAM\n\
+1 WIFE @I1@\n\
+1 CHIL @I2@\n\
+0 TRLR\n",
+        );
+        assert!(
+            checks(&found).contains(&"child-born-after-mother-died"),
+            "{found:?}"
+        );
+    }
+
+    #[test]
+    fn a_parent_with_a_bounded_birth_is_too_young_only_when_every_age_is() {
+        let family = |parent: &str, child: &str| {
+            findings(&format!(
+                "0 HEAD\n0 @I1@ INDI\n1 BIRT\n2 DATE {parent}\n0 @I2@ INDI\n1 BIRT\n2 DATE {child}\n\
+0 @F1@ FAM\n1 HUSB @I1@\n1 CHIL @I2@\n0 TRLR\n"
+            ))
+        };
+        assert!(!checks(&family("AFT 1850", "1870")).contains(&"parent-too-young"));
+        let found = family("BET 1860 AND 1865", "1870");
+        let young = found
+            .iter()
+            .find(|finding| finding.check == "parent-too-young")
+            .expect("too young at every allowed age");
+        assert_eq!(
+            young.message,
+            "a parent born between 1860 and 1865 with a child born 1870, at most 10 years old"
+        );
+    }
+
     #[test]
     fn a_clean_record_produces_nothing_but_what_is_actually_missing() {
         let found = findings(