gedcomkit 0.1.13__tar.gz → 0.1.14__tar.gz

{gedcomkit-0.1.13 → gedcomkit-0.1.14}/CHANGELOG.md

@@ -5,6 +5,24 @@ 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.14] - 2026-10-10
+
+### Fixed
+
+- `IndividualView::life_years` now reads the birth year from the first
+  `BIRT` that has a year, else the first `CHR` with one, else the first
+  `BAPM`. Before, it looked only at `BIRT` then `CHR`, and at the first event
+  with the tag even when its date did not parse, so a dateless `BIRT` ahead of
+  a dated one gave no year. `IndividualView::event_year` is unchanged. The
+  death year is still `DEAT` only.
+
+### Changed
+
+- `Document::record` and `Document::record_mut` no longer allocate an
+  upper-cased copy of every identifier they scan; they compare ASCII
+  case-insensitively in place. Matching is identical to before (ASCII case
+  folding only, first duplicate wins) and to `Document::xref_index`.
+
 ## [0.1.13] - 2026-10-02
 
 ### Fixed

{gedcomkit-0.1.13 → gedcomkit-0.1.14}/Cargo.lock

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

{gedcomkit-0.1.13 → gedcomkit-0.1.14}/Cargo.toml

@@ -3,7 +3,7 @@
 # was checked on crates.io, npm, and PyPI before the initial release.
 [package]
 name = "gedcomkit"
-version = "0.1.13"
+version = "0.1.14"
 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.13 → gedcomkit-0.1.14}/PKG-INFO

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

{gedcomkit-0.1.13 → gedcomkit-0.1.14}/bindings/gedcomkit-py/Cargo.lock

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

{gedcomkit-0.1.13 → gedcomkit-0.1.14}/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.13"
+version = "0.1.14"
 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.13 → gedcomkit-0.1.14}/src/build.rs

@@ -455,14 +455,13 @@ impl Document {
                 ),
             ));
         }
-        let wanted = record.to_ascii_uppercase();
         let owner = self
             .records
             .iter_mut()
             .find(|node| {
                 node.xref.as_ref().map_or_else(
                     || node.tag == record,
-                    |xref| xref.to_ascii_uppercase() == wanted,
+                    |xref| xref.eq_ignore_ascii_case(record),
                 )
             })
             .ok_or_else(|| fault(0, GedcomErrorKind::Structure, format!("no record {record}")))?;

{gedcomkit-0.1.13 → gedcomkit-0.1.14}/src/lib.rs

@@ -847,23 +847,24 @@ impl Document {
     /// case and `xref-case.ged` in the fixture corpus proves it matters.
     #[must_use]
     pub fn record(&self, xref: &str) -> Option<&Node> {
-        let wanted = xref.to_ascii_uppercase();
+        // `eq_ignore_ascii_case` is exactly "equal after `to_ascii_uppercase`"
+        // (non-ASCII bytes compare as themselves), without allocating an
+        // upper-cased copy of every identifier scanned.
         self.records.iter().find(|record| {
             record
                 .xref
                 .as_ref()
-                .is_some_and(|own| own.to_ascii_uppercase() == wanted)
+                .is_some_and(|own| own.eq_ignore_ascii_case(xref))
         })
     }
 
     /// The record with this cross-reference identifier, mutably.
     pub fn record_mut(&mut self, xref: &str) -> Option<&mut Node> {
-        let wanted = xref.to_ascii_uppercase();
         self.records.iter_mut().find(|record| {
             record
                 .xref
                 .as_ref()
-                .is_some_and(|own| own.to_ascii_uppercase() == wanted)
+                .is_some_and(|own| own.eq_ignore_ascii_case(xref))
         })
     }
 
@@ -1297,6 +1298,44 @@ mod tests {
         }
     }
 
