rustypaper 0.2.3__tar.gz → 0.2.4__tar.gz

{rustypaper-0.2.3 → rustypaper-0.2.4}/Cargo.lock

@@ -567,7 +567,7 @@ dependencies = [
 
 [[package]]
 name = "rustypaper"
-version = "0.2.3"
+version = "0.2.4"
 dependencies = [
  "anyhow",
  "clap",
@@ -580,7 +580,7 @@ dependencies = [
 
 [[package]]
 name = "rustypaper-py"
-version = "0.2.3"
+version = "0.2.4"
 dependencies = [
  "pyo3",
  "rustypaper",

{rustypaper-0.2.3 → rustypaper-0.2.4}/Cargo.toml

@@ -3,14 +3,14 @@ resolver = "2"
 members = ["rustypaper", "rustypaper-py"]
 
 [workspace.package]
-version = "0.2.3"
+version = "0.2.4"
 edition = "2021"
 rust-version = "1.94"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/pgarrett-scripps/rustypaper"
 
 [workspace.dependencies]
-rustypaper = { path = "rustypaper", version = "0.2.3" }
+rustypaper = { path = "rustypaper", version = "0.2.4" }
 # The pure-Rust PDF backend, from the registry. Deliberately not a path dependency: a path
 # only resolves where the sibling checkout happens to exist, which is this machine and not a
 # CI runner, and `cargo fmt --all` walks into it whether it is there or not. To develop the

{rustypaper-0.2.3 → rustypaper-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rustypaper
-Version: 0.2.3
+Version: 0.2.4
 Classifier: Programming Language :: Rust
 Classifier: Topic :: Text Processing :: Markup
 Classifier: Topic :: Scientific/Engineering

{rustypaper-0.2.3 → rustypaper-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rustypaper"
-version = "0.2.3"
+version = "0.2.4"
 description = "Structure-aware conversion of born-digital scientific PDFs to Markdown, Typst and JSON."
 readme = "README.md"
 requires-python = ">=3.9"

{rustypaper-0.2.3 → rustypaper-0.2.4}/rustypaper/src/backend/rustium.rs

@@ -278,6 +278,9 @@ fn collect_glyphs(page: &Page, space: &Space, fonts: &mut FontTable, raw: &mut P
             text,
             bbox,
             origin: space.point(g.origin),
+            // The page transform is rigid — shift, flip, `/Rotate` — so the advance length
+            // carries over from user space unchanged.
+            advance: g.advance,
             font,
             size: resolve_size(g.font_size, &bbox, angle),
             angle,

{rustypaper-0.2.3 → rustypaper-0.2.4}/rustypaper/src/doc.rs

@@ -560,11 +560,16 @@ fn join_lines(group: &[&Line], vocab: &Vocabulary) -> (String, Vec<Span>) {
         }
 
         let justified = line_reaches(group[i - 1], right_edge, group[i - 1].size);
-        match justified
-            .then(|| split_boundary(&out, &text))
-            .flatten()
-            .and_then(|(head, tail)| rejoin_across_break(vocab, head, tail))
-        {
+        match split_boundary(&out, &text).and_then(|(head, tail)| {
+            // A URL wrap is tried first and without the geometric guard: a line broken inside
+            // a URL often cannot be stretched to the margin, and a trailing hyphen there is
+            // part of the identifier, not a hyphenation to undo.
+            url_wrap(head, tail).or_else(|| {
+                justified
+                    .then(|| rejoin_across_break(vocab, head, tail))
+                    .flatten()
+            })
+        }) {
             Some(merged) => {
                 let head = head_len(&out);
                 let head_chars = out[out.len() - head..].chars().count();
@@ -659,11 +664,82 @@ fn rejoin_across_break(vocab: &Vocabulary, head: &str, tail: &str) -> Option<Str
     }
 }
 
+/// Joins a URL or DOI wrapped across a line break back into one token.
+///
+/// A typesetter breaks a long URL *after* a separator — `/`, `-`, `.`, `_` — and adds no
+/// hyphen, so the separator ending the line is itself the evidence of continuation. The word
+/// vocabulary knows nothing here, and the usual soft-hyphen removal would eat a `-` that is
+/// part of the identifier, which is why this runs before [`rejoin_across_break`].
+///
+/// Both sides are held to it. The head must already be inside a URL (a scheme, `www.`,
+/// `doi.org/`, or a bare DOI prefix) and end at a separator; the tail must be made of URL
+/// characters and carry a digit or a `/`, so a sentence that genuinely ends in a URL cannot
+/// swallow the capitalised word that starts the next one.
+fn url_wrap(head: &str, tail: &str) -> Option<String> {
+    let in_url = head.contains("://")
+        || head.starts_with("www.")
+        || head.starts_with("doi.org/")
+        || bare_doi_prefix(head);
+    if !in_url || !head.ends_with(['/', '-', '.', '_']) {
+        return None;
+    }
+    // A numbered bibliography's next entry starts with its own label — `15.`, `(15)`, `15)`,
+    // `[15]` or a bare `15` — and an entry often ends with a complete DOI and a final period,
+    // or a URL ending in `/`. That boundary looks exactly like a wrap (separator-ended head,
+    // digit-bearing tail) and must never be glued: one swallowed label collapses every entry
+    // after it. The one head that keeps its claim is a hyphen-ended one — an entry does not
+    // end mid-identifier at a hyphen, so `…08328-` + `5` is still the identifier's own tail.
+    if !head.ends_with('-') {
+        if label_shaped(tail) {
+            return None;
+        }
+        // A pure-digit tail after a final period is a year starting the next line, not a
+        // DOI fragment: every wrapped identifier observed continues with a slash, dot,
+        // hyphen or letter, never with bare digits alone.
+        if head.ends_with('.') && !tail.is_empty() && tail.bytes().all(|b| b.is_ascii_digit()) {
+            return None;
+        }
+    }
+    let urlish = tail
+        .chars()
+        .all(|c| c.is_ascii_alphanumeric() || "-._~/%#?=&:+();<>".contains(c));
+    let continues = tail.contains('/') || tail.chars().any(|c| c.is_ascii_digit());
+    (urlish && continues).then(|| format!("{head}{tail}"))
+}
+
+/// A reference label as bibliographies print them: one to three digits, bare, wrapped in
+/// `()` or `[]`, or followed by `.`, `)` or `]`.
+fn label_shaped(tail: &str) -> bool {
+    let digits = tail
+        .trim_start_matches(['(', '['])
+        .trim_end_matches(['.', ')', ']']);
+    !digits.is_empty() && digits.len() <= 3 && digits.bytes().all(|b| b.is_ascii_digit())
+}
+
+/// Whether `head` starts like a bare DOI: `10.` then at least four digits, with the
+/// registrant's `/` already seen.
+fn bare_doi_prefix(head: &str) -> bool {
+    head.strip_prefix("10.").is_some_and(|rest| {
+        rest.bytes().take_while(u8::is_ascii_digit).count() >= 4 && rest.contains('/')
+    })
+}
+
 /// Whether a line runs to the block's right edge, within one character's slack.
 fn line_reaches(line: &Line, right_edge: f32, size: f32) -> bool {
     right_edge - line.bbox.x1 <= size
 }
 
+/// Whether `left`'s last word and `right`'s first word are one URL wrapped across the break
+/// between two *blocks* — the test [`join_lines`] applies between two lines of one block,
+/// offered to the seam where a reference entry continues across a page or column break. The
+/// guards are [`url_wrap`]'s own: the caller decides only that the two texts are already a
+/// continuation, never that unrelated blocks should join.
+pub(crate) fn url_wrap_at_seam(left: &str, right: &str) -> bool {
+    split_boundary(left, right)
+        .and_then(|(head, tail)| url_wrap(head, tail))
+        .is_some()
+}
+
 /// The last word of `left` and the first word of `right`, if both exist.
 fn split_boundary<'a>(left: &'a str, right: &'a str) -> Option<(&'a str, &'a str)> {
     let head = left.rsplit(' ').next()?;
@@ -1235,6 +1311,73 @@ mod tests {
         assert_eq!(rejoin_across_break(&vocab, "learn-", "(ing)"), None);
     }
 
+    #[test]
+    fn a_url_broken_at_a_separator_rejoins_without_a_space() {
+        // The shapes the pilot papers print: broken after the scheme, after a path slash,
+        // after a dot inside the DOI, and at a hyphen that is part of the identifier.
+        assert_eq!(
+            url_wrap("https://", "doi.org/10.1038/s41467-019-08328-5"),
+            Some("https://doi.org/10.1038/s41467-019-08328-5".into())
+        );
+        assert_eq!(
+            url_wrap("https://doi.org/10.1186/", "s12974-021-02283-z."),
+            Some("https://doi.org/10.1186/s12974-021-02283-z.".into())
+        );
+        assert_eq!(
+            url_wrap("https://doi.org/10.", "1016/s0196-9781(02)00015-3"),
+            Some("https://doi.org/10.1016/s0196-9781(02)00015-3".into())
+        );
+        assert_eq!(
+            url_wrap("https://doi.org/10.1128/jb.181.21.6650-", "6655.1999"),
+            Some("https://doi.org/10.1128/jb.181.21.6650-6655.1999".into())
+        );
+        // A bare DOI with no scheme still counts as being inside a URL.
+        assert_eq!(
+            url_wrap("10.1016/j.", "expneurol.2015.05.005"),
+            Some("10.1016/j.expneurol.2015.05.005".into())
+        );
+    }
+
+    #[test]
+    fn a_sentence_ending_in_a_url_keeps_the_next_word_separate() {
+        // The tail is an ordinary word: no digit, no slash. The URL ended with the sentence.
+        assert_eq!(url_wrap("https://example.com/", "The"), None);
+        assert_eq!(url_wrap("https://example.com/survey.", "Respondents"), None);
+        // The head is not inside a URL at all.
+        assert_eq!(url_wrap("ratio.", "2020"), None);
+        assert_eq!(url_wrap("learn-", "ing"), None);
+        // The head ends mid-word, not at a separator a typesetter breaks after.
+        assert_eq!(url_wrap("https://doi.org/10.1038/srep", "14206"), None);
+        // An entry ending in a DOI and a period, with the next entry's label on the next
+        // line: the label is a new entry, not the DOI's continuation, in every style a
+        // bibliography prints one.
+        let entry_end = "https://doi.org/10.1101/2020.04.02.022277.";
+        for label in ["15.", "15", "15)", "(15)", "[15]", "15]", "7", "7."] {
+            assert_eq!(url_wrap(entry_end, label), None, "glued label {label:?}");
+        }
+        // The same labels after an entry whose URL ends in a slash.
+        for label in ["15.", "15", "15)", "(15)"] {
+            assert_eq!(
+                url_wrap("https://doi.org/10.1016/j.cell.2020.01.001/", label),
+                None,
+                "glued label {label:?} after a slash"
+            );
+        }
+        // A year starting the next line after a sentence-final URL is prose, not a DOI tail.
+        assert_eq!(url_wrap("https://example.com/survey.", "2010"), None);
+        assert_eq!(url_wrap("https://example.com/.", "3"), None);
+    }
+
+    #[test]
+    fn a_hyphen_ended_head_keeps_its_claim_on_a_digit_tail() {
+        // An entry does not end mid-identifier at a hyphen: `…08328-` + `5` is the
+        // identifier's own tail even though `5` alone is label-shaped.
+        assert_eq!(
+            url_wrap("https://doi.org/10.1038/s41467-019-08328-", "5"),
+            Some("https://doi.org/10.1038/s41467-019-08328-5".into())
+        );
+    }
+
     #[test]
     fn consecutive_body_lines_form_one_paragraph() {
         let page = vec![

{rustypaper-0.2.3 → rustypaper-0.2.4}/rustypaper/src/ir.rs

@@ -239,6 +239,11 @@ pub enum GlyphText {
 /// One rendered character.
 #[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
 pub struct Glyph {
+    /// Pen advance from this glyph's origin to the next, in page units along the baseline —
+    /// the displacement the PDF interpreter applied after showing it, character and word
+    /// spacing included. `0.0` means the backend does not know it, and the ink box has to
+    /// stand in for the pen.
+    pub advance: f32,
     pub text: GlyphText,
     /// Tight glyph bounds — the inked extent, used for baseline and script detection.
     pub bbox: Rect,
@@ -431,6 +436,7 @@ mod tests {
             text,
             bbox: Rect::from_corners(0.0, 0.0, 1.0, 1.0),
             origin: Point::new(0.0, 0.0),
+            advance: 0.0,
             font: FontId(0),
             size: 10.0,
             angle: 0.0,
@@ -465,6 +471,7 @@ mod tests {
             text: GlyphText::Char('a'),
             bbox: Rect::from_corners(0.0, 0.0, 1.0, 1.0),
             origin: Point::new(0.0, 0.0),
+            advance: 0.0,
             font: FontId(0),
             size: 10.0,
             angle: 0.0,

{rustypaper-0.2.3 → rustypaper-0.2.4}/rustypaper/src/layout/columns.rs

@@ -665,6 +665,7 @@ mod tests {
                 text: GlyphText::Char('x'),
                 bbox: Rect::from_corners(x, baseline - 7.0, x + 5.0, baseline),
                 origin: Point::new(x, baseline),
+                advance: 0.0,
                 font: FontId(0),
                 size: 10.0,
                 angle: 0.0,

{rustypaper-0.2.3 → rustypaper-0.2.4}/rustypaper/src/layout/furniture.rs

@@ -17,7 +17,7 @@
 //! that carries the whole document. See [`alternates`] for what stops that from being a licence
 //! to delete anything that repeats twice.
 
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 use crate::text::lines::Line;
 
@@ -92,6 +92,11 @@ pub fn strip(pages: &mut [Vec<Line>], page_heights: &[f32]) -> usize {
         .into_iter()
         .filter(|&at| alternates(at, total, &by_class))
         .collect();
+    let established: HashSet<&str> = seen
+        .iter()
+        .filter(|(_, &n)| n >= quorum)
+        .map(|(key, _)| key.as_str())
+        .collect();
 
     let mut removed = 0;
     for (index, (lines, &height)) in pages.iter_mut().zip(page_heights).enumerate() {
@@ -107,7 +112,7 @@ pub fn strip(pages: &mut [Vec<Line>], page_heights: &[f32]) -> usize {
                     .get(&(at, parity))
                     .and_then(|counts| counts.get(&key))
                     .is_some_and(|&n| n >= class_quorum(class_size(total, parity)));
-            let furniture = repeats || carries_its_class;
+            let furniture = repeats || carries_its_class || composed_of(&key, &established);
             removed += usize::from(furniture);
             !furniture
         });
@@ -116,6 +121,31 @@ pub fn strip(pages: &mut [Vec<Line>], page_heights: &[f32]) -> usize {
     removed
 }
 
+/// Whether a signature is two or more quorum-clearing signatures run together.
+///
+/// A running head set as two spans a fraction of a point apart builds as two lines on most pages
+/// and as one merged line where the baselines coincide. The merged line's own signature then
+/// appears only a handful of times — below any quorum — while each of its halves clears the
+/// whole-document quorum comfortably. Signatures concatenate exactly, because whitespace is
+/// dropped and case is folded, so the merged line can be recognised as the composition it is.
+///
+/// At least two parts are required: a line matching a single furniture signature is already
+/// covered by the quorum test, and demanding a genuine composition keeps this from being a
+/// second, laxer spelling of it.
+fn composed_of(sig: &str, established: &HashSet<&str>) -> bool {
+    fn splits(rest: &str, established: &HashSet<&str>, parts: usize) -> bool {
+        if rest.is_empty() {
+            return parts >= 2;
+        }
+        established.iter().any(|head| {
+            !head.is_empty()
+                && rest.starts_with(head)
+                && splits(&rest[head.len()..], established, parts + 1)
+        })
+    }
+    splits(sig, established, 0)
+}
+
 /// Whether the head at this margin alternates between recto and verso pages.
 ///
 /// This is the guard on the parity count, and it is what keeps a section heading that happens to
@@ -460,6 +490,54 @@ mod tests {
         );
     }
 
+    /// A head set as two spans half a point apart in baseline: line building keeps them apart on
+    /// most pages and merges them where the baselines coincide. The merged line's signature is
+    /// seen nowhere else, but it is exactly the concatenation of two signatures that each clear
+    /// the quorum, and it is as much furniture as its halves.
+    #[test]
+    fn a_merged_pair_of_furniture_lines_is_furniture() {
+        let mut pages: Vec<Vec<Line>> = (0..8)
+            .map(|i| {
+                let mut page = vec![line(&format!("body of page {}", i + 1), 300.0)];
+                if i == 5 {
+                    page.push(line(
+                        "Hamoud et al. Journal (2024) 22:287 Page 6 of 17",
+                        40.0,
+                    ));
+                } else {
+                    page.push(line("Hamoud et al. Journal (2024) 22:287", 40.0));
+                    page.push(line(&format!("Page {} of 17", i + 1), 40.5));
+                }
+                page
+            })
+            .collect();
+        let heights = vec![HEIGHT; 8];
+        strip(&mut pages, &heights);
+        assert!(
+            pages.iter().all(|p| p.len() == 1),
+            "the merged head is two furniture signatures run together, in {:?}",
+            pages
+                .iter()
+                .flatten()
+                .map(Line::text)
+                .collect::<Vec<String>>()
+        );
+    }
+
+    /// The composition test must not become a laxer spelling of the quorum: a margin line whose
+    /// signature matches a single furniture signature with something else appended is not a
+    /// concatenation of two established heads, and it stays.
+    #[test]
+    fn a_furniture_prefix_alone_does_not_compose() {
+        let (mut pages, heights) = document(8);
+        pages[0].push(line("Preprint. Under review. Comments welcome", 55.0));
+        strip(&mut pages, &heights);
+        assert!(
+            pages[0].iter().any(|l| l.text().ends_with("welcome")),
+            "one established head plus a one-off tail is not a composition"
+        );
+    }
+
     #[test]
     fn class_sizes_partition_the_document() {
         for total in 0..12 {

{rustypaper-0.2.3 → rustypaper-0.2.4}/rustypaper/src/math/build.rs

@@ -456,6 +456,7 @@ mod tests {
             text: GlyphText::Char(c),
             bbox: Rect::from_corners(x, baseline - size * 0.7, x + w, baseline),
             origin: Point::new(x, baseline),
+            advance: 0.0,
             font: FontId(0),
             size,
             angle: 0.0,

{rustypaper-0.2.3 → rustypaper-0.2.4}/rustypaper/src/math/mod.rs

@@ -638,6 +638,7 @@ mod tests {
                     text: GlyphText::Char(c),
                     bbox: Rect::from_corners(x, baseline - size * 0.7, x + w, baseline),
                     origin: Point::new(x, baseline),
+                    advance: 0.0,
                     font: FontId(font),
                     size,
                     angle: 0.0,

{rustypaper-0.2.3 → rustypaper-0.2.4}/rustypaper/src/pipeline.rs

@@ -443,7 +443,13 @@ fn extract_bibliography(document: &mut doc::Document) {
         } else {
             &block.text
         };
-        if !joined.is_empty() {
+        // A reference entry wraps its URL at the page or column break that split these
+        // blocks exactly as it wraps at a line break inside one — radiofrequency's
+        // `…10.3390/` ends one page and `ijerph192316150` opens the next. These blocks are
+        // already one bibliography being rejoined, so the seam gets the same test a line
+        // break gets, and the space is withheld only where its guards say the identifier
+        // continues.
+        if !joined.is_empty() && !doc::url_wrap_at_seam(&joined, body) {
             joined.push(' ');
         }
         origins.push((joined.len(), block));

{rustypaper-0.2.3 → rustypaper-0.2.4}/rustypaper/src/refs.rs

@@ -654,10 +654,24 @@ fn leading_label(text: &str) -> Option<(String, &str)> {
 /// publication year sits at the end in most styles. Two runs of four digits are ruled out first,
 /// because in the styles that put the year early the *last* number in the entry is one of them
 /// and the year is not — see [`in_a_page_range`] and [`arxiv_span`].
+///
+/// Two refinements of "the last one", both learned from entries where the last plausible year is
+/// not the year at all. Digits inside the DOI are stepped over the way the arXiv identifier is:
+/// `10.1016/j.sjbs.2014.07.006` embeds the year an identifier was minted, not the year printed on
+/// the entry. And a year the style *marks* — `(2022)` in author–year styles, `2022;` opening a
+/// Vancouver volume — beats an unmarked one, because a volume or article number can sit in the
+/// year band (`2021;1865(12):130014` is volume 1865) while a marked year is the style saying
+/// which number is the date.
+///
+/// Among marked years the *first* wins, unlike among plain ones. The hazard runs the other way:
+/// material swept into the entry's tail — a running header, the opening of the next entry at a
+/// column seam — arrives marked, while the entry's own marked year opens the citation.
 fn find_year(text: &str) -> Option<u16> {
     let chars: Vec<char> = text.chars().collect();
     let identifier = arxiv_span(&chars);
+    let doi = doi_char_span(text);
     let mut found = None;
+    let mut marked = None;
     for i in 0..chars.len().saturating_sub(3) {
         if !chars[i].is_ascii_digit() {
             continue;
@@ -675,16 +689,39 @@ fn find_year(text: &str) -> Option<u16> {
         if identifier.as_ref().is_some_and(|span| span.contains(&i)) {
             continue;
         }
+        if doi.as_ref().is_some_and(|span| span.contains(&i)) {
+            continue;
+        }
         if in_a_page_range(&chars, i) {
             continue;
         }
         if let Ok(year) = window.parse::<u16>() {
             if (1800..=2100).contains(&year) {
+                // `(2022)` and `(2022a)` are marked; so is the `2022;` that opens a Vancouver
+                // volume. `22(4)` is not: the parenthesis there encloses the issue, not the year,
+                // and an issue number never opens with one.
+                let in_parens = i > 0
+                    && chars[i - 1] == '('
+                    && match chars.get(i + 4) {
+                        Some(')') => true,
+                        Some(c) if c.is_ascii_lowercase() => chars.get(i + 5) == Some(&')'),
+                        _ => false,
+                    };
+                if in_parens || chars.get(i + 4) == Some(&';') {
+                    marked.get_or_insert(year);
+                }
                 found = Some(year);
             }
         }
     }
-    found
+    marked.or(found)
+}
+
+/// Where the DOI sits, as a span of character indices, so the year search can step over it.
+fn doi_char_span(text: &str) -> Option<std::ops::Range<usize>> {
+    let doi = find_doi(text)?;
+    let start = text[..text.find(&doi)?].chars().count();
+    Some(start..start + doi.chars().count())
 }
 
 /// Whether the four digits at `at` are one end of a page range.
@@ -1316,6 +1353,56 @@ mod tests {
         );
     }
 
+    /// A DOI embeds the year an identifier was minted, which can differ from the printed year.
+    #[test]
+    fn a_year_inside_a_doi_is_not_the_year() {
+        assert_eq!(
+            parse("Alkhalaf S. A title. Saudi J Biol Sci. 2015;22(4):465-9. 10.1016/j.sjbs.2014.07.006")
+                .year,
+            Some(2015)
+        );
+    }
+
+    /// Vancouver style reads `Journal. YYYY;volume(issue):pages`, and both the volume and an
+    /// article number can land in the band a year occupies.
+    #[test]
+    fn a_volume_or_article_number_does_not_beat_a_marked_year() {
+        assert_eq!(
+            parse("Berger B. A title. Biochim Biophys Acta Gen Subj. 2021;1865(12):130014.").year,
+            Some(2021)
+        );
+        // An article number is the worse trap: no dash, no parenthesis, just four digits last.
+        assert_eq!(
+            parse("Hu H, et al. A title. Int J Mol Sci. 2021;22(4):1831.").year,
+            Some(2021)
+        );
+    }
+
+    /// Author–year styles mark the year with parentheses, possibly with a disambiguating letter.
+    #[test]
+    fn a_parenthesised_year_beats_a_later_plain_one() {
+        assert_eq!(
+            parse("Kucukguven A, et al. (2022) A title. Ann Anat 240:151882, vol 2023.").year,
+            Some(2022)
+        );
+        assert_eq!(
+            parse("Smith J (2019a) A title. Journal 12, 2021.").year,
+            Some(2019)
+        );
+    }
+
+    /// Among marked years the first wins: what an entry sweeps up at its tail — a running header,
+    /// the next entry's opening at a column seam — arrives marked too, and the entry's own marked
+    /// year comes first.
+    #[test]
+    fn the_first_marked_year_beats_a_later_one() {
+        assert_eq!(
+            parse("Thul PJ, et al. A map. Science. 2017;356(6340):eaal3321. Hamoud et al. Journal (2024) 22:501")
+                .year,
+            Some(2017)
+        );
+    }
+
     #[test]
     fn finds_dois() {
         let parsed = parse("[1] A. B. A title. Journal, 2016. doi:10.1145/3292500.3330701");