gedcomkit 0.1.19__tar.gz → 0.1.20__tar.gz

{gedcomkit-0.1.19 → gedcomkit-0.1.20}/CHANGELOG.md

@@ -7,6 +7,18 @@ rules.
 
 ## [Unreleased]
 
+## [0.1.20] - 2026-11-09
+
+### Fixed
+
+- The date reader reads a calendar named after a qualifier or a range
+  word, as both grammars write it: `INT @#DJULIAN@ 2 MAR 1700 (…)`,
+  `BEF @#DJULIAN@ 2 JAN 1700`, `ABT JULIAN 1700`, `BET @#DJULIAN@ 1700 AND
+  @#DJULIAN@ 1710`. Such a date was left unparsed before, though
+  `to_gedcom_5_5_1` writes exactly this form, so what it wrote did not read
+  back. A range whose ends name different calendars, or whose unnamed end
+  (Gregorian) disagrees with a named one, stays unparsed.
+
 ## [0.1.19] - 2026-10-17
 
 ### Added

{gedcomkit-0.1.19 → gedcomkit-0.1.20}/Cargo.lock

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

{gedcomkit-0.1.19 → gedcomkit-0.1.20}/Cargo.toml

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

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

{gedcomkit-0.1.19 → gedcomkit-0.1.20}/README.md

@@ -42,12 +42,8 @@ npm install gedcomkit
 2. Run the gates and release dry run:
 
    ```bash
-   cargo fmt --all --check
-   cargo clippy --all-features --all-targets -- -D warnings
-   cargo test --all-features
-   cargo test --no-default-features
-   cargo check --manifest-path bindings/gedcomkit-wasm/Cargo.toml --target wasm32-unknown-unknown
-   cargo check --manifest-path bindings/gedcomkit-py/Cargo.toml
+   cargo ci
+   cargo +1.88 ci test
    cargo publish --locked --dry-run
    bash scripts/check-release-tag.sh vX.Y.Z
    ```

{gedcomkit-0.1.19 → gedcomkit-0.1.20}/bindings/gedcomkit-py/Cargo.lock

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

{gedcomkit-0.1.19 → gedcomkit-0.1.20}/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.19"
+version = "0.1.20"
 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.19 → gedcomkit-0.1.20}/src/build.rs

