Merge branch 'main' into fix-219

Author: DerDrodt

CHANGELOG.md

@@ -1,3 +1,11 @@
+# 0.8.0
+
+- **Breaking change:** Fixed deserialization of page ranges,
+  removing `From<u64> for PageRanges`
+- Added support for disambiguation to alphanumeric citation style
+- Raised limit for disambiguation resolving in complex cases
+- The year 0 will now render as 1BC for CSL
+
 # 0.7.0
 
 - **Breaking change:** `Entry::page_range` now returns

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hayagriva"
-version = "0.7.0"
+version = "0.8.0"
 authors = ["Martin Haug <[email protected]>"]
 edition = "2021"
 license = "MIT OR Apache-2.0"

README.md

@@ -105,7 +105,7 @@ default features by writing this in your `Cargo.toml`:
 
 ```toml
 [dependencies]
-hayagriva = { version = "0.7", default-features = false }
+hayagriva = { version = "0.8", default-features = false }
 ```
 
 ### Selectors

archive/styles/alphanumeric.cbor

@@ -1 +1 @@
-�dinfo�fauthor��dnamekMartin [email protected]�dnamenLaurenz Mädjeeemailx[email protected]�hcategory��p@citation-formatelabelefield�bidx!http://typst.org/csl/alphanumericdissn�dlink�frights�e$textqMIT OR Apache-2.0gsummary�f$valuevAlphanumeric citationsetitle�[email protected]�dsort�ckey��i@variablefauthore@sortiascending�i@variablefissuede@sortiascendingflayout�f$value��dtext�i@variablencitation-labele@formdlongg@quotes�n@strip-periods��g@prefixa[g@suffixa]j@delimiterb, x@disambiguate-add-givenname�x@givenname-disambiguation-rulegby-citew@disambiguate-add-names�x@disambiguate-add-year-suffix�i@collapseocitation-numberx@after-collapse-delimiterb; s@near-note-distance�f@classgin-textw@initialize-with-hyphen�x@demote-non-dropping-particlepdisplay-and-sortemacro�flocale��
+�dinfo�fauthor��dnamekMartin [email protected]�dnamenLaurenz Mädjeeemailx[email protected]�hcategory��p@citation-formatelabelefield�bidx!http://typst.org/csl/alphanumericdissn�dlink�frights�e$textqMIT OR Apache-2.0gsummary�f$valuevAlphanumeric citationsetitle�[email protected]�dsort�ckey��i@variablefauthore@sortiascending�i@variablefissuede@sortiascendingflayout�f$value��dtext�i@variablencitation-labele@formdlongg@quotes�n@strip-periods���dtext�i@variablekyear-suffixe@formdlongg@quotes�n@strip-periods��g@prefixa[g@suffixa]j@delimiterb, x@disambiguate-add-givenname�x@givenname-disambiguation-rulegby-citew@disambiguate-add-names�x@disambiguate-add-year-suffix�i@collapseocitation-numberx@after-collapse-delimiterb; s@near-note-distance�f@classgin-textw@initialize-with-hyphen�x@demote-non-dropping-particlepdisplay-and-sortemacro�flocale��

docs/file-format.md

@@ -154,7 +154,7 @@ This section lists all possible fields and data types for them.
 |------------------|-----------------------------------------------------------|
 | **Data type:**   | formattable string                                        |
 | **Description:** | title of the item                                         |
-| **Example:**     | `title: Rick Astley: How An Internet Joke Revived My Career` |
+| **Example:**     | `title: "Rick Astley: How An Internet Joke Revived My Career"` |
 
 #### `author`
 

src/csl/elem.rs

@@ -141,6 +141,9 @@ pub enum ElemMeta {
     Name(NameVariable, usize),
     /// The entry corresponds to a citation item.
     Entry(usize),
+    /// The element is the output of `cs:text` with a `variable` set to
+    /// `citation-label`.
+    CitationLabel,
 }
 
 /// A container for element children with useful methods.