+    #[test]
+    fn lookup_folds_ascii_case_only_and_the_first_duplicate_wins() {
+        let document = Document::parse(
+            "0 HEAD\n0 @a1@ INDI\n1 NAME First\n0 @A1@ INDI\n1 NAME Second\n\
+0 @\u{e9}1@ INDI\n0 @\u{c9}1@ INDI\n1 NAME Upper\n0 TRLR\n",
+        )
+        .expect("parse");
+
+        // Case-insensitive for ASCII, and the earlier duplicate is the one found.
+        for wanted in ["@a1@", "@A1@"] {
+            let found = document.record(wanted).expect("found");
+            assert_eq!(found.xref.as_deref(), Some("@a1@"));
+        }
+        // Non-ASCII letters are not case-folded, matching `xref_index`.
+        assert_eq!(
+            document
+                .record("@\u{e9}1@")
+                .and_then(|node| node.xref.as_deref()),
+            Some("@\u{e9}1@")
+        );
+        assert_eq!(
+            document
+                .record("@\u{c9}1@")
+                .and_then(|node| node.xref.as_deref()),
+            Some("@\u{c9}1@")
+        );
+        assert!(document.record("@z9@").is_none());
+
+        let index = document.xref_index();
+        assert_eq!(index["@A1@"], 1);
+        assert_ne!(index["@\u{c9}1@"], index["@\u{e9}1@"]);
+
+        let mut document = document;
+        let found = document.record_mut("@A1@").expect("found mutably");
+        assert_eq!(found.xref.as_deref(), Some("@a1@"));
+        assert!(document.record_mut("@\u{c9}1@").is_some());
+    }
+
     #[test]
     fn next_xref_continues_the_files_own_numbering() {
         let document = Document::parse("0 HEAD\n0 @I1@ INDI\n0 @I7@ INDI\n0 @F1@ FAM\n0 TRLR\n")

{gedcomkit-0.1.13 → gedcomkit-0.1.14}/src/view.rs

@@ -452,11 +452,30 @@ impl IndividualView {
             .and_then(|event| event.year)
     }
 
+    /// The year of the first event with this tag whose date parsed.
+    ///
+    /// [`IndividualView::event_year`] stops at the first event with the tag,
+    /// so a dateless `BIRT` hides a dated one after it; a displayed birth year
+    /// should not be lost that way. That method keeps its documented meaning
+    /// and this private helper serves [`IndividualView::life_years`].
+    fn first_year(&self, tag: &str) -> Option<i32> {
+        self.events
+            .iter()
+            .filter(|event| event.tag == tag)
+            .find_map(|event| event.year)
+    }
+
     /// The years to show beside a name: birth and death, when they parsed.
+    ///
+    /// The birth year is the first `BIRT` with a year, else the first `CHR`
+    /// with one, else the first `BAPM`; the death year is `DEAT` only.
     #[must_use]
     pub fn life_years(&self) -> Option<String> {
-        let year = |tag: &str| self.event_year(tag);
-        match (year("BIRT").or_else(|| year("CHR")), year("DEAT")) {
+        let birth = self
+            .first_year("BIRT")
+            .or_else(|| self.first_year("CHR"))
+            .or_else(|| self.first_year("BAPM"));
+        match (birth, self.first_year("DEAT")) {
             (Some(birth), Some(death)) => Some(format!("{birth}–{death}")),
             (Some(birth), None) => Some(format!("b. {birth}")),
             (None, Some(death)) => Some(format!("d. {death}")),
@@ -634,6 +653,46 @@ mod tests {
         assert_eq!(view.identifiers[0].kind.as_deref(), Some("FamilySearch"));
     }
 
+    fn life_years_of(body: &str) -> Option<String> {
+        let text = format!("0 HEAD\n0 @I1@ INDI\n{body}0 TRLR\n");
+        let document = Document::parse(&text).expect("parse");
+        IndividualView::from_node(document.record("@I1@").expect("individual")).life_years()
+    }
+
+    #[test]
+    fn a_birth_year_skips_events_whose_date_gave_none() {
+        // A dateless BIRT before a dated one still yields the year.
+        let body = "1 BIRT\n1 BIRT\n2 DATE 1850\n";
+        assert_eq!(life_years_of(body).as_deref(), Some("b. 1850"));
+        // An unparsed date is skipped the same way.
+        let body = "1 BIRT\n2 DATE nonsense\n1 BIRT\n2 DATE 1851\n";
+        assert_eq!(life_years_of(body).as_deref(), Some("b. 1851"));
+        // event_year keeps its documented first-event meaning.
+        let document =
+            Document::parse("0 HEAD\n0 @I1@ INDI\n1 BIRT\n1 BIRT\n2 DATE 1850\n0 TRLR\n")
+                .expect("parse");
+        let view = IndividualView::from_node(document.record("@I1@").expect("individual"));
+        assert_eq!(view.event_year("BIRT"), None);
+    }
+
+    #[test]
+    fn a_birth_year_falls_back_from_birth_to_christening_to_baptism() {
+        let bapm = "1 BAPM\n2 DATE 1802\n";
+        assert_eq!(life_years_of(bapm).as_deref(), Some("b. 1802"));
+        let both = "1 BAPM\n2 DATE 1802\n1 CHR\n2 DATE 1801\n";
+        assert_eq!(life_years_of(both).as_deref(), Some("b. 1801"));
+        let all = "1 BAPM\n2 DATE 1802\n1 CHR\n2 DATE 1801\n1 BIRT\n2 DATE 1800\n";
+        assert_eq!(life_years_of(all).as_deref(), Some("b. 1800"));
+        // A dateless BIRT does not block the fallback.
+        let dateless = "1 BIRT\n1 CHR\n2 DATE 1801\n";
+        assert_eq!(life_years_of(dateless).as_deref(), Some("b. 1801"));
+        // Death stays DEAT only: a burial year is not a death year.
+        let burial = "1 BAPM\n2 DATE 1802\n1 BURI\n2 DATE 1870\n";
+        assert_eq!(life_years_of(burial).as_deref(), Some("b. 1802"));
+        let died = "1 BAPM\n2 DATE 1802\n1 DEAT\n2 DATE 1870\n";
+        assert_eq!(life_years_of(died).as_deref(), Some("1802–1870"));
+    }
+
     #[test]
     fn a_record_type_we_do_not_know_still_has_a_title_and_a_view() {
         let record = Document::parse("0 HEAD\n0 @X1@ _OPAQUE\n1 QUERY Tova Testwright\n0 TRLR\n")