@@ -316,7 +316,7 @@ impl Node {
     /// beside a space loses that space on re-joining. Failing that — a run
     /// of spaces wider than the limit, say — the cut falls back to the
     /// latest legal byte boundary instead, which is documented behavior of
-    /// [`cut`] this call reuses, not a special case here.
+    /// the private `cut` this call reuses, not a special case here.
     ///
     /// The rendered line is measured in UTF-8 bytes, including level,
     /// optional cross-reference, tag, delimiters, and a terminator reserved

{gedcomkit-0.1.19 → gedcomkit-0.1.20}/src/dates.rs

@@ -300,8 +300,19 @@ impl GedcomDate {
     pub fn parse(payload: &str) -> Self {
         let original = payload.to_owned();
         let (escape, rest) = split_calendar(payload.trim());
-        let calendar = escape.unwrap_or_default();
         let (rest, phrase) = split_phrase(&rest);
+        // Both grammars put the calendar after a qualifier or a range word
+        // (`ABT @#DJULIAN@ 1700`, `BET JULIAN 1700 AND JULIAN 1710`): read
+        // there when the payload does not open with one, and only when every
+        // part of the payload names the same calendar.
+        let (escape, rest) = match escape {
+            Some(escape) => (Some(escape), rest),
+            None => match inner_calendar(&rest) {
+                Some((calendar, rest)) => (Some(calendar), rest),
+                None => (None, rest),
+            },
+        };
+        let calendar = escape.unwrap_or_default();
         let declared = escape.is_some();
         let dual = dual_year(&rest);
         let mut date = parse_expression(&rest)
@@ -690,7 +701,7 @@ fn parse_expression(input: &str) -> Option<GedcomDate> {
     // read (`FROM ABT 1924 TO 1959` puts a qualifier inside the range, which
     // neither version's grammar allows) would otherwise leave a range with
     // that end gone and nothing to say so.
-    if let Some((left, right)) = split_keyword(trimmed, &["AND", "ET", "UND", "OG"])
+    if let Some((left, right)) = split_keyword(trimmed, &RANGE_AND)
         && let Some(prefix) =
             strip_keyword(left, &["BET", "BETWEEN", "ENTRE", "ZWISCHEN", "MELLOM"])
     {
@@ -698,7 +709,7 @@ fn parse_expression(input: &str) -> Option<GedcomDate> {
         let to = parse_point(right)?;
         return build(DateKind::Between, Some(from), Some(to));
     }
-    if let Some((left, right)) = split_keyword(trimmed, &["TO", "AU", "BIS", "TIL"])
+    if let Some((left, right)) = split_keyword(trimmed, &RANGE_TO)
         && let Some(prefix) = strip_keyword(left, &["FROM", "DE", "DU", "VON", "FRA"])
     {
         let from = parse_point(prefix)?;
@@ -815,6 +826,81 @@ fn split_calendar(input: &str) -> (Option<Calendar>, String) {
     (None, input.to_owned())
 }
 
+/// The words between a range's ends, in every spelling the reader takes:
+/// `BET x AND y` and `FROM x TO y`.
+const RANGE_AND: [&str; 4] = ["AND", "ET", "UND", "OG"];
+const RANGE_TO: [&str; 4] = ["TO", "AU", "BIS", "TIL"];
+
+/// The words a calendar may follow inside a date: a qualifier, or a word of
+/// a range.
+const BEFORE_CALENDAR: [&str; 10] = [
+    "ABT", "CAL", "EST", "BEF", "AFT", "INT", "BET", "AND", "FROM", "TO",
+];
+
+/// The calendar named after a qualifier or a range word, and the payload
+/// without it, when at least one part names one and every naming agrees.
+/// A 5.5.1 escape (`@#DJULIAN@`, `@#DFRENCH R@`) or a GEDCOM 7 calendar word
+/// (`JULIAN`) is read only directly after one of [`BEFORE_CALENDAR`], so
+/// words elsewhere are left alone. Two different calendars, or a range
+/// whose ends do not all name one, give `None`, and the payload stays as it
+/// was for the reader to leave unparsed.
+fn inner_calendar(input: &str) -> Option<(Calendar, String)> {
+    let mut found: Option<Calendar> = None;
+    let mut kept: Vec<&str> = Vec::new();
+    let mut rest = input.trim();
+    let mut after_keyword = false;
+    let mut namings = 0;
+    while !rest.is_empty() {
+        let named = if after_keyword {
+            if let Some(escape) = rest.strip_prefix("@#D")
+                && let Some((name, remainder)) = escape.split_once('@')
+            {
+                Some((calendar_from(name), remainder))
+            } else {
+                let (word, remainder) = rest.split_once(' ').unwrap_or((rest, ""));
+                matches!(
+                    word,
+                    "GREGORIAN" | "JULIAN" | "HEBREW" | "FRENCH_R" | "ROMAN"
+                )
+                .then(|| (calendar_from(word), remainder))
+            }
+        } else {
+            None
+        };
+        if let Some((calendar, remainder)) = named {
+            if found.is_some_and(|known| known != calendar) {
+                return None;
+            }
+            found = Some(calendar);
+            namings += 1;
+            rest = remainder.trim_start();
+            after_keyword = false;
+            continue;
+        }
+        let (word, remainder) = rest.split_once(' ').unwrap_or((rest, ""));
+        after_keyword = BEFORE_CALENDAR
+            .iter()
+            .any(|keyword| word.eq_ignore_ascii_case(keyword));
+        kept.push(word);
+        rest = remainder.trim_start();
+    }
+    // Each end of a range names its own calendar; one left unnamed is
+    // Gregorian, which one date cannot hold beside another calendar.
+    let ends = 1 + kept
+        .iter()
+        .enumerate()
+        .filter(|(at, word)| {
+            let is = |words: &[&str]| words.iter().any(|w| word.eq_ignore_ascii_case(w));
+            is(&RANGE_AND) || (*at > 0 && is(&RANGE_TO))
+        })
+        .count();
+    // An unnamed end is Gregorian, which agrees only with a Gregorian one.
+    if namings != ends && found != Some(Calendar::Gregorian) {
+        return None;
+    }
+    found.map(|calendar| (calendar, kept.join(" ")))
+}
+
 /// The number of days in a month of a year, in the Julian calendar or the
 /// Gregorian. The year is counted as given, with no shift for the missing
 /// year zero; [`day_exists`] makes that shift before it asks.
@@ -2113,4 +2199,54 @@ mod tests {
             ["ABT 1875", "5 JAN 1882", "BET 1890 AND 1895", "1900"]
         );
     }
+    #[test]
+    fn a_calendar_after_a_qualifier_or_range_word_is_read() {
+        let julian = |text: &str| {
+            let date = GedcomDate::parse(text);
+            (date.calendar, date.kind, date.earliest, date.phrase)
+        };
+        let (calendar, kind, earliest, phrase) = julian("INT @#DJULIAN@ 2 MAR 1700 (x)");
+        assert_eq!(calendar, Calendar::Julian);
+        assert_eq!(kind, DateKind::Interpreted);
+        assert_eq!(
+            earliest.map(|point| (point.month, point.day)),
+            Some((Some(3), Some(2)))
+        );
+        assert_eq!(phrase.as_deref(), Some("x"));
+        for text in [
+            "BEF @#DJULIAN@ 2 JAN 1700",
+            "ABT JULIAN 1700",
+            "BET @#DJULIAN@ 1700 AND @#DJULIAN@ 1710",
+            "FROM JULIAN 1700 TO JULIAN 1710",
+        ] {
+            let date = GedcomDate::parse(text);
+            assert_eq!(date.calendar, Calendar::Julian, "{text}");
+            assert!(date.is_parsed(), "{text}");
+            assert_eq!(date.original, text);
+        }
+        assert_eq!(
+            GedcomDate::parse("BEF @#DJULIAN@ 2 JAN 1700").display(),
+            "before 2 January 1700"
+        );
+        // One end unnamed, or two calendars: not one date.
+        for text in [
+            "BET @#DJULIAN@ 1700 AND 1710",
+            "BET @#DJULIAN@ 1700 ET 1710",
+            "FROM @#DJULIAN@ 1700 BIS 1710",
+            "BET @#DJULIAN@ 1700 AND @#DGREGORIAN@ 1710",
+        ] {
+            let date = GedcomDate::parse(text);
+            assert!(!date.is_parsed(), "{text}");
+            assert_eq!(date.calendar, Calendar::Gregorian, "{text}");
+        }
+        // An unnamed end is Gregorian, so it agrees with a Gregorian one.
+        assert!(GedcomDate::parse("BET @#DGREGORIAN@ 1700 AND 1710").is_parsed());
+        // A calendar word anywhere else is no calendar.
+        assert!(!GedcomDate::parse("1700 JULIAN").is_parsed());
+        // What the 5.5.1 writer writes, the reader reads back.
+        let written = GedcomDate::parse("@#DJULIAN@ 1740/41").to_gedcom_5_5_1();
+        let back = GedcomDate::parse(written.as_deref().unwrap_or_default());
+        assert_eq!(back.calendar, Calendar::Julian);
+        assert_eq!(back.earliest.map(|point| point.year), Some(1740));
+    }
 }