@@ -165,20 +168,18 @@ impl ElemChildren {
 
     /// Retrieve a reference to the first child with a matching meta by
     /// DFS.
-    pub fn get_meta(&self, meta: ElemMeta) -> Option<&Elem> {
-        for child in &self.0 {
-            match child {
-                ElemChild::Elem(e) if e.meta == Some(meta) => return Some(e),
-                ElemChild::Elem(e) => {
-                    if let Some(e) = e.children.get_meta(meta) {
-                        return Some(e);
-                    }
-                }
-                _ => {}
-            }
-        }
-
-        None
+    pub fn find_meta(&self, meta: ElemMeta) -> Option<&Elem> {
+        self.find_elem_by(&|e| e.meta == Some(meta))
+    }
+
+    /// Retrieve a mutable reference to the first child matching the predicate
+    /// by DFS.
+    pub fn find_elem_by<F: Fn(&Elem) -> bool>(&self, f: &F) -> Option<&Elem> {
+        self.0.iter().find_map(|child| match child {
+            ElemChild::Elem(e) if f(e) => Some(e),
+            ElemChild::Elem(e) => e.children.find_elem_by(f),
+            _ => None,
+        })
     }
 
     /// Retrieve a mutable reference to the first child with a matching meta by

src/csl/mod.rs

@@ -212,7 +212,7 @@ impl<'a, T: EntryLike + Hash + PartialEq + Eq + Debug> BibliographyDriver<'a, T>
         //
         // If we have set the disambiguation state for an item, we need to set
         // the same state for all entries referencing that item.
-        for _ in 0..6 {
+        for _ in 0..16 {
             let ambiguous = find_ambiguous_sets(&res);
             if ambiguous.is_empty() {
                 break;
@@ -296,7 +296,7 @@ impl<'a, T: EntryLike + Hash + PartialEq + Eq + Debug> BibliographyDriver<'a, T>
 
                 let Some(name_elem) = cite.items[i]
                     .rendered
-                    .get_meta(ElemMeta::Names)
+                    .find_meta(ElemMeta::Names)
                     .map(|e| format!("{:?}", e))
                 else {
                     continue;
@@ -639,19 +639,9 @@ fn date_replacement<T: EntryLike>(
 
     ElemChildren(vec![ElemChild::Text(Formatted {
         text: if let Some(date) = date {
-            format!(
-                "{}{}",
-                if date.year > 0 { date.year } else { date.year.abs() + 1 },
-                if date.year < 1000 {
-                    if date.year < 0 {
-                        "BC"
-                    } else {
-                        "AD"
-                    }
-                } else {
-                    ""
-                }
-            )
+            let mut s = String::with_capacity(4);
+            write_year(date.year, false, &mut s).unwrap();
+            s
         } else if let Some(no_date) = ctx
             .ctx(entry, cite_props.clone(), locale, term_locale, false)
             .term(Term::Other(OtherTerm::NoDate), TermForm::default(), false)
@@ -664,6 +654,33 @@ fn date_replacement<T: EntryLike>(
     })])
 }
 
+pub fn write_year<W: std::fmt::Write>(
+    year: i32,
+    short: bool,
+    w: &mut W,
+) -> std::fmt::Result {
+    if short && year >= 1000 {
+        return write!(w, "{:02}", year % 100);
+    }
+
+    write!(
+        w,
+        "{}{}",
+        if year > 0 { year } else { year.abs() + 1 },
+        if year < 1000 {
+            if year <= 0 {
+                "BC"
+            } else {
+                // AD is used as a postfix, see
+                // https://docs.citationstyles.org/en/stable/specification.html?#ad-and-bc
+                "AD"
+            }
+        } else {
+            ""
+        }
+    )
+}
+
 fn last_purpose_render<T: EntryLike + Debug>(
     ctx: &StyleContext<'_>,
     item: &SpeculativeItemRender<T>,
@@ -764,19 +781,32 @@ fn disambiguate_year_suffix<F, T>(
     T: EntryLike + PartialEq,
     F: FnMut(&T, DisambiguateState),
 {
-    if renders
-        .iter()
-        .flat_map(|r| r.items.iter())
-        .any(|i| i.rendered.get_meta(ElemMeta::Date).is_some())
-        && group.iter().any(|&(cite_idx, item_idx)| {
-            renders[cite_idx].request.style.citation.disambiguate_add_year_suffix
-                && renders[cite_idx].items[item_idx]
-                    .cite_props
-                    .speculative
-                    .disambiguation
-                    .may_disambiguate_with_year_suffix()
-        })
-    {
+    if renders.iter().flat_map(|r| r.items.iter()).any(|i| {
+        let entry_has_date = i
+            .entry
+            .resolve_date_variable(DateVariable::Issued)
+            .or_else(|| i.entry.resolve_date_variable(DateVariable::Accessed))
+            .or_else(|| i.entry.resolve_date_variable(DateVariable::AvailableDate))
+            .or_else(|| i.entry.resolve_date_variable(DateVariable::EventDate))
+            .or_else(|| i.entry.resolve_date_variable(DateVariable::Submitted))
+            .or_else(|| i.entry.resolve_date_variable(DateVariable::OriginalDate))
+            .is_some();
+
+        i.rendered
+            .find_elem_by(&|e| {
+                // The citation label will contain the date if there is one.
+                e.meta == Some(ElemMeta::Date)
+                    || (entry_has_date && e.meta == Some(ElemMeta::CitationLabel))
+            })
+            .is_some()
+    }) && group.iter().any(|&(cite_idx, item_idx)| {
+        renders[cite_idx].request.style.citation.disambiguate_add_year_suffix
+            && renders[cite_idx].items[item_idx]
+                .cite_props
+                .speculative
+                .disambiguation
+                .may_disambiguate_with_year_suffix()
+    }) {
         let mut entries = Vec::new();
         for &(cite_idx, item_idx) in group.iter() {
             let item = &renders[cite_idx].items[item_idx];
@@ -911,7 +941,7 @@ fn collapse_items<'a, T: EntryLike>(cite: &mut SpeculativeCiteRender<'a, '_, T>)
                     // cannot be mutably borrowed below otherwise.
                     let item = &cite.items[i];
                     if item.hidden
-                        || item.rendered.get_meta(ElemMeta::CitationNumber).is_none()
+                        || item.rendered.find_meta(ElemMeta::CitationNumber).is_none()
                     {
                         end_range(&mut cite.items, &mut range_start, &mut just_collapsed);
                         continue;
@@ -3096,4 +3126,76 @@ mod tests {
             // }
         }
     }
+
+    #[test]
+    fn low_year_test() {
+        let yield_year = |year, short| {
+            let mut s = String::new();
+            write_year(year, short, &mut s).unwrap();
+            s
+        };
+
+        assert_eq!(yield_year(2021, false), "2021");
+        assert_eq!(yield_year(2021, true), "21");
+        assert_eq!(yield_year(0, false), "1BC");
+        assert_eq!(yield_year(-1, false), "2BC");
+        assert_eq!(yield_year(1, false), "1AD");
+        assert_eq!(yield_year(0, true), "1BC");
+        assert_eq!(yield_year(-1, true), "2BC");
+        assert_eq!(yield_year(1, true), "1AD");
+    }
+
+    #[test]
+    #[cfg(feature = "archive")]
+    fn test_alphanumeric_disambiguation() {
+        let bibtex = r#"@article{chenTransMorphTransformerUnsupervised2021,
+  title = {{{TransMorph}}: {{Transformer}} for Unsupervised Medical Image Registration},
+  author = {Chen, Junyu and Frey, Eric C. and He, Yufan and Segars, William P. and Li, Ye and Du, Yong},
+  date = {2021},
+}
+
+@article{chenViTVNetVisionTransformer2021,
+  title = {{{ViT-V-Net}}: {{Vision Transformer}} for {{Unsupervised Volumetric Medical Image Registration}}},
+  author = {Chen, Junyu and He, Yufan and Frey, Eric C. and Li, Ye and Du, Yong},
+  date = {2021},
+}"#;
+
+        let library = crate::io::from_biblatex_str(bibtex).unwrap();
+        let alphanumeric = archive::ArchivedStyle::Alphanumeric.get();
+        let citationberg::Style::Independent(alphanumeric) = alphanumeric else {
+            unreachable!()
+        };
+
+        let mut driver = BibliographyDriver::new();
+        for entry in library.iter() {
+            driver.citation(CitationRequest::new(
+                vec![CitationItem::with_entry(entry)],
+                &alphanumeric,
+                None,
+                &[],
+                None,
+            ));
+        }
+
+        let finished = driver.finish(BibliographyRequest {
+            style: &alphanumeric,
+            locale: None,
+            locale_files: &[],
+        });
+
+        let mut c1 = String::new();
+        let mut c2 = String::new();
+
+        finished.citations[0]
+            .citation
+            .write_buf(&mut c1, BufWriteFormat::Plain)
+            .unwrap();
+        finished.citations[1]
+            .citation
+            .write_buf(&mut c2, BufWriteFormat::Plain)
+            .unwrap();
+
+        assert_eq!(c1, "[Che+21a]");
+        assert_eq!(c2, "[Che+21b]");
+    }
 }

src/csl/rendering/mod.rs

@@ -20,7 +20,7 @@ use crate::types::{ChunkedString, Date, MaybeTyped, Numeric};
 use crate::PageRanges;
 
 use super::taxonomy::EntryLike;
-use super::{Context, ElemMeta, IbidState, SpecialForm, UsageInfo};
+use super::{write_year, Context, ElemMeta, IbidState, SpecialForm, UsageInfo};
 
 pub mod names;
 
@@ -126,6 +126,11 @@ impl RenderCsl for citationberg::Text {
                 {
                     Some(ElemMeta::CitationNumber)
                 }
+                TextTarget::Variable { var, .. }
+                    if var == StandardVariable::CitationLabel.into() =>
+                {
+                    Some(ElemMeta::CitationLabel)
+                }
                 TextTarget::Variable { .. } => Some(ElemMeta::Text),
                 _ => None,
             },
@@ -769,17 +774,8 @@ fn render_date_part<T: EntryLike>(
                     write!(ctx, "{}", val).unwrap();
                 }
             }
-            DateStrongAnyForm::Year(LongShortForm::Short) => {
-                write!(ctx, "{:02}", (val % 100).abs()).unwrap();
-            }
-            DateStrongAnyForm::Year(LongShortForm::Long) => {
-                write!(ctx, "{}", val.abs()).unwrap();
-            }
-        }
-
-        if let DateStrongAnyForm::Year(_) = form {
-            if date.year < 1000 {
-                ctx.push_str(if date.year < 0 { "BC" } else { "AD" });
+            DateStrongAnyForm::Year(brevity) => {
+                write_year(val, brevity == LongShortForm::Short, ctx).unwrap();
             }
         }
     }

src/csl/taxonomy.rs

@@ -810,8 +810,15 @@ impl EntryLike for citationberg::json::Item {
     ) -> Option<MaybeTyped<PageRanges>> {
         match variable {
             PageVariable::Page => match self.0.get("page")? {
-                csl_json::Value::Number(n) => {
-                    Some(MaybeTyped::Typed(PageRanges::from(*n as u64)))
+                &csl_json::Value::Number(n) => {
+                    // Page ranges use i32 internally, so we check whether the
+                    // number is in range.
+                    Some(match i32::try_from(n) {
+                        Ok(n) => MaybeTyped::Typed(PageRanges::from(n)),
+                        // If the number is not in range, we degrade to a
+                        // string, which disables some CSL features.
+                        Err(_) => MaybeTyped::String(n.to_string()),
+                    })
                 }
                 csl_json::Value::String(s) => {
                     let res = MaybeTyped::<PageRanges>::infallible_from_str(s);

src/lib.rs

@@ -91,7 +91,7 @@ default features by writing this in your `Cargo.toml`:
 
 ```toml
 [dependencies]
-hayagriva = { version = "0.7", default-features = false }
+hayagriva = { version = "0.8", default-features = false }
 ```
 
 # Selectors