mini-cite 0.2.0

BibTeX-backed inline citations and footnotes for the mini-* family.
Documentation
use super::*;

/// Parses `source`, asserting it succeeds, and returns the entries.
fn entries_of(source: &str) -> Vec<(String, Entry)> {
    parse_entries(source).expect("source should parse")
}

/// Looks up one entry by key, asserting it is present.
fn entry_named<'a>(entries: &'a [(String, Entry)], key: &str) -> &'a Entry {
    &entries
        .iter()
        .find(|(k, _)| k == key)
        .unwrap_or_else(|| panic!("no entry keyed `{key}`"))
        .1
}

#[test]
fn parses_single_entry() {
    let source = r#"
@article{smith2020,
  author = {Jane Smith},
  title = {On Small Things},
  year = {2020}
}
"#;

    let entries = entries_of(source);

    assert_eq!(entries.len(), 1);
    assert_eq!(entries[0].0, "smith2020");
    assert_eq!(entries[0].1.entry_type, "article");
    assert_eq!(entries[0].1.fields["author"], "Jane Smith");
    assert_eq!(entries[0].1.fields["title"], "On Small Things");
    assert_eq!(entries[0].1.fields["year"], "2020");
}

#[test]
fn parses_multiple_entries_in_one_source() {
    let source = r#"
@article{first, title = {First} }
@book{second, title = {Second} }
"#;

    let entries = entries_of(source);

    assert_eq!(entries.len(), 2);
    assert_eq!(entries[0].0, "first");
    assert_eq!(entries[1].0, "second");
    assert_eq!(entries[1].1.entry_type, "book");
}

#[test]
fn parses_quote_delimited_values() {
    let source = r#"@article{k, title = "A Quoted Title", year = "1999"}"#;

    let entry = &entries_of(source)[0].1;

    assert_eq!(entry.fields["title"], "A Quoted Title");
    assert_eq!(entry.fields["year"], "1999");
}

#[test]
fn parses_bare_undelimited_value() {
    let source = "@article{k, year = 2020}";

    assert_eq!(entries_of(source)[0].1.fields["year"], "2020");
}

#[test]
fn strips_nested_capitalization_braces_from_value() {
    let source = "@article{k, title = {A {Special} Title}}";

    assert_eq!(entries_of(source)[0].1.fields["title"], "A Special Title");
}

#[test]
fn keeps_comma_inside_braced_value_as_part_of_the_value() {
    let source = "@article{k, author = {Smith, Jane and Doe, John}, year = {2020}}";

    let entry = &entries_of(source)[0].1;

    assert_eq!(entry.fields["author"], "Smith, Jane and Doe, John");
    assert_eq!(entry.fields["year"], "2020");
}

#[test]
fn accepts_trailing_comma_after_last_field() {
    let source = "@article{k, title = {T}, year = {2020},}";

    let entry = &entries_of(source)[0].1;

    assert_eq!(entry.fields.len(), 2);
    assert_eq!(entry.fields["year"], "2020");
}

#[test]
fn collapses_whitespace_in_multi_line_value() {
    let source = r#"@article{k,
  title = {A Title That Spans
           More Than One
           Line}
}"#;

    assert_eq!(
        entries_of(source)[0].1.fields["title"],
        "A Title That Spans More Than One Line"
    );
}

#[test]
fn lowercases_field_names() {
    let source = "@article{k, Author = {A}, TITLE = {T}, YeAr = {2020}}";

    let entry = &entries_of(source)[0].1;

    assert_eq!(entry.fields["author"], "A");
    assert_eq!(entry.fields["title"], "T");
    assert_eq!(entry.fields["year"], "2020");
}

#[test]
fn lowercases_entry_type() {
    let source = "@ARTICLE{k, title = {T}}";

    assert_eq!(entries_of(source)[0].1.entry_type, "article");
}

#[test]
fn duplicate_field_name_keeps_last_value() {
    let source = "@article{k, title = {First}, title = {Second}}";

    let entry = &entries_of(source)[0].1;

    assert_eq!(entry.fields.len(), 1);
    assert_eq!(entry.fields["title"], "Second");
}

#[test]
fn discards_comment_block_without_affecting_neighbours() {
    let source = r#"
@article{before, title = {Before} }
@comment{ this is a note with an unbalanced-looking } brace pair {}
@article{after, title = {After} }
"#;

    let entries = entries_of(source);

    assert_eq!(entries.len(), 2);
    assert_eq!(entry_named(&entries, "before").fields["title"], "Before");
    assert_eq!(entry_named(&entries, "after").fields["title"], "After");
}

#[test]
fn discards_string_block_without_affecting_neighbours() {
    let source = r#"
@string{jml = {Journal of Minimal Things}}
@article{after, title = {After} }
"#;

    let entries = entries_of(source);

    assert_eq!(entries.len(), 1);
    assert_eq!(entries[0].0, "after");
}

#[test]
fn skips_stray_text_between_entries() {
    let source = r#"
This file was exported by a tool that writes prose headers.

@article{first, title = {First} }

Some more stray commentary, not an entry.

@book{second, title = {Second} }
"#;

    let entries = entries_of(source);

    assert_eq!(entries.len(), 2);
    assert_eq!(entries[0].0, "first");
    assert_eq!(entries[1].0, "second");
}

#[test]
fn empty_source_parses_to_no_entries() {
    assert!(entries_of("").is_empty());
    assert!(entries_of("\n  \n").is_empty());
}

#[test]
fn missing_closing_brace_is_a_parse_error() {
    let source = "@article{k, title = {Unterminated}";

    let error = parse_entries(source).expect_err("unterminated entry should not parse");

    assert!(
        matches!(&error, CiteError::Parse { file: None, message } if message.contains("closing")),
        "expected a Parse error mentioning the closing brace, got: {error}"
    );
}

#[test]
fn entry_without_opening_brace_is_a_parse_error() {
    let source = "@article";

    let error = parse_entries(source).expect_err("entry with no body should not parse");

    assert!(matches!(error, CiteError::Parse { .. }));
}

#[test]
fn field_without_equals_is_a_parse_error() {
    let source = "@article{k, title}";

    let error = parse_entries(source).expect_err("field with no `=` should not parse");

    assert!(
        matches!(&error, CiteError::Parse { message, .. } if message.contains('k')),
        "error should name the entry the bad field is in, got: {error}"
    );
}

#[test]
fn entry_without_citation_key_is_a_parse_error() {
    let source = "@article{, title = {T}}";

    let error = parse_entries(source).expect_err("entry with no key should not parse");

    assert!(
        matches!(&error, CiteError::Parse { message, .. } if message.contains("key")),
        "expected a Parse error mentioning the missing key, got: {error}"
    );
}

#[test]
fn entry_with_key_but_no_fields_parses_to_empty_fields() {
    let source = "@misc{lonely}";

    let entry = &entries_of(source)[0].1;

    assert_eq!(entry.entry_type, "misc");
    assert!(entry.fields.is_empty());
}