use std::collections::HashMap;
use std::sync::LazyLock;
use super::lint_directive_verb;
use crate::bib::ast;
use crate::bib::syntax::{SyntaxKind, SyntaxNode};
use crate::directives::Verb;
const FIELD_ORDER: &[&str] = &[
"title",
"subtitle",
"titleaddon",
"shorttitle",
"author",
"shortauthor",
"editor",
"shorteditor",
"editortype",
"translator",
"bookauthor",
"journaltitle",
"journal",
"journalsubtitle",
"shortjournal",
"booktitle",
"booksubtitle",
"booktitleaddon",
"maintitle",
"mainsubtitle",
"maintitleaddon",
"eventtitle",
"eventtitleaddon",
"date",
"year",
"month",
"day",
"eventdate",
"publisher",
"institution",
"school",
"organization",
"location",
"address",
"series",
"volume",
"volumes",
"number",
"issue",
"edition",
"version",
"chapter",
"part",
"pages",
"pagetotal",
"eid",
"doi",
"eprint",
"eprinttype",
"archiveprefix",
"eprintclass",
"primaryclass",
"isbn",
"issn",
"isrn",
"url",
"urldate",
"type",
"howpublished",
"pubstate",
"language",
"langid",
"note",
"addendum",
"abstract",
"annotation",
"annote",
"keywords",
"crossref",
"xref",
"xdata",
"related",
"relatedtype",
"relatedstring",
"file",
"pdf",
];
static FIELD_RANKS: LazyLock<HashMap<&'static str, usize>> = LazyLock::new(|| {
FIELD_ORDER
.iter()
.enumerate()
.map(|(rank, &name)| (name, rank))
.collect()
});
pub(super) fn canonical_fields(entry: &SyntaxNode) -> Vec<SyntaxNode> {
let mut fields: Vec<SyntaxNode> = ast::fields(entry).collect();
fields.sort_by_cached_key(|field| {
let name = ast::field_name(field).unwrap_or_default().to_lowercase();
match FIELD_RANKS.get(name.as_str()) {
Some(&rank) => (0u8, rank, String::new()),
None => (1u8, 0usize, name),
}
});
fields
}
pub(super) fn sorted_blocks(
root: &SyntaxNode,
protected: impl Fn(&SyntaxNode) -> bool,
) -> Vec<SyntaxNode> {
let blocks: Vec<SyntaxNode> = root.children().collect();
let mut pinned = skip_targets(&blocks);
for (block, pinned) in blocks.iter().zip(&mut pinned) {
*pinned |= protected(block);
}
let mut result: Vec<SyntaxNode> = Vec::with_capacity(blocks.len());
let mut i = 0;
while i < blocks.len() {
if blocks[i].kind() != SyntaxKind::ENTRY || pinned[i] {
result.push(blocks[i].clone());
i += 1;
continue;
}
let start = i;
while i < blocks.len() && blocks[i].kind() == SyntaxKind::ENTRY && !pinned[i] {
i += 1;
}
result.extend(segment_in_order(&blocks[start..i]));
}
result
}
fn skip_targets(blocks: &[SyntaxNode]) -> Vec<bool> {
let mut pinned = vec![false; blocks.len()];
let mut pending_skip = false;
for (index, block) in blocks.iter().enumerate() {
if block.kind() == SyntaxKind::COMMENT_ENTRY {
pending_skip |= matches!(lint_directive_verb(block), Some(Verb::Skip));
continue;
}
if pending_skip && block.kind() == SyntaxKind::ENTRY {
pinned[index] = true;
}
pending_skip = false;
}
pinned
}
fn segment_in_order(segment: &[SyntaxNode]) -> Vec<SyntaxNode> {
let mut entries = segment.to_vec();
if segment.iter().any(has_cross_reference) {
return entries;
}
entries.sort_by_cached_key(|entry| {
ast::cite_key(entry)
.map(|(key, _)| key.to_lowercase())
.unwrap_or_default()
});
entries
}
fn has_cross_reference(entry: &SyntaxNode) -> bool {
ast::fields(entry).any(|field| {
ast::field_name(&field).is_some_and(|name| {
let lc = name.to_lowercase();
lc == "crossref" || lc == "xdata"
})
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::bib::parse;
use crate::bib::semantic::builtin;
fn entry(src: &str) -> SyntaxNode {
parse(src)
.syntax()
.descendants()
.find(|n| n.kind() == SyntaxKind::ENTRY)
.expect("an ENTRY node")
}
fn ordered_names(entry: &SyntaxNode) -> Vec<String> {
canonical_fields(entry)
.iter()
.map(|f| ast::field_name(f).unwrap_or_default().to_lowercase())
.collect()
}
fn ordered_keys(src: &str) -> Vec<String> {
sorted_blocks(&parse(src).syntax(), |_| false)
.iter()
.filter_map(|b| ast::cite_key(b).map(|(k, _)| k))
.collect()
}
#[test]
fn fields_sorted_to_canonical_order() {
let e = entry("@article{k, year = 2020, title = {T}, author = {A}}\n");
assert_eq!(ordered_names(&e), ["title", "author", "year"]);
}
#[test]
fn title_first_order_is_shared_by_all_entry_types() {
for etype in builtin().entry_names().chain(["weirdtype"]) {
let e = entry(&format!(
"@{etype}{{k, url = {{U}}, date = {{2020}}, author = {{A}}, title = {{T}}}}\n"
));
assert_eq!(
ordered_names(&e),
["title", "author", "date", "url"],
"field order differs for @{etype}"
);
}
}
#[test]
fn unknown_fields_alphabetized_after_known() {
let e = entry("@article{k, zzz = {z}, author = {A}, aaa = {a}}\n");
assert_eq!(ordered_names(&e), ["author", "aaa", "zzz"]);
}
#[test]
fn unknown_entry_type_uses_shared_order_and_alphabetical_tail() {
let e = entry(
"@weirdtype{k, charlie = {c}, Author = {A}, alpha = {a}, TITLE = {T}, bravo = {b}}\n",
);
assert_eq!(
ordered_names(&e),
["title", "author", "alpha", "bravo", "charlie"]
);
}
#[test]
fn duplicate_field_names_keep_source_order() {
let e = entry("@misc{k, note = {first}, title = {T}, NOTE = {second}}\n");
let values: Vec<String> = canonical_fields(&e)
.iter()
.filter(|f| ast::field_name(f).is_some_and(|name| name.eq_ignore_ascii_case("note")))
.map(|f| ast::field_value(f).unwrap().to_string())
.collect();
assert_eq!(values, ["{first}", "{second}"]);
}
#[test]
fn entries_sorted_by_key_case_insensitive() {
let keys = ordered_keys("@misc{Charlie}\n@misc{alpha}\n@misc{Bravo}\n");
assert_eq!(keys, ["alpha", "Bravo", "Charlie"]);
}
#[test]
fn string_def_is_a_barrier() {
let blocks = sorted_blocks(
&parse("@misc{zoo}\n@string{m = \"x\"}\n@misc{apple}\n").syntax(),
|_| false,
);
assert_eq!(ast::cite_key(&blocks[0]).unwrap().0, "zoo");
assert_eq!(blocks[1].kind(), SyntaxKind::STRING_ENTRY);
assert_eq!(ast::cite_key(&blocks[2]).unwrap().0, "apple");
}
#[test]
fn lint_skip_target_is_not_reordered() {
let keys = ordered_keys(
"@comment{badness-lint skip unknown-field}\n\
@misc{zulu, unknown = {U}}\n\
@misc{alpha, title = {A}}\n",
);
assert_eq!(keys, ["zulu", "alpha"]);
}
#[test]
fn crossref_segment_left_in_source_order() {
let keys = ordered_keys(
"@inproceedings{zzz, crossref = {proc}}\n@proceedings{proc, title = {P}}\n",
);
assert_eq!(keys, ["zzz", "proc"]);
}
}